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.core.PadraoGatilho.TipoPadrao;

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 String tipoFonteSelecionada;

        private Integer contadorCandleParaVerificar;

        private List<String> logs;

        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>());

//              setTipoFonteSelecionada(TipoFonteDadosProfit.TEMPO_REAL.getValor());

                setContadorCandleParaVerificar(0);

        }

        @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 String getTipoFonteSelecionada() {

                return tipoFonteSelecionada;

        }

        public void setTipoFonteSelecionada(String tipoFonteSelecionada) {

                this.tipoFonteSelecionada = tipoFonteSelecionada;

        }

        public TipoFonteDadosProfit[] getTiposFonteDadosProfit() {

                return TipoFonteDadosProfit.values();

        }

        public List<String> getLogs() {

                return logs;

        }

        public void setLogs(List<String> logs) {

                this.logs = logs;

        }

        public String getLogsBacktestAsText() {

            if (logs == null || logs.isEmpty()) return "";

            return String.join("\n", logs);

        }

        public Integer getContadorCandleParaVerificar() {

                return contadorCandleParaVerificar;

        }

        public void setContadorCandleParaVerificar(Integer contadorCandleParaVerificar) {

                this.contadorCandleParaVerificar = contadorCandleParaVerificar;

        }

        public void iniciar() {

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

                        public void execute() {

                                roboOperadorService.iniciarOperacao(getTipoFonteSelecionada(), getContadorCandleParaVerificar());

                                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.getTipoPadrao() == TipoPadrao.COMPLETO_G3)

                .collect(Collectors.toList());

        padroesComG3 = inverterLista(padroesComG3);

        padroesAteG2 = padroes.stream()

                        .filter(p -> p.getTipoPadrao() == TipoPadrao.PARCIAL_G2)

                .collect(Collectors.toList());

        padroesAteG2 = 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());

                setLogs(getEntidade().getLogs());

                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();");

        }

    }

    public void verificarCandle() {

    }

}