Subversion Repositories Integrator Subversion

package br.com.ec.controller;

import java.io.Serializable;

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

import org.primefaces.model.StreamedContent;
import org.springframework.context.annotation.Scope;

import br.com.ec.controller.consultademanda.NotaFiscalConsultaPorDemanda;
import br.com.ec.core.generic.GenericService;
import br.com.ec.domain.dto.consulta.ParametrosConsultaNotaFiscal;
import br.com.ec.domain.model.NotaFiscal;
import br.com.ec.domain.model.Venda;
import br.com.ec.domain.model.nfe.TipoNotaFiscal;
import br.com.ec.domain.service.EmissorRelatorioService;
import br.com.ec.domain.service.NotaFiscalService;
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.ec.web.util.TipoOperacao;

@Named
@Scope("view")
public class NotaFiscalBean extends AbstractBean<NotaFiscal> implements Serializable {

        private static final long serialVersionUID = 1L;
       
        private NotaFiscalService notaFiscalService;
        private EmissorRelatorioService emissorRelatorioService;
       
        private ParametrosConsultaNotaFiscal parametrosConsultaNotaFiscal;
        private NotaFiscalConsultaPorDemanda lazy;
       
        private Long sequencialVendaParaVinculo;
        private StreamedContent danfeNfe;

        @Inject
        public NotaFiscalBean(NotaFiscalConsultaPorDemanda lazy, NotaFiscalService notaFiscalService, EmissorRelatorioService emissorRelatorioService) {
                this.lazy = lazy;
                this.notaFiscalService = notaFiscalService;
                this.emissorRelatorioService = emissorRelatorioService;
        }
       
        @Override
        public void preCarregamento() {
                parametrosConsultaNotaFiscal = new ParametrosConsultaNotaFiscal();
                prepararConsultaDemanda();
                limparEntidade();
        }

        @Override
        public void limparEntidade() {
                setEntidade(new NotaFiscal());
        }

        @Override
        public GenericService<NotaFiscal> getService() {
                return notaFiscalService;
        }
       
        @Override
        public NotaFiscal getEntidade() {
                return entidade;
        }
       
        @Override
        public void preConsultar() {
                setTipoOperacao(TipoOperacao.CONSULTAR);
        }

        @Override
        public NotaFiscal getId() {
                return getEntidade();
        }
       
        public ParametrosConsultaNotaFiscal getParametrosConsultaNotaFiscal() {
                return parametrosConsultaNotaFiscal;
        }
        public void setParametrosConsultaNotaFiscal(ParametrosConsultaNotaFiscal parametrosConsultaNotaFiscal) {
                this.parametrosConsultaNotaFiscal = parametrosConsultaNotaFiscal;
        }
       
        public NotaFiscalConsultaPorDemanda getLazy() {
                return lazy;
        }
        public void setLazy(NotaFiscalConsultaPorDemanda lazy) {
                this.lazy = lazy;
        }
        public void prepararConsultaDemanda() {
                lazy.setarParametrosConsulta(getParametrosConsultaNotaFiscal());
        }
       
        public TipoNotaFiscal[] getTiposNotaFiscal() {
                return TipoNotaFiscal.values();
        }
       
        public Long getSequencialVendaParaVinculo() {
                return sequencialVendaParaVinculo;
        }
        public void setSequencialVendaParaVinculo(Long sequencialVendaParaVinculo) {
                this.sequencialVendaParaVinculo = sequencialVendaParaVinculo;
        }
       
        public StreamedContent getDanfeNfe() {
                return danfeNfe;
        }
        public void setDanfeNfe(StreamedContent danfeNfe) {
                this.danfeNfe = danfeNfe;
        }
       
        /**************************************************/
       
        public void desvincularVenda() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                notaFiscalService.desvincularVenda(getEntidade().getSequencial());
                                getEntidade().setVenda(null);
                                LancadorMensagem.lancarSucesso("VENDA DESVINCULADA COM SUCESSO");
                        }
                });
        }
       
        public void vincularVenda() {
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
                        public void execute() {
                                Venda vendaVinculada = notaFiscalService.vincularVenda(getEntidade().getSequencial(), getSequencialVendaParaVinculo());
                                getEntidade().setVenda(vendaVinculada);
                                LancadorMensagem.lancarSucesso("VENDA VINCULADA COM SUCESSO");
                        }
                });
        }
       
        public void emitirDanfeNfe(Long sequencialNotaFiscal) {
                setDanfeNfe(notaFiscalService.gerarDanfeNfe(sequencialNotaFiscal));
                /*
                return new VerificadorLancamentoException().verificarLancamentoException(new CommandRelatorioStreamedContent() {
                        @Override
                        public StreamedContent execute() {
                                return notaFiscalService.gerarDanfeNfe(getEntidade().getSequencial());
                        }
                });
                */
        }
       
        /*
         private StreamedContent chart;
         public StreamedContent getChart() {
                 return chart;
         }
         private PieDataset createDataset() {
                 DefaultPieDataset dataset = new DefaultPieDataset();
                 dataset.setValue("New York", new Double(45.0));
                 dataset.setValue("London", new Double(15.0));
                 dataset.setValue("Paris", new Double(25.2));
                 dataset.setValue("Berlin", new Double(14.8));
                 return dataset;
         }
       
         private StreamedContent escala;
         public StreamedContent getEscala() {
                 return escala;
         }
         
         private StreamedContent escalaPdf;
         public StreamedContent getEscalaPdf() {
                 return escalaPdf;
         }
         public String generateRandomIdForNotCaching() {
                 return java.util.UUID.randomUUID().toString();
         }
       
         private void criarImagens() {
                 try {
                         InputStream arquivoPdf = FacesContext.getCurrentInstance().getExternalContext().getResourceAsStream("/imagens/escala-202310.pdf");
                         byte[] bytePdf = ArquivoUtil.retornarBytesPassandoInputStream(arquivoPdf);
                         ByteArrayOutputStream osPdf = new ByteArrayOutputStream();
                         PdfReader reader = new PdfReader(bytePdf);
                         escalaPdf = DefaultStreamedContent.builder()
                            .contentType("application/pdf")
                            .name("escala-202310.pdf")
                            .stream(() -> {
                                                try {
                                                        return ArquivoUtil.gerarInputStreamDeArquivo(bytePdf);
                                                } catch (IOException e1) {
                                                        e1.printStackTrace();
                                                }
                                                return arquivoPdf;
                                        })
                            .build();
                         
                         
                         InputStream arquivo = FacesContext.getCurrentInstance().getExternalContext().getResourceAsStream("/imagens/escala-202310.png");
                         BufferedImage imagem = ImageIO.read(arquivo);
                         ByteArrayOutputStream os = new ByteArrayOutputStream();
             ImageIO.write(imagem, "png", os);
                         escala = DefaultStreamedContent.builder()
                            .contentType("image/png")
                            .stream(() -> new ByteArrayInputStream(os.toByteArray()))
                            .build();
                       
                         
                        chart = DefaultStreamedContent.builder()
                            .contentType("image/png")
                            .stream(() -> {
                                try {
                                    JFreeChart jfreechart = ChartFactory.createPieChart("Cities", createDataset(), true, true, false);
                                    File chartFile = new File("dynamichart");
                                    ChartUtilities.saveChartAsPNG(chartFile, jfreechart, 375, 300);
                                    return new FileInputStream(chartFile);
                                }
                                catch (Exception e) {
                                    e.printStackTrace();
                                    return null;
                                }
                            })
                            .build();
                 } catch (IOException e1) {
                                // TODO Auto-generated catch block
                                e1.printStackTrace();
                        }
        }
        */
}