Subversion Repositories Integrator Subversion

package br.com.sl.controller;

import java.io.Serializable;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.stream.Collectors;

import javax.faces.application.FacesMessage;

import javax.inject.Inject;

import javax.inject.Named;

import org.primefaces.PrimeFaces;

import org.springframework.context.annotation.Scope;

import br.com.ec.core.generic.GenericService;

import br.com.ec.core.util.VerificadorUtil;

import br.com.ec.web.exception.VerificadorLancamentoException;

import br.com.ec.web.exception.VerificadorLancamentoException.CommandBean;

import br.com.ec.web.generic.AbstractBean;

import br.com.ec.web.message.LancadorMensagem;

import br.com.kronus.core.PadraoGatilho;

import br.com.kronus.strategy.ResultadoEstrategiaGatilho3;

import br.com.sl.domain.dto.RoboDTO;

import br.com.sl.domain.dto.robo.AlertaPadraoService;

import br.com.sl.domain.dto.robo.SinalTradeGatilho3;

import br.com.sl.domain.model.tipos.TipoFonteDadosProfit;

import br.com.sl.domain.service.RoboOperadorService;

@Named

@Scope("view")

public class RoboBean extends AbstractBean<RoboDTO> implements Serializable {

        private RoboOperadorService roboOperadorService;

//      private TipoFonteDadosProfit tipoFonteSelecionada = TipoFonteDadosProfit.HISTORICO;

        private List<PadraoGatilho> padroesEmAberto;

        private Integer contadorUltimoCandle;

        private List<PadraoGatilho> padroes;

        private List<PadraoGatilho> padroesComG3;  // completos (G3 != null)

    private List<PadraoGatilho> padroesAteG2;  // parciais (G2 != null && G3 == null)

    private List<SinalTradeGatilho3> sinaisTradeGatilho3;

    private List<ResultadoEstrategiaGatilho3> resultados;

        @Inject

        public RoboBean(RoboOperadorService roboOperadorService) {

                this.roboOperadorService = roboOperadorService;

        }

        @Override

        public void preCarregamento() {

                limparEntidade();

                getEntidade().setRodando(roboOperadorService.isRodando());

        }

        @Override

        public void limparEntidade() {

                setEntidade(new RoboDTO());

                setPadroes(new ArrayList<PadraoGatilho>());

                setPadroesComG3(new ArrayList<PadraoGatilho>());

                setPadroesAteG2(new ArrayList<PadraoGatilho>());

                setSinaisTradeGatilho3(new ArrayList<SinalTradeGatilho3>());

                setResultados(new ArrayList<ResultadoEstrategiaGatilho3>());

        }

        @Override

        public GenericService<RoboDTO> getService() {

                return roboOperadorService;

        }

        @Override

        public RoboDTO getEntidade() {

                return entidade;

        }

        @Override

        public RoboDTO getId() {

                return getEntidade();

        }

        public List<PadraoGatilho> getPadroes() {

                return padroes;

        }

        public void setPadroes(List<PadraoGatilho> padroes) {

                this.padroes = padroes;

        }

        public List<SinalTradeGatilho3> getSinaisTradeGatilho3() {

                return sinaisTradeGatilho3;

        }

        public void setSinaisTradeGatilho3(List<SinalTradeGatilho3> sinaisTradeGatilho3) {

                this.sinaisTradeGatilho3 = sinaisTradeGatilho3;

        }

        public List<ResultadoEstrategiaGatilho3> getResultados() {

                return resultados;

        }

        public void setResultados(List<ResultadoEstrategiaGatilho3> resultados) {

                this.resultados = resultados;

        }

        public List<PadraoGatilho> getPadroesComG3() {

                return padroesComG3;

        }

        public void setPadroesComG3(List<PadraoGatilho> padroesComG3) {

                this.padroesComG3 = padroesComG3;

        }

        public List<PadraoGatilho> getPadroesAteG2() {

                return padroesAteG2;

        }

        public void setPadroesAteG2(List<PadraoGatilho> padroesAteG2) {

                this.padroesAteG2 = padroesAteG2;

        }

        public void iniciar() {

                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {

                        public void execute() {

                                // ANALISAR POR HISTÓRICO

                                getEntidade().setAnalisarPorHistoricoArquivo(false);

                                roboOperadorService.iniciarOperacao(getEntidade().getAnalisarPorHistoricoArquivo());

                                setEntidade(roboOperadorService.statusRobo());

                                LancadorMensagem.lancarSucesso("ROBÔ INICIADO COM SUCESSO!");

                        }

                });

    }

    public void parar() {

        new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {

                        public void execute() {

                                roboOperadorService.pararOperacao();

                                setEntidade(roboOperadorService.statusRobo());

                                LancadorMensagem.lancarSucesso("ROBÔ PARADO COM SUCESSO!");

                        }

                });

    }

    public void preencherOutrosPadroes() {

                padroesComG3 = padroes.stream()

                .filter(p -> p.getGatilho2() != null && p.getGatilho3() != null)

                .collect(Collectors.toList());

                inverterLista(padroesComG3);

        padroesAteG2 = padroes.stream()

                .filter(p -> p.getGatilho2() != null && p.getGatilho3() == null)

                .collect(Collectors.toList());

        inverterLista(padroesAteG2);

        }

    public static List<PadraoGatilho> inverterLista(List<PadraoGatilho> candles) {

        List<PadraoGatilho> invertida = new ArrayList<>(candles);

        Collections.reverse(invertida);

        return invertida;

    }

    public void atualizarStatus() {

        setEntidade(roboOperadorService.statusRobo());

        if (VerificadorUtil.naoEstaNuloOuVazio(getEntidade().getPadroes())) {

                if (getEntidade().getPadroes().size() != getPadroes().size()) {

                        AlertaPadraoService.novoAlerta("NOVO PADRÃO IDENTIFICADO!");

                        PrimeFaces.current().executeScript("playAlertaAgressivo();");

                }

                setPadroes(getEntidade().getPadroes());

                preencherOutrosPadroes();

                setSinaisTradeGatilho3(getEntidade().getSinaisTradeGatilho3());

                setResultados(getEntidade().getResultados());

        }

        verificarNovosPadroes();

    }

    public void verificarNovosPadroes() {

        List<String> alertas = AlertaPadraoService.consumirAlertas();

        if (!alertas.isEmpty()) {

            for (String msg : alertas) {

                FacesMessage facesMessage = new FacesMessage(

                        FacesMessage.SEVERITY_INFO,

                        "Novo padrão identificado",

                        msg

                );

                javax.faces.context.FacesContext.getCurrentInstance()

                        .addMessage(null, facesMessage);

            }

            // Toca o som no cliente

            PrimeFaces.current().executeScript("playBeepPadrao();");

            // Se estiver em PF antigo:

            // RequestContext.getCurrentInstance().execute("playBeepPadrao();");

        }

    }

}