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.exception.VerificadorLancamentoException.CommandRelatorioStreamedContent;

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 danfeNfePreVisualizacao;

        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 getDanfeNfePreVisualizacao() {

                return danfeNfePreVisualizacao;

        }

        public void setDanfeNfePreVisualizacao(StreamedContent danfeNfePreVisualizacao) {

                this.danfeNfePreVisualizacao = danfeNfePreVisualizacao;

        }

        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) {

                setDanfeNfePreVisualizacao(notaFiscalService.gerarDanfeNfePreVisualizacao(sequencialNotaFiscal));

                setDanfeNfe(notaFiscalService.gerarDanfeNfe(sequencialNotaFiscal));

        }

        public void emitirDanfeNfePreVisualizacao(Long sequencialNotaFiscal) {

                setDanfeNfePreVisualizacao(notaFiscalService.gerarDanfeNfePreVisualizacao(sequencialNotaFiscal));

                setDanfeNfe(notaFiscalService.gerarDanfeNfe(sequencialNotaFiscal));

                /*

                return new VerificadorLancamentoException().verificarLancamentoException(new CommandRelatorioStreamedContent() {

                        @Override

                        public StreamedContent execute() {

                                return notaFiscalService.gerarDanfeNfe(getEntidade().getSequencial());

                        }

                });

                */

        }

        public StreamedContent downloadNotaFiscal() {

                return new VerificadorLancamentoException().verificarLancamentoException(new CommandRelatorioStreamedContent() {

                        @Override

                        public StreamedContent execute() {

                                return getDanfeNfe();

                        }

                });

        }

        public void emitirDanfeNfeTeste() {

                Long sequencialNotaFiscal = new Long(168722);

                setDanfeNfePreVisualizacao(notaFiscalService.gerarDanfeNfePreVisualizacao(sequencialNotaFiscal));

                setDanfeNfe(notaFiscalService.gerarDanfeNfe(sequencialNotaFiscal));

        }

        /*

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

                        }

        }

        */

}