Subversion Repositories Integrator Subversion

package br.com.ec.controller.managedbean;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

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

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

import br.com.ec.core.consulta.ParametrosConsulta;
import br.com.ec.core.generic.GenericService;
import br.com.ec.core.util.VerificadorUtil;
import br.com.ec.domain.dto.ConsolidadoNotasFiscaisDTO;
import br.com.ec.domain.dto.ConsolidadoPessoaJuridicaDTO;
import br.com.ec.domain.dto.ParametrosConsultaNotaFiscalDTO;
import br.com.ec.domain.model.NotaFiscal;
import br.com.ec.domain.model.Pessoa;
import br.com.ec.domain.model.Vigencia;
import br.com.ec.domain.model.tipos.nfe.TipoNotaFiscal;
import br.com.ec.domain.service.notafiscal.NotaFiscalService;
import br.com.ec.web.exception.VerificadorLancamentoException;
import br.com.ec.web.exception.VerificadorLancamentoException.CommandRelatorioStreamedContent;
import br.com.ec.web.generic.AbstractBean;

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

        private static final long serialVersionUID = 1L;
       
        private List<String> anosSelecionados;
        private List<String> mesesSelecionados;
       
        private List<Vigencia> vigencias;
       
        // OPÇÕES DE RELATORIOS PARA SEREM CONSULTADOS E APRESENTADOS
        private Boolean consolidadoNotasFiscais;
       
        private NotaFiscalService notaFiscalService;
       
        @Inject
        public ConsolidadoNotasFiscaisBean(NotaFiscalService notaFiscalService) {
                this.notaFiscalService = notaFiscalService;
        }
       
        public List<String> getAnosSelecionados() {
                return anosSelecionados;
        }
        public void setAnosSelecionados(List<String> anosSelecionados) {
                this.anosSelecionados = anosSelecionados;
        }
       
        public List<String> getMesesSelecionados() {
                return mesesSelecionados;
        }
        public void setMesesSelecionados(List<String> mesesSelecionados) {
                this.mesesSelecionados = mesesSelecionados;
        }
       
        public List<Vigencia> getVigencias() {
                return vigencias;
        }
        public void setVigencias(List<Vigencia> vigencias) {
                this.vigencias = vigencias;
        }
       
        public Boolean getConsolidadoNotasFiscais() {
                return consolidadoNotasFiscais;
        }
        public void setConsolidadoNotasFiscais(Boolean consolidadoNotasFiscais) {
                this.consolidadoNotasFiscais = consolidadoNotasFiscais;
        }
       
        @Override
        public void preCarregamento() {
                entidade = new ConsolidadoNotasFiscaisDTO();
                parametrosConsulta = new ParametrosConsulta<ConsolidadoNotasFiscaisDTO>();
                parametrosConsulta.setEntidade(entidade);
        }
       
        @Override
        public void limparEntidade() {
                ConsolidadoNotasFiscaisDTO ConsolidadoVigencia = new ConsolidadoNotasFiscaisDTO();
                setEntidade(ConsolidadoVigencia);
        }

        @Override
        public GenericService<ConsolidadoNotasFiscaisDTO> getService() {
                return null;
        }
       
        @Override
        public ConsolidadoNotasFiscaisDTO getEntidade() {
                return entidade;
        }

        @Override
        public ConsolidadoNotasFiscaisDTO getId() {
                return getEntidade();
        }
       
        /*******************************************************/
       
        public void consultarConsolidacoes() {
                if (getConsolidadoNotasFiscais()) {
                        consultarValoresNotasFiscais();
                }
        }
       
        public void consultarValoresNotasFiscais() {
                ParametrosConsultaNotaFiscalDTO parametros = new ParametrosConsultaNotaFiscalDTO();
                parametros.setEntidade(new NotaFiscal());
                if (VerificadorUtil.naoEstaNulo(getEntidade().getVigencia())) {
                        parametros.setDataInicial(getEntidade().getVigencia().getDataInicio());
                        parametros.setDataFinal(getEntidade().getVigencia().getDataFim());
                }
                List<NotaFiscal> notasFiscais = notaFiscalService.consultarNotasFiscais(parametros);
               
                Integer notasRecebidas = 0;
                Double valorTotalRecebido = 0.0;
                for (NotaFiscal nf : notasFiscais) {
                        if (VerificadorUtil.naoEstaNulo(nf.getValorNotaFiscal())) {
                                if (nf.getTipoNotaFiscal().equals(TipoNotaFiscal.NFE_ENTRADA.getValor())) {
                                        notasRecebidas++;
                                        valorTotalRecebido = valorTotalRecebido + nf.getValorNotaFiscal();
                                }
                        }
                }
                getEntidade().setValorTotalNotasFiscaisRecebidas(valorTotalRecebido);
                getEntidade().setNotasFiscaisRecebidas(notasRecebidas);
               
                Integer notasRemessas = 0;
                Double valorTotalRemessas = 0.0;
                for (NotaFiscal nf : notasFiscais) {
                        if (VerificadorUtil.naoEstaNulo(nf.getValorNotaFiscal())) {
                                if (nf.getTipoNotaFiscal().equals(TipoNotaFiscal.NFE_REMESSA.getValor())) {
                                        notasRemessas++;
                                        valorTotalRemessas = valorTotalRemessas + nf.getValorNotaFiscal();
                                }
                        }
                }
                getEntidade().setValorTotalNotasFiscaisRemessas(valorTotalRemessas);
                getEntidade().setNotasFiscaisRemessas(notasRemessas);
               
                List<ConsolidadoPessoaJuridicaDTO> pessoasJuridicasEmitidas = preencherNotasPorPessoaJuridica(notasFiscais);
                for (ConsolidadoPessoaJuridicaDTO consolidadoPessoaJuridica : pessoasJuridicasEmitidas) {
                        Integer notasEmitidas = 0;
                        Double valorTotalEmitido = 0.0;
                       
                        for (NotaFiscal nf : notasFiscais) {
                                if (VerificadorUtil.naoEstaNulo(nf.getPessoaEmitente())) {
                                        if (nf.getPessoaEmitente().equals(consolidadoPessoaJuridica.getPessoaJuridica())) {
                                                if (nf.getTipoNotaFiscal().equals(TipoNotaFiscal.NFE_SAIDA.getValor()) ||
                                                                nf.getTipoNotaFiscal().equals(TipoNotaFiscal.NFCE_SAIDA.getValor())) {
                                                        notasEmitidas++;
                                                        valorTotalEmitido = valorTotalEmitido + nf.getValorNotaFiscal();
                                                }
                                        }
                                }
                        }
                       
                        consolidadoPessoaJuridica.setNotasFiscaisEmitidas(notasEmitidas);
                        consolidadoPessoaJuridica.setValorTotalNotasFiscaisEmitidas(valorTotalEmitido);
                }
                getEntidade().setConsolidadosPessoaJuridica(pessoasJuridicasEmitidas);
        }
       
        private List<ConsolidadoPessoaJuridicaDTO> preencherNotasPorPessoaJuridica(List<NotaFiscal> notasFiscais) {
                List<Pessoa> pessoas = new ArrayList<Pessoa>();
                for (NotaFiscal notaFiscal : notasFiscais) {
                        if (VerificadorUtil.naoEstaNulo(notaFiscal.getPessoaEmitente())) {
                                if (!pessoas.contains(notaFiscal.getPessoaEmitente())) {
                                        pessoas.add(notaFiscal.getPessoaEmitente());
                                }
                        }
                }
                List<ConsolidadoPessoaJuridicaDTO> consolidadosPJ = new ArrayList<ConsolidadoPessoaJuridicaDTO>();
                for (Pessoa pessoa : pessoas) {
                        ConsolidadoPessoaJuridicaDTO consolidadoPessoaJuridica = new ConsolidadoPessoaJuridicaDTO();
                        consolidadoPessoaJuridica.setPessoaJuridica(pessoa);
                        consolidadosPJ.add(consolidadoPessoaJuridica);
                }
                return consolidadosPJ;
        }

        public StreamedContent downloadXmlsNotasFiscaisEmitidas() {
                return new VerificadorLancamentoException().verificarLancamentoException(new CommandRelatorioStreamedContent() {
                        @Override
                        public StreamedContent execute() {
                                return notaFiscalService.downloadXmls(getEntidade().getVigencia().getDataInicio(), getEntidade().getVigencia().getDataFim(), TipoNotaFiscal.NFCE_SAIDA.getValor(), null);
                        }
                });
        }
       
        public StreamedContent downloadXmlsNotasFiscaisEmitidas(final Pessoa pessoaEmissor) {
                return new VerificadorLancamentoException().verificarLancamentoException(new CommandRelatorioStreamedContent() {
                        @Override
                        public StreamedContent execute() {
                                return notaFiscalService.downloadXmls(getEntidade().getVigencia().getDataInicio(), getEntidade().getVigencia().getDataFim(), TipoNotaFiscal.NFCE_SAIDA.getValor(), pessoaEmissor);
                        }
                });
        }
       
        public StreamedContent downloadXmlsNotasFiscaisRecebidas() {
                return new VerificadorLancamentoException().verificarLancamentoException(new CommandRelatorioStreamedContent() {
                        @Override
                        public StreamedContent execute() {
                                return notaFiscalService.downloadXmls(getEntidade().getVigencia().getDataInicio(), getEntidade().getVigencia().getDataFim(), TipoNotaFiscal.NFE_ENTRADA.getValor(), null);
                        }
                });
        }
       
        public StreamedContent downloadXmlsNotasFiscaisRemessa() {
                return new VerificadorLancamentoException().verificarLancamentoException(new CommandRelatorioStreamedContent() {
                        @Override
                        public StreamedContent execute() {
                                return notaFiscalService.downloadXmls(getEntidade().getVigencia().getDataInicio(), getEntidade().getVigencia().getDataFim(), TipoNotaFiscal.NFE_REMESSA.getValor(), null);
                        }
                });
        }
       
}