Subversion Repositories Integrator Subversion

package br.com.sl.controller;

import javax.inject.Inject;
import javax.inject.Named;

import org.primefaces.event.FileUploadEvent;
import org.primefaces.model.file.UploadedFile;
import org.primefaces.model.file.UploadedFiles;
import org.springframework.context.annotation.Scope;

import br.com.ec.core.generic.GenericService;
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.sl.domain.dto.SinaisResultadoDTO;
import br.com.sl.domain.service.AnalisadorPadroesService;

@Named
@Scope("view")
public class VerificadorSinaisBean extends AbstractBean<SinaisResultadoDTO>  {
       
        private UploadedFiles arquivos;
       
        private AnalisadorPadroesService analisadorPadroesService;

        @Inject
        public VerificadorSinaisBean(AnalisadorPadroesService analisadorPadroesService) {
                this.analisadorPadroesService = analisadorPadroesService;
        }
       
        @Override
        public void preCarregamento() {
                limparEntidade();
        }
   
    @Override
        public SinaisResultadoDTO getId() {
                return null;
        }

        @Override
        public GenericService<SinaisResultadoDTO> getService() {
                return null;
        }

        @Override
        public void limparEntidade() {
                setEntidade(new SinaisResultadoDTO());
                setArquivos(new UploadedFiles());
        }
       
        public UploadedFiles getArquivos() {
                return arquivos;
        }
        public void setArquivos(UploadedFiles arquivos) {
                this.arquivos = arquivos;
        }
   
        public void analisarViaUpload() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                analisadorPadroesService.analisarPadroesViaArquivos(getEntidade(), getArquivos());
                                LancadorMensagem.lancarSucesso("DADOS ANALISADOS COM SUCESSO!");
                        }
                });
    }

}

       
/*
        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 VerificadorSinaisBean(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() {
       
    }
}
 */