Subversion Repositories Integrator Subversion

package br.com.ec.domain.service.impl;

import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

import org.springframework.stereotype.Service;

import br.com.ec.core.exception.NegocioException;
import br.com.ec.core.generic.AbstractService;
import br.com.ec.core.generic.GenericRepository;
import br.com.ec.core.util.DataUtils;
import br.com.ec.core.util.VerificadorUtil;
import br.com.ec.core.validador.Validador;
import br.com.ec.domain.dto.AuditoriaVendaDTO;
import br.com.ec.domain.dto.FormaPagamentoDTO;
import br.com.ec.domain.dto.LojaDTO;
import br.com.ec.domain.dto.ModeloDTO;
import br.com.ec.domain.dto.RankingComprasTransferenciasDTO;
import br.com.ec.domain.dto.RankingComprasTransferenciasEstiloDTO;
import br.com.ec.domain.dto.RankingComprasTransferenciasEstiloPorLojaDTO;
import br.com.ec.domain.dto.RankingModeloDTO;
import br.com.ec.domain.dto.RankingProdutoDTO;
import br.com.ec.domain.dto.RankingProdutoDTONovo;
import br.com.ec.domain.dto.RankingTransferenciasModeloDTO;
import br.com.ec.domain.dto.RankingTransferenciasModeloPorLojaDTO;
import br.com.ec.domain.dto.consulta.ParametrosConsultaModelosMaisVendidosDTO;
import br.com.ec.domain.dto.consulta.ParametrosConsultaPorPeriodoDTO;
import br.com.ec.domain.dto.consulta.ParametrosConsultaProdutosVendidosDTO;
import br.com.ec.domain.dto.consulta.ParametrosConsultaVendasDTO;
import br.com.ec.domain.model.Venda;
import br.com.ec.domain.model.tipos.TipoEstiloProduto;
import br.com.ec.domain.model.tipos.TipoProduto;
import br.com.ec.domain.model.tipos.TipoSituacaoVenda;
import br.com.ec.domain.service.LojaService;
import br.com.ec.domain.service.ModeloService;
import br.com.ec.domain.service.VendaService;
import br.com.ec.repository.VendaRepository;

@Service
public class VendaServiceImpl extends AbstractService<Venda> implements VendaService {

        private LojaService lojaService;
        private ModeloService modeloService;
        private VendaRepository vendaRepository;
       
        public VendaServiceImpl(Validador validador, LojaService lojaService, ModeloService modeloService, VendaRepository vendaRepository) {
                super(validador);
                this.lojaService = lojaService;
                this.modeloService = modeloService;
                this.vendaRepository = vendaRepository;
        }

        @Override
        protected GenericRepository<Venda> getRepository() {
                return vendaRepository;
        }
       
        @Override
        public Double obterValorTotalBrutoDeVendas(ParametrosConsultaVendasDTO parametrosConsultaVendasDTO) {
                Double valorTotal = vendaRepository.obterValorTotalBrutoDeVendas(parametrosConsultaVendasDTO);
                valorTotal = valorTotal - vendaRepository.obterValorDeCuponsUtilizadosPorLojaEePeriodo(parametrosConsultaVendasDTO);
                return valorTotal;
        }
       
        @Override
        public Integer obterQuantidadeDeVendasPorLojaEePeriodo(Long sequencialLoja, Date dataInicial, Date dataFinal) {
                return vendaRepository.obterQuantidadeDeVendas(new ParametrosConsultaVendasDTO(sequencialLoja, dataInicial, dataFinal));
        }
       
        @Override
        public Integer obterQuantidadeDeVendasNovasPorLojaEePeriodo(Long sequencialLoja, Date dataInicial, Date dataFinal) {
                ParametrosConsultaVendasDTO parametrosConsulta = new ParametrosConsultaVendasDTO(sequencialLoja, dataInicial, dataFinal);
                parametrosConsulta.setTipoSituacaoVenda(TipoSituacaoVenda.NOVO.getValor());
                return vendaRepository.obterQuantidadeDeVendas(parametrosConsulta);
        }
       
        @Override
        public Double obterValorTotalBrutoDeVendasPorLojaEePeriodoEeFormasDePagamento(ParametrosConsultaVendasDTO parametrosConsultaVendas, List<FormaPagamentoDTO> formasDePagamento) {
                return vendaRepository.obterValorTotalBrutoDeVendasPorParametrosEeFormasDePagamento(parametrosConsultaVendas, formasDePagamento);
        }
       
        @Override
        public Double obterValorDeMaquinetasPorPessoa(Long sequencialPessoaMaquineta, Date dataInicio, Date dataFim) {
                return vendaRepository.obterValorDeMaquinetasPorPessoa(sequencialPessoaMaquineta, dataInicio, dataFim);
        }
       
        @Override
        public Double obterValorTotalLiquidoDeVendas(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
                return vendaRepository.obterValorTotalLiquidoDeVendas(parametrosConsultaVendas);
        }
       
        @Override
        public Double obterValorProdutosUtilizadosEmVendas(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
                return vendaRepository.obterValorProdutosUtilizadosEmVendas(parametrosConsultaVendas);
        }
       
        @Override
        public List<AuditoriaVendaDTO> consultarAuditoriaVenda(Date dataSelecionada, Long sequencialLojaSelecionada) {
                if (VerificadorUtil.estaNulo(sequencialLojaSelecionada)) {
                        throw new NegocioException("Selecione a loja");
                }
                Integer diferencaDiasEntreDatas = DataUtils.calcularDiferenceEmDiasEntreDuasDatas(DataUtils.getDataAtual(), dataSelecionada);
                if (diferencaDiasEntreDatas > 60) {
                        throw new NegocioException("Consulta indisponível");
                }
                return vendaRepository.consultarAuditoriaVenda(dataSelecionada, sequencialLojaSelecionada);
        }
       
        @Override
        public List<RankingComprasTransferenciasDTO> consultarRankingComprasTransferencias(Integer quantidadeDiasVendas, Integer quantidadeDiasParaAlerta, List<RankingModeloDTO> modelosMaisVendidos, Boolean consultarPorLoja) {
                List<RankingComprasTransferenciasDTO> ranking = new ArrayList<RankingComprasTransferenciasDTO>();
               
                ParametrosConsultaPorPeriodoDTO parametrosConsultaPorPeriodoDTO = new ParametrosConsultaPorPeriodoDTO();
                parametrosConsultaPorPeriodoDTO.setDataFinal(DataUtils.getDataAtual());
                parametrosConsultaPorPeriodoDTO.setDataInicial(DataUtils.acrescentarDias(DataUtils.getDataAtual(), quantidadeDiasVendas*-1));
               
                Integer posicaoRanking = 1;
                for (RankingModeloDTO rankingModelo : modelosMaisVendidos) {
                        RankingComprasTransferenciasDTO rankingComprasTransferenciasDTO = new RankingComprasTransferenciasDTO();
                        rankingComprasTransferenciasDTO.setRankingModelo(rankingModelo);
                        rankingComprasTransferenciasDTO.setPosicaoRanking(posicaoRanking);
                        posicaoRanking++;

                        // CONSULTAR POR ESTILO
                        List<RankingComprasTransferenciasEstiloDTO> rankEstiloDTO = new ArrayList<RankingComprasTransferenciasEstiloDTO>();
                        rankEstiloDTO.addAll(consultarRankingPorEstilo(rankingModelo.getModelo().getSequencial(), parametrosConsultaPorPeriodoDTO));
                       
                        // PREENCHER COM ESTILOS QUE NÃO FORAM CONSULTADOS
                        List<RankingComprasTransferenciasEstiloDTO> rankingEstiloDTO = new ArrayList<RankingComprasTransferenciasEstiloDTO>();
                        for (TipoEstiloProduto tipoEstilo : TipoEstiloProduto.values()) {      
                                Boolean adicionarEstilo = true;
                                for (RankingComprasTransferenciasEstiloDTO rankingEstilo : rankEstiloDTO) {
                                        if (rankingEstilo.getEstilo().equals(tipoEstilo)) {
                                                rankingEstiloDTO.add(rankingEstilo);
                                                adicionarEstilo = false;
                                                break;
                                        }
                                }
                                if (adicionarEstilo) {
                                        RankingComprasTransferenciasEstiloDTO rankingEstilo = new RankingComprasTransferenciasEstiloDTO();
                                        rankingEstilo.setEstilo(tipoEstilo);
                                        rankingEstiloDTO.add(rankingEstilo);
                                }
                        }
                       
                        Double quantidadeMinimaTransferirComprar = new Double(quantidadeDiasParaAlerta) / new Double(quantidadeDiasVendas);
                       
                        // CONSULTAR ESTILO POR LOJA
                        if (consultarPorLoja) {
                                for (RankingComprasTransferenciasEstiloDTO rankingEstilo : rankingEstiloDTO) {
                                        List<RankingComprasTransferenciasEstiloPorLojaDTO> rankingPorLoja = new ArrayList<RankingComprasTransferenciasEstiloPorLojaDTO>();
                                        rankingPorLoja.addAll(consultarRankingPorEstiloPorLoja(rankingModelo.getModelo().getSequencial(), rankingEstilo.getEstilo().getValor(), parametrosConsultaPorPeriodoDTO));
                                       
                                        // PREENCHER COM LOJAS ATIVAS
                                        List<RankingComprasTransferenciasEstiloPorLojaDTO> rankingEstiloPorLoja = new ArrayList<RankingComprasTransferenciasEstiloPorLojaDTO>();
                                        List<LojaDTO> lojasDTO = lojaService.consultarLojasAtivas();
                                        for (LojaDTO lojaDTO : lojasDTO) {
                                                Boolean adicionarRankingLoja = true;
                                                for (RankingComprasTransferenciasEstiloPorLojaDTO rk : rankingPorLoja) {
                                                        if (rk.getLojaDTO().equals(lojaDTO)) {
                                                                rankingEstiloPorLoja.add(rk);
                                                                adicionarRankingLoja = false;
                                                                break;
                                                        }
                                                }
                                                if (adicionarRankingLoja) {
                                                        RankingComprasTransferenciasEstiloPorLojaDTO rank = new RankingComprasTransferenciasEstiloPorLojaDTO();
                                                        rank.setLojaDTO(lojaDTO);
                                                        rankingEstiloPorLoja.add(rank);
                                                }
                                        }
                                        rankingEstilo.setRankingsPorLoja(rankingEstiloPorLoja);
                                        rankingComprasTransferenciasDTO.getEstilos().add(rankingEstilo);
                                }
                                rankingComprasTransferenciasDTO.setAlertas(rankingComprasTransferenciasDTO.verificarAlertasLogistica(quantidadeMinimaTransferirComprar));
                        } else {
                                rankingComprasTransferenciasDTO.setEstilos(rankingEstiloDTO);
                                rankingComprasTransferenciasDTO.setAlertas(rankingComprasTransferenciasDTO.verificarAlertasCompras(quantidadeMinimaTransferirComprar));
                        }
                        ranking.add(rankingComprasTransferenciasDTO);
                }
               
                List<RankingComprasTransferenciasDTO> rankingComAlertas = retirarModelosSemAlertas(ranking);
                return rankingComAlertas;
        }

        private List<RankingComprasTransferenciasDTO> retirarModelosSemAlertas(List<RankingComprasTransferenciasDTO> ranking) {
                List<RankingComprasTransferenciasDTO> rankingComAlertas = new ArrayList<RankingComprasTransferenciasDTO>();
                for (RankingComprasTransferenciasDTO rank : ranking) {
                        if (!rank.getAlertas().isEmpty()) {
                                rankingComAlertas.add(rank);
                        }
                }
                return rankingComAlertas;
        }
       
        @Override
        public List<RankingComprasTransferenciasEstiloPorLojaDTO> consultarRankingPorEstiloPorLoja(Long sequencialModelo, String tipoEstilo, ParametrosConsultaPorPeriodoDTO parametrosConsultaPorPeriodoDTO) {
                return vendaRepository.consultarRankingPorEstiloPorLoja(sequencialModelo, tipoEstilo, parametrosConsultaPorPeriodoDTO);
        }

        @Override
        public List<RankingModeloDTO> consultarRankingModelos(ParametrosConsultaModelosMaisVendidosDTO parametrosConsulta, Boolean adicionarTodosModelosFavoritos) {
                List<RankingModeloDTO> rankingModelosMaisVendidos = new ArrayList<RankingModeloDTO>();
                rankingModelosMaisVendidos.addAll(vendaRepository.consultarModelosMaisVendidos(parametrosConsulta));
               
                if (adicionarTodosModelosFavoritos) {
                        // PREENCHER COM MODELOS FAVORITOS SEM VENDAS
                        ModeloDTO modeloDTO = new ModeloDTO();
                        modeloDTO.setAtivo(true);
                        modeloDTO.setIndicadorFavorito(true);
                        List<ModeloDTO> modelosFavoritos = modeloService.consultarModelos(modeloDTO);
                        List<RankingModeloDTO> modelosFavoritosSemVendas = new ArrayList<RankingModeloDTO>();
                        for (ModeloDTO modeloFavorito : modelosFavoritos) {
                                Boolean adicionarModelo = true;
                                for (RankingModeloDTO ranking : rankingModelosMaisVendidos) {
                                        if (ranking.getModelo().equals(modeloFavorito)) {
                                                adicionarModelo = false;
                                                break;
                                        }
                                }
                                if (adicionarModelo) {
                                        RankingModeloDTO rankingModeloDTO = new RankingModeloDTO();
                                        rankingModeloDTO.setModelo(modeloFavorito);
                                        modelosFavoritosSemVendas.add(rankingModeloDTO);
                                }
                        }
                        rankingModelosMaisVendidos.addAll(modelosFavoritosSemVendas);
                }
               
                return rankingModelosMaisVendidos;
        }
       
        @Override
        public List<RankingComprasTransferenciasEstiloDTO> consultarRankingPorEstilo(Long sequencialModelo, ParametrosConsultaPorPeriodoDTO parametrosConsultaPorPeriodoDTO) {
                return vendaRepository.consultarRankingPorEstilo(sequencialModelo, parametrosConsultaPorPeriodoDTO);
        }
       
        @Override
        public List<RankingProdutoDTO> consultarProdutosVendidos(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
                List<RankingProdutoDTO> produtosVendidosConsultados = vendaRepository.consultarProdutosVendidos(parametrosConsulta);
                for (RankingProdutoDTO produtoVendido : produtosVendidosConsultados) {
                        produtoVendido.atualizarTempoEstoque(parametrosConsulta.getDataInicial(), parametrosConsulta.getDataFinal());
                }
                return produtosVendidosConsultados;
        }
       
        @Override
        public List<RankingProdutoDTONovo> consultarProdutosDTOVendidos(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
                List<RankingProdutoDTONovo> produtosVendidosConsultados = vendaRepository.consultarProdutosVendidosDTO(parametrosConsulta);
                for (RankingProdutoDTONovo produtoVendido : produtosVendidosConsultados) {
                        produtoVendido.atualizarTempoEstoque(parametrosConsulta.getDataInicial(), parametrosConsulta.getDataFinal());
                }
                return produtosVendidosConsultados;
        }
       
        @Override
        public List<RankingTransferenciasModeloDTO> consultarModelosParaRedistribuicao() {
                List<RankingTransferenciasModeloDTO> modelosParaRedistribuicao = new ArrayList<RankingTransferenciasModeloDTO>();
               
                // CONSULTAR MODELOS MAIS VENDIDOS (90 DIAS, CAPAS)
                List<RankingModeloDTO> modelosMaisVendidos = new ArrayList<RankingModeloDTO>();
                ParametrosConsultaModelosMaisVendidosDTO parametrosConsulta = new ParametrosConsultaModelosMaisVendidosDTO();
                parametrosConsulta.setDataFinal(DataUtils.getDataAtual());
                parametrosConsulta.setDataInicial(DataUtils.acrescentarDias(DataUtils.getDataAtual(), -90));
                modelosMaisVendidos.addAll(this.consultarRankingModelos(parametrosConsulta, true));
               
                // REFAZER: CONSULTAR E ATUALIZAR TOTAIS (POR LOJA)
                Integer quantidadeTotalVendas = 0;
                Integer quantidadeTotalEstoque = 0;
                for (RankingModeloDTO modeloMaisVendidos : modelosMaisVendidos) {
                        if (VerificadorUtil.naoEstaNulo(modeloMaisVendidos.getQuantidadeEstoqueGeral())) {
                                quantidadeTotalEstoque += modeloMaisVendidos.getQuantidadeEstoqueGeral();
                        }      
                        if (VerificadorUtil.naoEstaNulo(modeloMaisVendidos.getQuantidadeVendas())) {
                                quantidadeTotalVendas += modeloMaisVendidos.getQuantidadeVendas();
                        }
                }
                for (RankingModeloDTO modeloMaisVendidos : modelosMaisVendidos) {
                        modeloMaisVendidos.setQuantidadeTotalEstoqueGeral(quantidadeTotalEstoque);
                        modeloMaisVendidos.setQuantidadeTotalVendas(quantidadeTotalVendas);
                }
               
                // CONSULTAR VENDAS/ESTOQUE POR LOJA
                List<LojaDTO> lojasDTO = lojaService.consultarLojasAtivas();
                for (RankingModeloDTO modeloMaisVendidos : modelosMaisVendidos) {
                        RankingTransferenciasModeloDTO modeloParaRedistribuicao = new RankingTransferenciasModeloDTO();
                        modeloParaRedistribuicao.setModeloDTO(modeloMaisVendidos.getModelo());
                       
                        List<RankingTransferenciasModeloPorLojaDTO> rankingTransferenciasModeloPorLojaDTO = new ArrayList<RankingTransferenciasModeloPorLojaDTO>();
                        for (LojaDTO lojaDTO : lojasDTO) {
                                RankingTransferenciasModeloPorLojaDTO modeloPorLojaParaRedistribuicao = new RankingTransferenciasModeloPorLojaDTO();
                                modeloPorLojaParaRedistribuicao.setLojaDTO(lojaDTO);
                               
                                List<RankingModeloDTO> modeloPorLojaMaisVendidos = new ArrayList<RankingModeloDTO>();
                                ParametrosConsultaModelosMaisVendidosDTO parametrosConsultaPorLoja = new ParametrosConsultaModelosMaisVendidosDTO();
                                parametrosConsultaPorLoja.setDataFinal(DataUtils.getDataAtual());
                                parametrosConsultaPorLoja.setDataInicial(DataUtils.acrescentarDias(DataUtils.getDataAtual(), -90));
                                parametrosConsultaPorLoja.setSequencialModelo(modeloMaisVendidos.getModelo().getSequencial());
                                parametrosConsultaPorLoja.setSequencialLoja(lojaDTO.getSequencial());
                                modeloPorLojaMaisVendidos.addAll(this.consultarRankingModelos(parametrosConsultaPorLoja, false));
                                if (!modeloPorLojaMaisVendidos.isEmpty()) {
                                        RankingModeloDTO rankingModeloDTO = modeloPorLojaMaisVendidos.get(0);
                                       
                                        RankingTransferenciasModeloPorLojaDTO transferenciasModeloPorLojaDTO = new RankingTransferenciasModeloPorLojaDTO();
                                        transferenciasModeloPorLojaDTO.setLojaDTO(lojaDTO);
                                        transferenciasModeloPorLojaDTO.setQuantidadeEstoque(rankingModeloDTO.getQuantidadeEstoqueGeral());
                                        transferenciasModeloPorLojaDTO.setQuantidadeVendas(rankingModeloDTO.getQuantidadeVendas());
                                        transferenciasModeloPorLojaDTO.setQuantidadeTotalEstoque(modeloMaisVendidos.getQuantidadeTotalEstoqueLocal());
                                        transferenciasModeloPorLojaDTO.setQuantidadeTotalVendas(modeloMaisVendidos.getQuantidadeTotalVendas());
                                        rankingTransferenciasModeloPorLojaDTO.add(transferenciasModeloPorLojaDTO);
                                }
                                modeloParaRedistribuicao.getRankingTransferenciasModeloPorLojaDTO().add(modeloPorLojaParaRedistribuicao);
                        }
                        modelosParaRedistribuicao.add(modeloParaRedistribuicao);
                }
                return modelosParaRedistribuicao;
        }
       
        /*
        private LancamentoService lancamentoService;
        private VendaFormaPagamentoService vendaFormaPagamentoService;
        private ProdutoService produtoService;
        private ProdutoLojaService produtoLojaService;
        private VendedorService vendedorService;
        private FuncionarioService funcionarioService;
        private LojaService lojaService;
        private PedidoService pedidoService;
        private ParcelaService parcelaService;
        private AvaliacaoService avaliacaoService;
        private AvaliacaoFuncionarioService avaliacaoFuncionarioService;
        private AvaliacaoLojaService avaliacaoLojaService;
        private VendaVivoService vendaVivoService;
        private ModeloService modeloService;
        private CupomService cupomService;
        private BancoHorasService bancoHorasService;
        private EstoqueAuditoriaService estoqueAuditoriaService;
       
        private Ordenador ordenador;
        private NotaFiscalRepository notaFiscalRepository;

        @Autowired
        public VendaServiceImpl(Validador validador, VendaRepository vendaRepository, LancamentoService lancamentoService,
                        VendaFormaPagamentoService vendaFormaPagamentoService, ProdutoService produtoService, ProdutoLojaService produtoLojaService,
                        VendedorService vendedorService, FuncionarioService funcionarioService, LojaService lojaService, PedidoService pedidoService,
                        ParcelaService parcelaService, AvaliacaoService avaliacaoService, AvaliacaoFuncionarioService avaliacaoFuncionarioService,
                        AvaliacaoLojaService avaliacaoLojaService, VendaVivoService vendaVivoService, ModeloService modeloService, CupomService cupomService,
                        BancoHorasService bancoHorasService, EstoqueAuditoriaService estoqueAuditoriaService, NotaFiscalRepository notaFiscalRepository) {
                super(validador);
                this.vendaRepository = vendaRepository;
                this.funcionarioService = funcionarioService;
                this.lancamentoService = lancamentoService;
                this.vendaFormaPagamentoService = vendaFormaPagamentoService;
                this.produtoService = produtoService;
                this.produtoLojaService = produtoLojaService;
                this.vendedorService = vendedorService;
                this.lojaService = lojaService;
                this.pedidoService = pedidoService;
                this.parcelaService = parcelaService;
                this.avaliacaoService = avaliacaoService;
                this.avaliacaoFuncionarioService = avaliacaoFuncionarioService;
                this.avaliacaoLojaService = avaliacaoLojaService;
                this.vendaVivoService = vendaVivoService;
                this.modeloService = modeloService;
                this.cupomService = cupomService;
                this.bancoHorasService = bancoHorasService;
                this.estoqueAuditoriaService = estoqueAuditoriaService;
                this.ordenador = new OrdenadorImpl();
                this.notaFiscalRepository = notaFiscalRepository;
        }

        @Override
        protected GenericRepository<Venda> getRepository() {
                return vendaRepository;
        }
       
        @Override
        protected void regrasNegocioCadastrar(Venda venda) {
                if (VerificadorUtil.estaNulo(venda.getVendedor())) {
                        throw new NegocioException("Obrigatório informar o vendedor.");
                }
                venda.setDataVenda(DataUtils.getDataAtual());
                venda.setTipoSituacao(TipoSituacaoVenda.NOVO.getValor());
        }
        */
        /***************************************************************/
        /*
        @Override
        public Venda detalharVenda(Venda venda) {
                return vendaRepository.detalharVenda(venda);
        }
       
        @Override
        public Venda detalharVendaCompleta(Venda venda) {
                return vendaRepository.detalharVendaCompleta(venda);
        }
       
        public void excluirVenda(Venda venda, Usuario usuario) {
                List<NotaFiscal> notasVinculadas = desvincularNotaFiscalEmitida(venda, usuario);
                verificarSeExisteLancamentoFinanceiro(venda);
                reporEstoqueAoExcluirVenda(venda);
                excluirPagamentos(venda);
                super.excluir(venda);
                enviarEmail(venda, usuario, notasVinculadas);
        }

        private List<NotaFiscal> desvincularNotaFiscalEmitida(Venda venda, Usuario usuario) {
                List<NotaFiscal> notasFiscais = notaFiscalRepository.consultarNotasFiscais(venda);
                for (NotaFiscal nf : notasFiscais) {
                        nf.setObservacaoVenda("VENDA ID: " + venda.getSequencial() + " em " +
                                DataUtils.converterDataComHorarioParaString(venda.getDataVenda()) + ". " +
                                venda.getJustificativaParaExcluir());
                        notaFiscalRepository.desvincularVenda(nf);
                }
                return notasFiscais;
        }

        private void verificarSeExisteLancamentoFinanceiro(Venda venda) {
                if (parcelaService.verificarPossuiParcela(venda)) {
                        throw new NegocioException("Não é permitido excluir uma venda com lançamentos financeiros.");
                }
        }

        public void reporEstoqueAoExcluirVenda(Venda venda) {
                for (Lancamento lancamento : venda.getLancamentos()) {
                        alterarEstoqueProduto(1, venda.getLoja(), lancamento.getProduto().getCodigo());
                }
        }
       
        private void excluirPagamentos(Venda venda) {
                for (VendaFormaPagamento vendaFormaPagamento : venda.getListaVendaFormaPagamentos()) {
//                      vendaFormaPagamentoService.excluirPorId(vendaFormaPagamento);
                        vendaFormaPagamentoService.excluir(vendaFormaPagamento);
                }
        }
       
        private void enviarEmail(Venda venda, Usuario usuario, List<NotaFiscal> notasFiscaisVinculadas) {
                String diaAtual = DataUtils.converterDataParaString(DataUtils.getDataAtual());
                StringBuilder conteudo = new StringBuilder();
                conteudo.append(montarDadosDaVenda(venda, usuario, venda.getLancamentos(), venda.getVendaFormaPagamentos()));
                if (!notasFiscaisVinculadas.isEmpty()) {
                        conteudo.append("--------------------------------------------------\n\n");
                        conteudo.append("NOTAS FISCAIS DESVINCULADAS:\n");
                        for (NotaFiscal nota : notasFiscaisVinculadas) {
                                conteudo.append("NÚMERO: " + nota.getNumeroNotaFiscal() + "\n");
                        }
                }
                new GerenciadorEmailImpl()
                        .comEmailsDestino(ConstantesSEC.DESTINATARIOS_EMAIL_DIRECAO)
                        .comAssunto("ESPAÇO CASE - OPERAÇÃO DE EXCLUSÃO DE VENDA: " + diaAtual)
                        .comConteudo(conteudo.toString())
                        .enviar();
        }
       
        @Override
        public Venda cadastrarVendaPeloPDV(ParametrosVendaDTO parametrosVenda) {
                verificarLancamentos(parametrosVenda.getLancamentos());
//              lancarExcecaoCasoFreteContraditorio(parametrosVenda);
                lancarExcecaoCasoNaoSejaInformadoCamposObrigatorios(parametrosVenda);
                lancarExcecaoSeValoresNaoSaoIguais(parametrosVenda);
                Venda venda = new Venda(parametrosVenda);
                cadastrar(venda);
                cadastrarLancamentos(parametrosVenda, venda);
                cadastrarPagamentos(parametrosVenda, venda);
                alterarSituacaoPedido(parametrosVenda.getPedidoVinculado(), venda);
                enviarAlertasPorEmail(parametrosVenda, venda);
                venda.verificarSePermiteEmissaoNotaFiscal();
                venda.setEmitirNotaFiscal(verificarEmissaoNotaFiscal(parametrosVenda, venda));
                return venda;
        }

        private Boolean verificarEmissaoNotaFiscal(ParametrosVendaDTO parametrosVenda, Venda venda) {
                if (venda.getPermitirEmissaoNotaFiscal() == false) {return false;}
                Boolean emitir = null;
                emitir = naoEmitirLojaSemPermissao(parametrosVenda);
                if (VerificadorUtil.naoEstaNulo(emitir)) {return emitir;}
               
                emitir = naoEmitirCpfCnpjInvalido(parametrosVenda);
                if (VerificadorUtil.naoEstaNulo(emitir)) {return emitir;}
               
                emitir = emitirLojaComEmissaoObrigatoria(parametrosVenda);
                if (VerificadorUtil.naoEstaNulo(emitir)) {return emitir;}
               
                emitir = emitirProdutoComEmissaoObrigatoria(parametrosVenda);
                if (VerificadorUtil.naoEstaNulo(emitir)) {return emitir;}
               
                emitir = emitirVendasAcimaQuinhetosReais(parametrosVenda);
                if (VerificadorUtil.naoEstaNulo(emitir)) {return emitir;}
               
                emitir = emitirVendaPagamentoCartao(parametrosVenda);
                if (VerificadorUtil.naoEstaNulo(emitir)) {return emitir;}
                return false;
        }
       
        private Boolean naoEmitirLojaSemPermissao(ParametrosVendaDTO parametrosVenda) {
                if (parametrosVenda.getLoja().getTipoEmitirNotaFiscal().equals(TipoEmitirNotaFiscal.NAO_PERMITIR_EMISSAO.getValor()) ||
                                parametrosVenda.getLoja().getTipoEmitirNotaFiscal().equals(TipoEmitirNotaFiscal.NAO_EMITIR.getValor())) {
                        return false;
                }
                return null;
        }
       
        private Boolean naoEmitirCpfCnpjInvalido(ParametrosVendaDTO parametrosVenda) {
                if (VerificadorUtil.naoEstaNulo(parametrosVenda.getCliente())) {
                        if (!parametrosVenda.getCliente().cpfCnpjEhValido()) {
                                return false;
                        }
                }
                return null;
        }
       
        private Boolean emitirLojaComEmissaoObrigatoria(ParametrosVendaDTO parametrosVenda) {
                if (parametrosVenda.getLoja().getTipoEmitirNotaFiscal().equals(TipoEmitirNotaFiscal.TODAS_VENDAS.getValor())) {
                        return true;
                }
                return null;
        }

       
       
        private Boolean emitirProdutoComEmissaoObrigatoria(ParametrosVendaDTO parametrosVenda) {
                for (Lancamento lancamento : parametrosVenda.getLancamentos()) {
                        if (lancamento.getProduto().getIndicadorEmissaoNotaFiscal()) {
                                return true;
                        }
                }
                return null;
        }
       
        private Boolean emitirVendasAcimaQuinhetosReais(ParametrosVendaDTO parametrosVenda) {
                Double valorVenda = new Double(0.0);
                for (Lancamento lancamento : parametrosVenda.getLancamentos()) {
                        valorVenda = valorVenda + lancamento.getValorVenda();
                }
                if (valorVenda > 499.9) {
                        return true;
                }
                return null;
        }
       
        private Boolean emitirVendaPagamentoCartao(ParametrosVendaDTO parametrosVenda) {
                if (parametrosVenda.getLoja().getTipoEmitirNotaFiscal().equals(TipoEmitirNotaFiscal.VENDAS_OBRIGATORIAS.getValor())) {
                        for (VendaFormaPagamento pagamento : parametrosVenda.getLancamentosPagamentos()) {
                                if (pagamento.getFormaPagamento().formaPagamentoEhCredito() ||
                                                pagamento.getFormaPagamento().formaPagamentoEhDebito() ||
                                                pagamento.getFormaPagamento().formaPagamentoEhPagseguro()) {
                                        return true;
                                }
                        }
                }
                return null;
        }

        private void alterarSituacaoPedido(Pedido pedidoVinculado, Venda venda) {
                if (VerificadorUtil.naoEstaNulo(pedidoVinculado)) {
                        PedidoHistorico pedidoHistorico = new PedidoHistorico();
                        pedidoHistorico.setDataHistorico(DataUtils.getDataAtual());
                        pedidoHistorico.setObservacao("VENDA: " + venda.getSequencial());
                        pedidoHistorico.setTipoSituacao(TipoSituacaoPedido.FINALIZADO_COM_VENDAS.getValor());
                        pedidoHistorico.setUsuario(venda.getUsuario());
                        pedidoHistorico.setPedido(pedidoVinculado);
                        if (VerificadorUtil.estaNulo(pedidoVinculado.getHistorico())) {
                                pedidoVinculado.setHistorico(new ArrayList<PedidoHistorico>());
                        }
                        pedidoVinculado.getHistorico().add(pedidoHistorico);
                        pedidoVinculado.setTipoSituacao(TipoSituacaoPedido.FINALIZADO_COM_VENDAS.getValor());
                        pedidoVinculado.setDataUltimaAlteracaoSituacao(DataUtils.getDataAtual());
                        pedidoVinculado.setVenda(venda);
                        pedidoService.alterar(pedidoVinculado);
                }
        }

        private void enviarAlertasPorEmail(ParametrosVendaDTO parametrosVenda, Venda venda) {
                if (descontosEmProdutosSuperiores(parametrosVenda)) {
                        new GerenciadorEmailImpl()
                                .comEmailsDestino(ConstantesSEC.DESTINATARIOS_EMAIL_SUPERVISAO)
                                .comAssunto("ESPAÇO CASE - VENDA COM DESCONTO SUPERIOR : " + DataUtils.converterDataParaString(DataUtils.getDataAtual()))
                                .comConteudo(montarDadosDaVenda(venda, venda.getUsuario(), parametrosVenda.getLancamentos(), parametrosVenda.getLancamentosPagamentos()))
                                .enviar();
                }
                if (produtosComDescontoECupom(parametrosVenda)) {
                        new GerenciadorEmailImpl()
                                .comEmailsDestino(ConstantesSEC.DESTINATARIOS_EMAIL_SUPERVISAO)
                                .comAssunto("ESPAÇO CASE - VENDA COM PRODUTO COM DESCONTO E CUPOM PROMOCIONAL : " + DataUtils.converterDataParaString(DataUtils.getDataAtual()))
                                .comConteudo(montarDadosDaVenda(venda, venda.getUsuario(), parametrosVenda.getLancamentos(), parametrosVenda.getLancamentosPagamentos()))
                                .enviar();
                }
        }
*/     
        /*
        private void enviarAlertasPorEmail(ParametrosVendaDTO parametrosVenda, Venda venda) {
                if (pagamentoDividido(parametrosVenda)) {
                        if (descontoEmProdutos(parametrosVenda)) {
                                String diaAtual = DataUtils.converterDataParaString(DataUtils.getDataAtual());
                                new GerenciadorEmailImpl()
                                        .comEmailsDestino(ConstantesSEC.DESTINATARIOS_EMAIL_DIRECAO)
                                        .comAssunto("ESPAÇO CASE - VENDA DIVIDIDA E COM DESCONTO : " + diaAtual)
                                        .comConteudo(montarDadosDaVenda(venda, venda.getUsuario(), parametrosVenda.getLancamentos(), parametrosVenda.getLancamentosPagamentos()))
                                        .enviar();
                        }
                }
        }
        */
/*
        private Boolean pagamentoDividido(ParametrosVendaDTO parametrosVenda) {
                for (VendaFormaPagamento pagamento : parametrosVenda.getLancamentosPagamentos()) {
                        if (pagamento.getFormaPagamento().formaPagamentoEhCreditoDividido()) {
                                return true;
                        }
                }
                return false;
        }

        private boolean descontoEmProdutos(ParametrosVendaDTO parametrosVenda) {
                for (Lancamento lancamento : parametrosVenda.getLancamentos()) {
                        if (lancamento.comDescontos()) {
                                return true;
                        }
                }
                return false;
        }
       
        private boolean descontosEmProdutosSuperiores(ParametrosVendaDTO parametrosVenda) {
                for (Lancamento lancamento : parametrosVenda.getLancamentos()) {
                        if (lancamento.comDescontosAcimaDoPermitido()) {
                                return true;
                        }
                }
                return false;
        }
       
        private boolean produtosComDescontoECupom(ParametrosVendaDTO parametrosVenda) {
                for (Lancamento lancamento : parametrosVenda.getLancamentos()) {
                        if (VerificadorUtil.naoEstaNulo(lancamento.getCupom()) && lancamento.comDescontos()) {
                                return true;
                        }
                }
                return false;
        }

        @Override
        public void alterarVenda(ParametrosVendaDTO parametrosVenda, Usuario usuario, Boolean verificarJustificativa) {
                verificarLancamentos(parametrosVenda.getLancamentos());
                lancarExcecaoCasoNaoSejaInformadoCamposObrigatorios(parametrosVenda);
                lancarExcecaoSeValoresNaoSaoIguais(parametrosVenda);
                if (verificarJustificativa) {enviarEmailAlteracoes(parametrosVenda, usuario);}
                atualizarDadosDaVenda(parametrosVenda);
                alterarLancamentos(parametrosVenda);
                alterarPagamentos(parametrosVenda);
                alterar(parametrosVenda.getVenda());
                alterarSituacaoPedido(parametrosVenda.getPedidoVinculado(), parametrosVenda.getVenda());
        }

        private void enviarEmailAlteracoes(ParametrosVendaDTO parametrosVenda, Usuario usuario) {
                String diaAtual = DataUtils.converterDataParaString(DataUtils.getDataAtual());
                StringBuilder conteudo = new StringBuilder();
                conteudo.append("OPERAÇÃO REALIZADA POR: " + usuario.getNome() + "\n");
                conteudo.append("ID: " + parametrosVenda.getVenda().getSequencial() + "\n");
                conteudo.append("DATA DA VENDA: " + DataUtils.converterDataComHorarioParaString(parametrosVenda.getVenda().getDataVenda()) + "\n");
                conteudo.append("ALTERAÇÕES:\n");
                if (!parametrosVenda.getLoja().equals(parametrosVenda.getVenda().getLoja())) {
                        conteudo.append("LOJA: " + parametrosVenda.getVenda().getLoja().getDescricao() + " -> " + parametrosVenda.getLoja().getDescricao() + "\n");
                }
                if (!parametrosVenda.getVendedor().equals(parametrosVenda.getVenda().getVendedor())) {
                        conteudo.append("VENDEDOR: " + parametrosVenda.getVenda().getVendedor().getNomeDaPessoa() + " -> " + parametrosVenda.getVendedor().getNomeDaPessoa() + "\n");
                }
               
                String indicacao = "NÃO INFORMADO";
                String novaIndicacao = "NÃO INFORMADO";
                if (VerificadorUtil.naoEstaNulo(parametrosVenda.getVenda().getIndicacao())) {
                        indicacao = parametrosVenda.getVenda().getIndicacao().getNome();
                }
                if (VerificadorUtil.naoEstaNulo(parametrosVenda.getIndicacao())) {
                        novaIndicacao = parametrosVenda.getIndicacao().getNome();
                }
                if (!indicacao.equals(novaIndicacao)) {
                        conteudo.append("INDICAÇÃO: " + indicacao + " -> " + novaIndicacao + "\n");
                }
               
                String cliente = "NÃO INFORMADO";
                String novoCliente = "NÃO INFORMADO";
                if (VerificadorUtil.naoEstaNulo(parametrosVenda.getVenda().getCliente())) {
                        cliente = parametrosVenda.getVenda().getCliente().getNome();
                }
                if (VerificadorUtil.naoEstaNulo(parametrosVenda.getCliente())) {
                        novoCliente = parametrosVenda.getCliente().getNome();
                }
                if (!cliente.equals(novoCliente)) {
                        conteudo.append("CLIENTE: " + cliente + " -> " + novoCliente + "\n");
                }
               
                if (!parametrosVenda.getObservacao().equals(parametrosVenda.getVenda().getObservacao())) {
                        conteudo.append("OBS: " + parametrosVenda.getVenda().getObservacao() + " -> " + parametrosVenda.getObservacao() + "\n");
                }
               
                String formasPagamento = "";
                String novasFormasPagamento = "";
                List<VendaFormaPagamento> pagamentosAnteriores = consultarPagamentosCadastrados(parametrosVenda);
                if (!VerificadorUtil.isListaNulaOuVazia(pagamentosAnteriores)) {
                        for (VendaFormaPagamento pagamento : pagamentosAnteriores) {
                                formasPagamento = formasPagamento + " R$" + pagamento.getValorPagamento() + " (" + pagamento.getFormaPagamento().getDescricao();
                                if (VerificadorUtil.naoEstaNulo(pagamento.getBandeiraCartao())) {
                                        formasPagamento =  formasPagamento + " - " + pagamento.getBandeiraCartao().getTipoCartaoDescricao() + " - " + pagamento.getDescricaoDaBandeiraCartao();
                                }
                                formasPagamento =  formasPagamento + "); ";
                        }
                }
                if (!VerificadorUtil.isListaNulaOuVazia(parametrosVenda.getLancamentosPagamentos())) {
                        for (VendaFormaPagamento pagamento : parametrosVenda.getLancamentosPagamentos()) {
                                novasFormasPagamento = novasFormasPagamento + " R$" + pagamento.getValorPagamento() + " (" + pagamento.getFormaPagamento().getDescricao();
                                if (VerificadorUtil.naoEstaNulo(pagamento.getBandeiraCartao())) {
                                        novasFormasPagamento =  novasFormasPagamento + " - " + pagamento.getBandeiraCartao().getTipoCartaoDescricao() + " - " + pagamento.getDescricaoDaBandeiraCartao();
                                }
                                novasFormasPagamento =  novasFormasPagamento + "); ";
                        }
                }
                if (!formasPagamento.equals(novasFormasPagamento)) {
                        conteudo.append("FORMAS DE PAGAMENTO: " + formasPagamento + " -> " + novasFormasPagamento + "\n");
                }
               
                conteudo.append("\n");
                conteudo.append("JUSTIFICATIVA: " + parametrosVenda.getVenda().getJustificativaParaExcluir() + "\n");
                new GerenciadorEmailImpl()
                        .comEmailsDestino(ConstantesSEC.DESTINATARIOS_EMAIL_SUPERVISAO)
                        .comAssunto("ESPAÇO CASE - ALTERAÇÃO DE VENDA: " + diaAtual)
                        .comConteudo(conteudo.toString())
                        .enviar();
        }
       
        private String montarDadosDaVenda(Venda venda, Usuario usuario, List<Lancamento> lancamentos, List<VendaFormaPagamento> pagamentos) {
                StringBuilder conteudo = new StringBuilder();
                conteudo.append("OPERAÇÃO REALIZADA POR: " + usuario.getNome() + "\n");
                conteudo.append("ID: " + venda.getSequencial() + "\n");
                conteudo.append("DATA DA VENDA: " + DataUtils.converterDataComHorarioParaString(venda.getDataVenda()) + "\n");
                conteudo.append("LOJA: " + venda.getLoja().getDescricao() + "\n");
                conteudo.append("VENDEDOR: " + venda.getVendedor().getNomeDaPessoa() + "\n");
                conteudo.append("TOTAL: " + valorTotalVenda(lancamentos) + "\n");
                conteudo.append("OBS.: " + venda.getObservacao() + "\n");
                if (VerificadorUtil.naoEstaNuloOuVazio(venda.getJustificativaParaExcluir())) {
                        conteudo.append("JUSTIFICATIVA: " + venda.getJustificativaParaExcluir() + "\n");
                } else {
                        conteudo.append("SEM JUSTIFICATIVA\n");
                }
                conteudo.append("--------------------------------------------------\n");
                for (Lancamento lancamento : lancamentos) {
                        conteudo.append(lancamento.getProduto().getCodigoProdutoPadrao() + " | ");
                        conteudo.append(lancamento.getProduto().getDescricaoComModeloCompleta() + ", ");
                        conteudo.append("R$" + lancamento.getValorVenda());
                        if (lancamento.comDescontos()) {
                                conteudo.append(" (COM DESCONTO DE R$" + lancamento.valorDescontos());
                                conteudo.append(" [" + lancamento.valorPercentualDescontos() + "])");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(lancamento.getObservacao())) {
                                conteudo.append(" (OBS.: " + lancamento.getObservacao() + ")");
                        }
                        if (VerificadorUtil.naoEstaNulo(lancamento.getCupom())) {
                                String descricaoCupom = lancamento.getCupom().getCodigo();
                                if (VerificadorUtil.naoEstaNulo(lancamento.getCupom().getDescricao())) {
                                        descricaoCupom = descricaoCupom + " - " + lancamento.getCupom().getDescricao();
                                }
                                conteudo.append(" (CUPOM: " + descricaoCupom + ")");
                        }
                        conteudo.append("\n");
                }
                conteudo.append("--------------------------------------------------\n");
                for (VendaFormaPagamento pagamento : pagamentos) {
                        if (VerificadorUtil.naoEstaNulo(pagamento.getBandeiraCartao())) {
                                conteudo.append(pagamento.getFormaPagamento().getDescricao() + " - " + pagamento.getBandeiraCartao().getDescricao() + ": R$" +  pagamento.getValorPagamento() + "\n");
                        } else {
                                conteudo.append(pagamento.getFormaPagamento().getDescricao() + ": R$" + pagamento.getValorPagamento() + "\n");
                        }
                        conteudo.append("\n");
                }
                conteudo.append("--------------------------------------------------\n");
                if (VerificadorUtil.naoEstaNulo(venda.getCliente())) {
                        conteudo.append("DADOS DO CLIENTE:\n");
                        conteudo.append(venda.getCliente().getNome() + "\n");
                        conteudo.append(venda.getCliente().getCpfCnpjFormatado() + "\n");
                }
                return conteudo.toString();
        }
       
        private Double valorTotalVenda(List<Lancamento> lancamentos) {
                Double total = new Double(0.0);
                for (Lancamento lancamento : lancamentos) {
                        if (lancamento.getAtivo()) {
                                total = total + lancamento.getValorVenda();
                        }
                }
                return total;
        }

        private void atualizarDadosDaVenda(ParametrosVendaDTO parametrosVenda) {
                parametrosVenda.getVenda().setVendedor(parametrosVenda.getVendedor());
                parametrosVenda.getVenda().setIndicacao(parametrosVenda.getIndicacao());
                parametrosVenda.getVenda().setCliente(parametrosVenda.getCliente());
                parametrosVenda.getVenda().setObservacao(parametrosVenda.getObservacao());
                parametrosVenda.getVenda().setNotaFiscal(parametrosVenda.getNotaFiscal());
                parametrosVenda.getVenda().setMaquineta(parametrosVenda.getMaquineta());
                if (!parametrosVenda.getVenda().getLoja().equals(parametrosVenda.getLoja())) {
                        for (Lancamento lancamento : parametrosVenda.getVenda().getLancamentos()) {
                                alterarEstoqueProduto(1, parametrosVenda.getVenda().getLoja(), lancamento.getProduto().getCodigo());
                                alterarEstoqueProduto(-1, parametrosVenda.getLoja(), lancamento.getProduto().getCodigo());
                        }
                        parametrosVenda.getVenda().setLoja(parametrosVenda.getLoja());
                        parametrosVenda.getVenda().setMaquineta(parametrosVenda.getLoja().getMaquineta());
                }
                parametrosVenda.getVenda().setTipoSituacao(parametrosVenda.getTipoSituacao());
                parametrosVenda.getVenda().setDataVenda(parametrosVenda.getDataVenda());
        }
       
        @Override
        public List<Venda> consultarVendasDoDia(Long sequencialLoja, Date dataVendas) {
                return vendaRepository.consultarVendasDoDia(sequencialLoja, dataVendas);
        }
       
        @Override
        public Integer obterQuantidadeDeVendasPorLojaEePeriodo(Venda venda, Date dataInicial, Date dataFinal) {
                return vendaRepository.obterQuantidadeDeVendasPorLojaEePeriodo(venda, dataInicial, dataFinal);
        }
       
        @Override
        public Double obterValorTotalBrutoDeVendasPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsulta) {
                Double valorTotal = vendaRepository.obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsulta);
                valorTotal = valorTotal - vendaRepository.obterValorDeCuponsUtilizadosPorLojaEePeriodo(parametrosConsulta);
                return valorTotal;
        }
       
        @Override
        public Double obterValorTotalDeDescontosPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsulta) {
                return vendaRepository.obterValorTotalDeDescontosPorLojaEePeriodo(parametrosConsulta);
        }
       
        @Override
        public Double obterValorTotalBrutoDeVendasPorLojaEePeriodoEeFormasDePagamento(ParametrosConsultaVendasDTO parametrosConsultaVendas, List<FormaPagamento> formasDePagamento) {
                return vendaRepository.obterValorTotalBrutoDeVendasPorLojaEePeriodoEeFormasDePagamento(parametrosConsultaVendas, formasDePagamento);
        }
       
        @Override
        public Integer obterQuantidadeProdutosVendidosPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
                return vendaRepository.obterQuantidadeProdutosVendidosPorLojaEePeriodo(parametrosConsultaVendas);
        }
       
        @Override
        public Integer obterQuantidadeProdutosVendidosPorLojaEePeriodoNaoVivo(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
                return vendaRepository.obterQuantidadeProdutosVendidosPorLojaEePeriodoNaoVivo(parametrosConsultaVendas);
        }
       
        @Override
        public Integer obterQuantidadeProdutosVendidosPorEstiloEeGenero(Date dataInicial, Date dataFinal, Long sequencialLoja, Long sequencialModelo, String tipoProduto, String estiloProduto, String tipoGenero) {
                return vendaRepository.obterQuantidadeProdutosVendidosPorEstiloEeGenero(dataInicial, dataFinal, sequencialLoja, sequencialModelo, tipoProduto, estiloProduto, tipoGenero);
        }
       
        private void verificarLancamentos(List<Lancamento> lancamentos) {
                if (lancamentos.isEmpty()) {
                        throw new NegocioException("Obrigatório informar ao menos um produto");
                }
        }
*/     
        // TODO: EM DESENVOLVIMENTO
        /*
        private void lancarExcecaoCasoFreteContraditorio(ParametrosVendaDTO parametrosVenda) {
                if (VerificadorUtil.naoEstaNulo(parametrosVenda.getTipoFrete())) {
                        if (parametrosVenda.getTipoFrete().equals(ConstantesSEC.NotaFiscal.Transporte.SEM_OCORRENCIA_TRANSPORTE_9)
                                        && parametrosVenda.getValorFrete() > 0.0) {
                                throw new NegocioException("Não é possível informar o frete sem a ocorrência.");
                        }
                        if (parametrosVenda.getTipoFrete().equals(ConstantesSEC.NotaFiscal.Transporte.FRETE_POR_CONTA_REMETENTE_TRANSPORTE_PROPRIO_3)
                                        && parametrosVenda.getValorFrete() == 0.0) {
                                throw new NegocioException("É necessário informar o valor do frete.");
                        }
                       
                }
                // CASO TENHA VALOR E: FRETE CIF, FRETE DE TERCEIROS, FRETE REMETENTE (TP) OU SEM OCORRÊNCIA
                // CASO NÃO TENHA VALOR E: FRETE FOB.
        }
        */
/*     
        private void lancarExcecaoCasoNaoSejaInformadoCamposObrigatorios(ParametrosVendaDTO parametrosVenda) {
                if (VerificadorUtil.isListaNulaOuVazia(parametrosVenda.getLancamentosPagamentos()) && VerificadorUtil.estaNuloOuVazio(parametrosVenda.getObservacao())) {
                        throw new NegocioException("Obrigatório informar as observações em vendas sem pagamentos");
                }
                if (VerificadorUtil.estaNulo(parametrosVenda.getLoja())) {
                        throw new NegocioException("Informe a loja");
                }
        }
*/
//      private void lancarExcecaoSeValoresNaoSaoIguais(ParametrosVendaDTO parametrosVenda) {
//              final double TOLERANCE = 0.01;
//              if(Math.abs(parametrosVenda.valorTotalLancamentos() /*+ parametrosVenda.getValorFrete() */- parametrosVenda.valorTotalPago()) > TOLERANCE) {
//                      throw new NegocioException("Valores pagos não corresponde ao valor vendido.");
//              }
//      }
/*
        private void cadastrarLancamentos(ParametrosVendaDTO parametrosVenda, Venda venda) {
                for (Lancamento lancamento : parametrosVenda.getLancamentos()) {
                        cadastrarLancamento(parametrosVenda.getLoja(), venda, lancamento);
                }
        }
       
        private void alterarLancamentos(ParametrosVendaDTO parametrosVenda) {
                excluirLancamentosRetiradosDaLista(parametrosVenda, consultarLancamentosCadastrados(parametrosVenda));
                cadastrarNovosLancamentos(parametrosVenda);
        }

        private void excluirLancamentosRetiradosDaLista(ParametrosVendaDTO parametrosVenda, List<Lancamento> lancamentosAntigos) {
                for (Lancamento lancamentoAntigo : lancamentosAntigos) {
                        if (!parametrosVenda.getLancamentos().contains(lancamentoAntigo)) {
                                lancamentoService.excluir(lancamentoAntigo);
                                alterarEstoqueProduto(1, parametrosVenda.getLoja(), lancamentoAntigo.getProduto().getCodigo());
                        }
                }
        }

        private void cadastrarNovosLancamentos(ParametrosVendaDTO parametrosVenda) {
                for (Lancamento lancamento : parametrosVenda.getLancamentos()) {
                        if (VerificadorUtil.estaNulo(lancamento.getSequencial())) {
                                cadastrarLancamento(parametrosVenda.getLoja(), parametrosVenda.getVenda(), lancamento);
                        }
                }
        }

        private List<Lancamento> consultarLancamentosCadastrados(ParametrosVendaDTO parametrosVenda) {
                Lancamento lancamentoDaVenda = new Lancamento();
                lancamentoDaVenda.setVenda(parametrosVenda.getVenda());
                return lancamentoService.consultarPassandoEntidade(lancamentoDaVenda, 0, lancamentoService.obterQuantidadeDeRegistrosPassandoEntidade(lancamentoDaVenda));
        }

        private void cadastrarLancamento(Loja loja, Venda venda, Lancamento lancamento) {
                lancamento.setVenda(venda);
                igualarValorVarejoComCompraSeProdutoForPadrao(lancamento);
                acrescentarValorIPISeHouver(lancamento);
                lancamentoService.cadastrar(lancamento);
                alterarEstoqueProduto(-1, loja, lancamento.getProduto().getCodigo());
                utilizarCupom(lancamento.getCupom());
               
        }
       
        private void igualarValorVarejoComCompraSeProdutoForPadrao(Lancamento lancamento) {
                if (VerificadorUtil.naoEstaNulo(lancamento.getProduto())) {
                        if (lancamento.getProduto().getCodigo().equals(ConstantesSEC.CODIGO_PRODUTO_PADRAO_000000)) {
                                lancamento.setValorVarejo(lancamento.getValorVenda());
                        }
                }
        }
       
        private void acrescentarValorIPISeHouver(Lancamento lancamento) {
                if (VerificadorUtil.naoEstaNulo(lancamento.getProduto())) {
                        lancamento.setValorCompra(lancamento.getProduto().getValorCompra());
//                      lancamento.setValorCompra(lancamento.getProduto().calculoOperacao());
                }
        }

        private void cadastrarPagamentos(ParametrosVendaDTO parametrosVenda, Venda venda) {
                for (VendaFormaPagamento vendaFormaPagamento : parametrosVenda.getLancamentosPagamentos()) {
                        adicionarMaquineta(vendaFormaPagamento, parametrosVenda, venda);
                        vendaFormaPagamento.setVenda(venda);
                        vendaFormaPagamentoService.cadastrar(vendaFormaPagamento);
                        utilizarCupom(vendaFormaPagamento.getCupom());
                }
        }

        private void adicionarMaquineta(VendaFormaPagamento vendaFormaPagamento, ParametrosVendaDTO parametrosVenda, Venda venda) {
                if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhCartao()) {
                        if (VerificadorUtil.estaNulo(parametrosVenda.getMaquineta())) {
                                parametrosVenda.setMaquineta(parametrosVenda.getLoja().getMaquineta());
                        }
                        venda.setMaquineta(parametrosVenda.getMaquineta());
                }
        }
       
        private void alterarPagamentos(ParametrosVendaDTO parametrosVenda) {
                excluirPagamentosRetiradosDaLista(parametrosVenda, consultarPagamentosCadastrados(parametrosVenda));
                cadastrarNovosPagamentos(parametrosVenda);
        }

        private void excluirPagamentosRetiradosDaLista(ParametrosVendaDTO parametrosVenda, List<VendaFormaPagamento> pagamentosAntigos) {
                for (VendaFormaPagamento pagamentoAntigo : pagamentosAntigos) {
                        if (!parametrosVenda.getLancamentosPagamentos().contains(pagamentoAntigo)) {
                                vendaFormaPagamentoService.excluir(pagamentoAntigo);
                        }
//                      if (verificarSePagamentoFoiRetiradoDaLista(parametrosVenda.getLancamentosPagamentos(), pagamentoAntigo)) {
//                              vendaFormaPagamentoService.excluirPorId(pagamentoAntigo);
//                      }
                }
        }
       
        private boolean verificarSePagamentoFoiRetiradoDaLista(List<VendaFormaPagamento> pagamentos, VendaFormaPagamento pagamentoAntigo) {
                boolean pagamentoRetirado = true;
                for (VendaFormaPagamento pagamento : pagamentos) {
                        if (pagamento.getCodigoDaFormaPagamento().equals(pagamentoAntigo.getCodigoDaFormaPagamento())) {
                                if (verificarSeBandeiraCartaoEhIgual(pagamento.getCodigoDaBandeiraCartao(), pagamentoAntigo.getCodigoDaBandeiraCartao()) &&
                                                pagamento.getValorPagamento().equals(pagamentoAntigo.getValorPagamento())) {
                                        return false;
                                } else {
                                        pagamento.setVenda(pagamentoAntigo.getVenda());
                                        vendaFormaPagamentoService.alterar(pagamento);
                                        return false;
                                }
                        }
                }
                return pagamentoRetirado;
        }

        private boolean verificarSeBandeiraCartaoEhIgual(Long codigoDaBandeiraCartao, Long codigoDaBandeiraCartaoSegundo) {
                if (VerificadorUtil.naoEstaNulo(codigoDaBandeiraCartao) && VerificadorUtil.naoEstaNulo(codigoDaBandeiraCartaoSegundo)) {
                        return codigoDaBandeiraCartao.equals(codigoDaBandeiraCartaoSegundo);
                }
                if ((VerificadorUtil.estaNulo(codigoDaBandeiraCartao) && VerificadorUtil.naoEstaNulo(codigoDaBandeiraCartaoSegundo)) ||
                                (VerificadorUtil.naoEstaNulo(codigoDaBandeiraCartao) && VerificadorUtil.estaNulo(codigoDaBandeiraCartaoSegundo))) {
                        return false;
                }
                return true;
        }

        private void cadastrarNovosPagamentos(ParametrosVendaDTO parametrosVenda) {
                for (VendaFormaPagamento pagamento : parametrosVenda.getLancamentosPagamentos()) {
                        if (VerificadorUtil.estaNulo(pagamento.getSequencial())) {
                                adicionarMaquineta(pagamento, parametrosVenda, parametrosVenda.getVenda());
                                pagamento.setVenda(parametrosVenda.getVenda());
                                vendaFormaPagamentoService.cadastrar(pagamento);
                                utilizarCupom(pagamento.getCupom());
                        }
                }
        }
       
        private List<VendaFormaPagamento> consultarPagamentosCadastrados(ParametrosVendaDTO parametrosVenda) {
                VendaFormaPagamento pagamentoDaVenda = new VendaFormaPagamento();
                pagamentoDaVenda.setVenda(parametrosVenda.getVenda());
                return vendaFormaPagamentoService.consultarPassandoEntidade(pagamentoDaVenda, 0, vendaFormaPagamentoService.obterQuantidadeDeRegistrosPassandoEntidade(pagamentoDaVenda));
        }
       
        private void alterarEstoqueProduto(Integer quantidadeAlterar, Loja loja, String codigoProduto) {
                if (VerificadorUtil.naoEstaNulo(codigoProduto)) {
                        Produto produto = produtoService.consultarProdutoPorCodigo(codigoProduto);
                        produtoLojaService.alterarEstoqueAcrescentandoQuantidadeInformada(quantidadeAlterar, produto, loja);
                }
        }
       
        private void utilizarCupom(Cupom cupom) {
                if (VerificadorUtil.naoEstaNulo(cupom)) {
                        Cupom cupomUtilizado = cupomService.consultarPorId(cupom);
                        cupomUtilizado.setDataHoraUtilizado(DataUtils.getDataAtual());
                        if (VerificadorUtil.estaNulo(cupomUtilizado.getQuantidadeUtilizada())) {
                                cupomUtilizado.setQuantidadeUtilizada(0);
                        }
                        cupomUtilizado.setQuantidadeUtilizada(cupomUtilizado.getQuantidadeUtilizada() + 1);
                        cupomService.alterar(cupomUtilizado);
                }
        }
       
        @Override
        public List<Venda> consultarVendasPorDemanda(ParametrosConsulta<Venda> parametrosConsulta, Integer primeiroRegistro,
                        Integer tamanhoPagina, String sortField, String orderSort, Map<String, Object> filters) {
                return vendaRepository.consultarVendasPorDemanda(parametrosConsulta, primeiroRegistro, tamanhoPagina, sortField, orderSort, filters);
        }
       
        @Override
        public List<Venda> consultarVendaPorParametros(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
                return vendaRepository.consultarVendaPorParametros(parametrosConsultaVendas);
        }
       
        @Override
        public GraficoAcumuladoDTO consultarGrafico(String mes, String ano) {
                return vendaRepository.consultarGrafico(mes, ano);
        }
       
        @Override
        public List<RankingVendedorDTO> consultarRankingVendedores(Date dataInicial, Date dataFinal, Boolean produtosComissionados, Loja lojaSelecionada) {
                List<RankingVendedorDTO> rankingVendedores = new ArrayList<RankingVendedorDTO>();
                List<Vendedor> vendedores = vendedorService.consultarVendedoresColaboradoresAtivos(lojaSelecionada);
                for (Vendedor vendedor : vendedores) {
                        RankingVendedorDTO vendedorConsultado = consultarRankingVendedor(vendedor, dataInicial, dataFinal, produtosComissionados);
                        rankingVendedores.add(vendedorConsultado);
                }
                return (List<RankingVendedorDTO>) ordenador.ordenar(rankingVendedores);
        }
       
        @Override
        public RankingVendedorDTO consultarRankingVendedor(Vendedor vendedor, Vigencia vigencia, Boolean produtosComissionados) {
                Avaliacao avaliacao = avaliacaoService.consultarAvaliacaoDaVigencia(vigencia);
                RankingVendedorDTO rankingVendedor = consultarRankingVendedor(vendedor, vigencia.getDataInicio(), vigencia.getDataFim(), produtosComissionados);
                rankingVendedor.setFuncionario(funcionarioService.consultarFuncionarioPorPessoa(vendedor.getPessoa()));
                rankingVendedor.setQuantidadeBancoHoras(bancoHorasService.consultarQuantidadeHoras(rankingVendedor.getFuncionario()));
                AvaliacaoFuncionario avaliacaoFuncionario = avaliacaoFuncionarioService.detalhar(vendedor.getPessoa(), avaliacao);
                if (VerificadorUtil.naoEstaNuloOuVazio(avaliacaoFuncionario)) {
                        rankingVendedor.setAvaliacaoFuncionario(avaliacaoFuncionario);
                        if (VerificadorUtil.naoEstaNulo(avaliacaoFuncionario.getPorcentagemComissao())) {
                                rankingVendedor.setComissao(calcularComissao(rankingVendedor.getValorTotalVendido(), avaliacaoFuncionario.getPorcentagemComissao()/100));
                        } else {
                                rankingVendedor.setComissao(calcularComissao(rankingVendedor.getValorTotalVendido(), avaliacaoFuncionario.retornarFaixaComissao(rankingVendedor.getValorTotalVendido(), rankingVendedor.getFuncionario().getTipoComissionamento())));
                        }
                }
                return rankingVendedor;
        }
       
        public Double calcularComissao(Double valorTotalVendido, Double porcentagemComissao) {
                if (VerificadorUtil.naoEstaNuloOuVazio(porcentagemComissao)) {
                        return valorTotalVendido * porcentagemComissao;
                }
                return 0.0;
        }
       
        @Override
        public RankingVendedorDTO consultarRankingVendedor(Vendedor vendedor, Date dataInicial, Date dataFinal, Boolean produtosComissionados) {
                ParametrosConsultaVendasDTO parametrosConsultaVendas = new ParametrosConsultaVendasDTO();
                parametrosConsultaVendas.setDataInicial(DataUtils.getDataComHorarioMinimo(dataInicial));
                parametrosConsultaVendas.setDataFinal(DataUtils.getDataComHorarioMaximo(dataFinal));
                parametrosConsultaVendas.setVendedor(vendedor);
                if (VerificadorUtil.naoEstaNulo(produtosComissionados)) {
                        parametrosConsultaVendas.setIndicadorComissionado(produtosComissionados);
                }
               
                RankingVendedorDTO rankingVendedor = new RankingVendedorDTO();
                rankingVendedor.setVendedor(vendedor);
                try {
                        rankingVendedor.setFuncionario(funcionarioService.consultarFuncionarioPorPessoa(vendedor.getPessoa()));
                        rankingVendedor.setQuantidadeBancoHoras(bancoHorasService.consultarQuantidadeHoras(rankingVendedor.getFuncionario()));
                } catch (RuntimeException e) {
                        rankingVendedor.setFuncionario(null);
                }
               
                rankingVendedor.setValorTotalVendido(obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsultaVendas));
                rankingVendedor.setValorTotalDescontos(obterValorTotalDeDescontosPorLojaEePeriodo(parametrosConsultaVendas));
                rankingVendedor.setQuantidadeTotalProdutosVendidos(obterQuantidadeProdutosVendidosPorLojaEePeriodo(parametrosConsultaVendas));
               
                Venda venda = new Venda();
                venda.setVendedor(vendedor);
                rankingVendedor.setQuantidadeVendas(obterQuantidadeDeVendasPorLojaEePeriodo(venda, dataInicial, dataFinal));
                rankingVendedor.setQuantidadePedidos(obterQuantidadePedidosValidos(vendedor, null, dataInicial, dataFinal));
                rankingVendedor.setQuantidadePedidosInvalidos(obterQuantidadePedidos(vendedor, null, dataInicial, dataFinal, TipoSituacaoPedido.INVALIDO.getValor()));
                rankingVendedor.setQuantidadeContagens(obterQuantidadeDeContagens(vendedor, dataInicial, dataFinal));
                rankingVendedor.setQuantidadeAtendimentos(obterQuantidadeDeAtendimentos(vendedor, dataInicial, dataFinal));
                rankingVendedor.setValorTotalVendidoVivo(obterValorTotalBrutoDeVendasVivoPorLojaEePeriodo(parametrosConsultaVendas));
               
                rankingVendedor.setAvaliacaoFuncionario(avaliacaoFuncionarioService.consultarAvaliacaoFuncionarioPelaData(vendedor, DataUtils.getDataComHorarioMinimo(dataFinal)));
                if (VerificadorUtil.naoEstaNulo(rankingVendedor.getAvaliacaoFuncionario())) {
                        rankingVendedor.setPercentualDescontos(rankingVendedor.getAvaliacaoFuncionario().retornarPercentual(rankingVendedor.getValorTotalDescontos(), rankingVendedor.getValorTotalVendido()));
                        rankingVendedor.setPercentualMetaMensal(rankingVendedor.getAvaliacaoFuncionario().retornarPercentualRealizado(rankingVendedor.getValorTotalVendido()));
                        rankingVendedor.setPercentualMetaMensalVivo(rankingVendedor.getAvaliacaoFuncionario().retornarPercentualVivoRealizado(rankingVendedor.getValorTotalVendidoVivo()));
                }
               
                ParametrosConsultaVendasDTO parametrosConsultaVendasDoDia = new ParametrosConsultaVendasDTO();
                parametrosConsultaVendasDoDia.setDataInicial(DataUtils.getDataComHorarioMinimo(DataUtils.getDataAtual()));
                parametrosConsultaVendasDoDia.setDataFinal(DataUtils.getDataComHorarioMaximo(DataUtils.getDataAtual()));
                parametrosConsultaVendasDoDia.setVendedor(vendedor);
                if (VerificadorUtil.naoEstaNulo(produtosComissionados)) {
                        parametrosConsultaVendasDoDia.setIndicadorComissionado(produtosComissionados);
                }
                rankingVendedor.setValorTotalVendidoDoDia(obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsultaVendasDoDia));
               
                return rankingVendedor;
        }

        private Integer obterQuantidadePedidos(Vendedor vendedor, Loja loja, Date dataInicial, Date dataFinal, String tipoSituacao) {
                if (VerificadorUtil.naoEstaNulo(vendedor)) {
                        if (VerificadorUtil.estaNulo(vendedor.getPessoa())) {
                                return 0;
                        }
                }
                ParametrosConsultaPedidoDTO parametrosPedidos = new ParametrosConsultaPedidoDTO();
                if (VerificadorUtil.naoEstaNulo(vendedor)) {
                        parametrosPedidos.setPessoa(vendedor.getPessoa());
                }
                parametrosPedidos.setEntidade(new Pedido());
                parametrosPedidos.getEntidade().setTipoSituacao(tipoSituacao);
                parametrosPedidos.getEntidade().setLoja(loja);
                parametrosPedidos.setDataInicial(dataInicial);
                parametrosPedidos.setDataFinal(dataFinal);
                return pedidoService.obterQuantidadeDeRegistrosParametrosConsulta(parametrosPedidos);
        }
       
        private Integer obterQuantidadePedidosValidos(Vendedor vendedor, Loja loja, Date dataInicial, Date dataFinal) {
                if (VerificadorUtil.naoEstaNulo(vendedor)) {
                        if (VerificadorUtil.estaNulo(vendedor.getPessoa())) {
                                return 0;
                        }
                }
                ParametrosConsultaPedidoDTO parametrosPedidos = new ParametrosConsultaPedidoDTO();
                if (VerificadorUtil.naoEstaNulo(vendedor)) {
                        parametrosPedidos.setPessoa(vendedor.getPessoa());
                }
                parametrosPedidos.setEntidade(new Pedido());
                parametrosPedidos.getEntidade().setLoja(loja);
                parametrosPedidos.setDataInicial(dataInicial);
                parametrosPedidos.setDataFinal(dataFinal);
                parametrosPedidos.setValidos(true);
                return pedidoService.obterQuantidadeDeRegistrosParametrosConsulta(parametrosPedidos);
        }
       
        private Integer obterQuantidadeDeContagens(Vendedor vendedor, Date dataInicial, Date dataFinal) {
                if (VerificadorUtil.naoEstaNulo(vendedor)) {
                        if (VerificadorUtil.estaNulo(vendedor.getPessoa())) {
                                return 0;
                        }
                }
                return produtoLojaService.obterQuantidadeDeContagens(vendedor.getPessoa(), dataInicial, dataFinal);
        }
       
        private Integer obterQuantidadeDeAtendimentos(Vendedor vendedor, Date dataInicial, Date dataFinal) {
                if (VerificadorUtil.estaNulo(vendedor.getPessoa())) {
                        return 0;
                }
                return produtoLojaService.obterQuantidadeDeAtendimentos(vendedor.getPessoa(), dataInicial, dataFinal);
        }
       
        private Integer obterQuantidadeDeAtendimentos(Loja loja, Date dataInicial, Date dataFinal) {
                return produtoLojaService.obterQuantidadeDeAtendimentos(loja, dataInicial, dataFinal);
        }

        private Double obterValorTotalBrutoDeVendasVivoPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
                ParametrosConsultaVendasVivoDTO parametrosConsultaVendasVivo = new ParametrosConsultaVendasVivoDTO();
                parametrosConsultaVendasVivo.setVendedor(parametrosConsultaVendas.getVendedor());
                parametrosConsultaVendasVivo.setDataInicial(parametrosConsultaVendas.getDataInicial());
                parametrosConsultaVendasVivo.setDataFinal(parametrosConsultaVendas.getDataFinal());
                return vendaVivoService.obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsultaVendasVivo);
        }
       
        @Override
        public List<RankingLojaDTO> consultarRankingLojas(Date dataInicial, Date dataFinal) {
                List<RankingLojaDTO> rankingLojas = new ArrayList<RankingLojaDTO>();
                List<Loja> lojas = lojaService.listarLojasAtivas();
                ParametrosConsultaVendasDTO parametrosConsultaVendas = new ParametrosConsultaVendasDTO();
                parametrosConsultaVendas.setDataInicial(DataUtils.getDataComHorarioMinimo(dataInicial));
                parametrosConsultaVendas.setDataFinal(DataUtils.getDataComHorarioMaximo(dataFinal));
                for (Loja loja : lojas) {
                        if (!loja.getSequencial().equals(ConstantesSEC.SEQUENCIAL_LOJA_FARMACIA_7)
                                        && !loja.getSequencial().equals(ConstantesSEC.SEQUENCIAL_RESTAURANTE_16)) {
                                parametrosConsultaVendas.setLoja(loja);
                               
                                RankingLojaDTO rankingLoja = new RankingLojaDTO();
                                rankingLoja.setLoja(loja);
                                rankingLoja.setValorTotalVendido(obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsultaVendas)
                                                - obterValorTotalBrutoDeVendasPorLojaEePeriodoServicos(parametrosConsultaVendas));
                                rankingLoja.setAvaliacaoLoja(avaliacaoLojaService.consultarAvaliacaoLojaPelaData(loja, DataUtils.getDataComHorarioMinimo(dataFinal)));
                                if (VerificadorUtil.naoEstaNulo(rankingLoja.getAvaliacaoLoja())) {
                                        rankingLoja.setValorMetaMensal(rankingLoja.getAvaliacaoLoja().getValorMetaMensal());
                                }
                                rankingLojas.add(rankingLoja);
                        }
                }
                return (List<RankingLojaDTO>) ordenador.ordenar(rankingLojas);
        }
       
        @Override
        public List<RankingLojaDTO> consultarRankingLojasCompleto(Date dataInicial, Date dataFinal) {
                List<RankingLojaDTO> rankingLojasCompleto = new ArrayList<RankingLojaDTO>();
                List<RankingLojaDTO> rankingLojas = consultarRankingLojas(dataInicial, dataFinal);
                for (RankingLojaDTO rankingLoja : rankingLojas) {
                        rankingLoja.setQuantidadeVendas(obterQuantidadeDeVendasPorLojaEePeriodo(new Venda(rankingLoja.getLoja(), null), dataInicial, dataFinal));
                        rankingLoja.setQuantidadeAtendimentos(obterQuantidadeDeAtendimentos(rankingLoja.getLoja(), dataInicial, dataFinal));
                        rankingLoja.setQuantidadePedidos(obterQuantidadePedidosValidos(null, rankingLoja.getLoja(), dataInicial, dataFinal));
                        rankingLoja.setQuantidadePedidosInvalidos(obterQuantidadePedidos(null, rankingLoja.getLoja(), dataInicial, dataFinal, TipoSituacaoPedido.INVALIDO.getValor()));
                       
                        ParametrosConsultaPorPeriodoDTO parametrosConsulta = new ParametrosConsultaPorPeriodoDTO();
                        ((ParametrosConsultaPorPeriodoDTO)parametrosConsulta).setDataInicial(dataInicial);
                        ((ParametrosConsultaPorPeriodoDTO)parametrosConsulta).setDataFinal(dataFinal);
                        EstoqueAuditoria estoqueAuditoria = new EstoqueAuditoria();
                        estoqueAuditoria.setLoja(rankingLoja.getLoja());
                        estoqueAuditoria.setTipoEstoqueAuditoria(TipoEstoqueAuditoria.AVARIA.getValor());
                        parametrosConsulta.setEntidade(estoqueAuditoria);
                        rankingLoja.setQuantidadeAvarias(estoqueAuditoriaService.obterQuantidadeTotalAuditoria(parametrosConsulta));
                       
                        estoqueAuditoria.setTipoEstoqueAuditoria(TipoEstoqueAuditoria.TROCA.getValor());
                        parametrosConsulta.setEntidade(estoqueAuditoria);
                        rankingLoja.setQuantidadeTrocas(estoqueAuditoriaService.obterQuantidadeTotalAuditoria(parametrosConsulta));
                       
                        ParametrosConsultaVendasDTO parametrosConsultaVendas = new ParametrosConsultaVendasDTO();
                        parametrosConsultaVendas.setDataInicial(DataUtils.getDataComHorarioMinimo(dataInicial));
                        parametrosConsultaVendas.setDataFinal(DataUtils.getDataComHorarioMaximo(dataFinal));
                        parametrosConsultaVendas.setLoja(rankingLoja.getLoja());
                        rankingLoja.setValorTotalDescontos(obterValorTotalDeDescontosPorLojaEePeriodo(parametrosConsultaVendas));
                        rankingLoja.setCustoProdutosVendidos(obterValorProdutosUtilizadosEmVendasPorLojaEePeriodo(parametrosConsultaVendas));
                        rankingLoja.setValorTotalEstoque(produtoService.valorTotalEstoque(rankingLoja.getLoja(), null));
                        rankingLoja.setQuantidadeTotalEstoque(produtoService.quantidadeTotalEstoque(rankingLoja.getLoja()));
                       
                        ParametrosConsultaLancamentosDTO parametros = new ParametrosConsultaLancamentosDTO();
                        parametros.setCategoria(new Categoria(ConstantesSEC.Categoria.SEQUENCIAL_CATEGORIA_ALUGUEL_11));
                        parametros.setCentroDeCustos(rankingLoja.getLoja());
                        parametros.setPagamentoRealizado(true);
                        parametros.setDataInicial(dataInicial);
                        parametros.setDataFinal(dataFinal);
                        Double valorCac = 0.0;
                       
                        valorCac = somarValor(valorCac, parcelaService.obterValorPassandoParametrosConsulta(parametros));
                        parametros.setCategoria(new Categoria(ConstantesSEC.Categoria.SEQUENCIAL_CATEGORIA_HORA_EXTRA_2));
                        valorCac = somarValor(valorCac, parcelaService.obterValorPassandoParametrosConsulta(parametros));
                        parametros.setCategoria(new Categoria(ConstantesSEC.Categoria.SEQUENCIAL_CATEGORIA_SALARIO_9));
                        valorCac = somarValor(valorCac, parcelaService.obterValorPassandoParametrosConsulta(parametros));
                        parametros.setCategoria(new Categoria(ConstantesSEC.Categoria.SEQUENCIAL_CATEGORIA_FERIAS_12));
                        valorCac = somarValor(valorCac, parcelaService.obterValorPassandoParametrosConsulta(parametros));
                        parametros.setCategoria(new Categoria(ConstantesSEC.Categoria.SEQUENCIAL_CATEGORIA_COMISSOES_8));
                        valorCac = somarValor(valorCac, parcelaService.obterValorPassandoParametrosConsulta(parametros));
                        parametros.setCategoria(new Categoria(ConstantesSEC.Categoria.SEQUENCIAL_CATEGORIA_VALE_TRANSPORTE_46));
                        valorCac = somarValor(valorCac, parcelaService.obterValorPassandoParametrosConsulta(parametros));
                        valorCac = valorCac / rankingLoja.getQuantidadeVendas();
                        rankingLoja.setValorCac(valorCac);
                       
                        rankingLojasCompleto.add(rankingLoja);
                }
                return (List<RankingLojaDTO>) ordenador.ordenar(rankingLojasCompleto);
        }
       
        private Double somarValor(Double valor, Double valorAcrescentar) {
                if (VerificadorUtil.naoEstaNulo(valorAcrescentar)) {
                        return valor + valorAcrescentar;
                }
                return valor;
        }
       
        @Override
        public List<RankingLojaDTO> consultarRankingLojasExtras(Date dataInicial, Date dataFinal) {
                List<RankingLojaDTO> rankingLojas = new ArrayList<RankingLojaDTO>();
               
                ParametrosConsultaVendasDTO parametrosConsultaVendas = new ParametrosConsultaVendasDTO();
                parametrosConsultaVendas.setDataInicial(DataUtils.getDataComHorarioMinimo(dataInicial));
                parametrosConsultaVendas.setDataFinal(DataUtils.getDataComHorarioMaximo(dataFinal));
                // rankingLojas.addAll(preenchendoLojasExtras(parametrosConsultaVendas));
               
                parametrosConsultaVendas.setLoja(null);
                // rankingLojas.add(preencherLojaAssistencia(parametrosConsultaVendas));
               
                return (List<RankingLojaDTO>) ordenador.ordenar(rankingLojas);
        }
       
        private RankingLojaDTO preencherLojaAssistencia(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
                RankingLojaDTO rankingLojaServico = new RankingLojaDTO();
                Loja lojaServico = new Loja();
                lojaServico.setDescricao("ASSISTÊNCIA");
                rankingLojaServico.setValorMetaMensal(new Double(0.0));
                rankingLojaServico.setLoja(lojaServico);
                rankingLojaServico.setValorTotalVendido(obterValorTotalBrutoDeVendasPorLojaEePeriodoServicos(parametrosConsultaVendas));
                return rankingLojaServico;
        }
       
        private RankingLojaDTO preencherVendasComPedidos(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
                RankingLojaDTO rankingLojaServico = new RankingLojaDTO();
                Loja lojaServico = new Loja();
                lojaServico.setDescricao("E-COMMERCE");
                rankingLojaServico.setValorMetaMensal(new Double(0.0));
                rankingLojaServico.setLoja(lojaServico);
                rankingLojaServico.setValorTotalVendido(obterValorTotalBrutoDeVendasPorLojaEePeriodoServicos(parametrosConsultaVendas));
                return rankingLojaServico;
        }

        private List<RankingLojaDTO> preenchendoLojasExtras(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
                List<RankingLojaDTO> rankingLojas = new ArrayList<RankingLojaDTO>();
                List<Loja> lojas = lojaService.listarLojasAtivas();
                for (Loja loja : lojas) {
                        if (loja.getSequencial().equals(ConstantesSEC.SEQUENCIAL_LOJA_FARMACIA_7)
                                        || loja.getSequencial().equals(ConstantesSEC.SEQUENCIAL_RESTAURANTE_16)) {
                                parametrosConsultaVendas.setLoja(loja);
                               
                                RankingLojaDTO rankingLoja = new RankingLojaDTO();
                                rankingLoja.setLoja(loja);
                                rankingLoja.setValorTotalVendido(obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsultaVendas)
                                                - obterValorTotalBrutoDeVendasPorLojaEePeriodoServicos(parametrosConsultaVendas));
                                rankingLoja.setAvaliacaoLoja(avaliacaoLojaService.consultarAvaliacaoLojaPelaData(loja, DataUtils.getDataComHorarioMinimo(parametrosConsultaVendas.getDataFinal())));
                                if (VerificadorUtil.naoEstaNulo(rankingLoja.getAvaliacaoLoja())) {
                                        rankingLoja.setValorMetaMensal(rankingLoja.getAvaliacaoLoja().getValorMetaMensal());
                                }
                                rankingLojas.add(rankingLoja);
                        }
                }
                return rankingLojas;
        }
       
        @Override
        public Double obterValorTotalBrutoDeVendasPorLojaEePeriodoServicos(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
                parametrosConsultaVendas.setTipoProduto(TipoProduto.SERVICO.getValor());
                Double valorTotal = vendaRepository.obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsultaVendas);
                parametrosConsultaVendas.setTipoProduto(null);
                return VerificadorUtil.estaNulo(valorTotal)? new Double(0.0) : valorTotal;
        }

        @Override
        public List<RankingProdutoDTO> consultarProdutosVendidosResumido(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
                return vendaRepository.consultarProdutosVendidosResumido(parametrosConsulta);
        }
       
        @Override
        public List<RankingProdutoDTO> consultarProdutosParaTransferir(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
                return vendaRepository.consultarProdutosParaTransferir(parametrosConsulta);
        }
       
        @Override
        public List<RankingProdutoDTO> consultarRankingProdutos(Date dataInicial, Date dataFinal, Integer quantidadeProdutos, String tipoOrdenacao, Long sequencialLoja, String tipoProduto, Produto produto, Marca marca) {
                return vendaRepository.consultarProdutosMaisVendidos(dataInicial, dataFinal, quantidadeProdutos, tipoOrdenacao, sequencialLoja, tipoProduto, produto, marca);
        }
       
        @Override
        public List<RankingModeloDTO> consultarRankingModelos(Date dataInicial, Date dataFinal, Integer quantidadeModelos, String tipoOrdenacao, String tipoProduto, Long sequencialLoja) {
                ParametrosConsultaModelosMaisVendidosDTO parametros = new ParametrosConsultaModelosMaisVendidosDTO(dataInicial, dataFinal, quantidadeModelos, tipoOrdenacao, tipoProduto, sequencialLoja);
                return this.consultarRankingModelos(parametros);
        }
       
        @Override
        public List<RankingComprasTransferenciasDTO> consultarPlanejamentoParaCompras(ParametrosConsultaParaComprasTransferenciasDTO parametrosParaConsulta) {
                Integer limite = parametrosParaConsulta.getQuantidadeModelos();
                if (parametrosParaConsulta.getIndicadorConsultarTodosModelos()) {
                        limite = null;
                }
                List<RankingComprasTransferenciasDTO> planejamentos = new ArrayList<RankingComprasTransferenciasDTO>();
                ParametrosConsultaModelosMaisVendidosDTO parametrosConsulta = new ParametrosConsultaModelosMaisVendidosDTO(parametrosParaConsulta.getDataInicial(), parametrosParaConsulta.getDataFinal(), limite,
                                parametrosParaConsulta.getTipoOrdenacao(), parametrosParaConsulta.getTipoProduto(), parametrosParaConsulta.getSequencialLoja(), parametrosParaConsulta.getModelo(), parametrosParaConsulta.getEstilo());
                List<RankingModeloDTO> modelos = vendaRepository.consultarModelosMaisVendidos(parametrosConsulta);
                for (RankingModeloDTO modelo : modelos) {
                        RankingComprasTransferenciasDTO planejamento = new RankingComprasTransferenciasDTO();
                        planejamento.setModelo(modelo.getModelo());
                        planejamento.setValorTotalVendido(modelo.getValorTotalVendido());
                        planejamento.setValorTotalComprado(modelo.getValorTotalComprado());
                        planejamento.setQuantidadeVendas(modelo.getQuantidadeVendas());
                        planejamento.setQuantidadeMinimaComprar(parametrosParaConsulta.getQuantidadeMinimaComprar());
                        if (VerificadorUtil.naoEstaNuloOuVazio(modelo.getQuantidadeEstoqueLocal())) {
                                planejamento.setQuantidadeEstoqueLocal(modelo.getQuantidadeEstoqueLocal().intValue());
                        }
                        planejamento.setQuantidadeEstoqueGeral(modelo.getQuantidadeEstoqueGeral().intValue());
                        planejamentos.add(planejamento);
                }
               
                if (parametrosParaConsulta.getIndicadorConsultarTodosModelos()) {
                        List<Modelo> modelosAtivos = new ArrayList<Modelo>();
                        if (VerificadorUtil.estaNulo(parametrosParaConsulta.getModelo())) {
                                modelosAtivos = modeloService.consultarTodosAtivos();
                        } else {
                                modelosAtivos = modeloService.consultarPassandoEntidade(parametrosParaConsulta.getModelo(), 0, modeloService.obterQuantidadeDeRegistrosPassandoEntidade(parametrosParaConsulta.getModelo()));
                        }
                        for (Modelo modeloAtivo : modelosAtivos) {
                                if (modeloNaoEstaPresenteNaLista(modelos, modeloAtivo)) {
                                        RankingComprasTransferenciasDTO planejamento = new RankingComprasTransferenciasDTO();
                                        planejamento.setModelo(modeloAtivo);
                                        planejamento.setValorTotalVendido(new Double(0.0));
                                        planejamento.setValorTotalComprado(new Double(0.0));
                                        planejamento.setQuantidadeVendas(new Long(0));
                                        planejamento.setQuantidadeMinimaComprar(parametrosParaConsulta.getQuantidadeMinimaComprar());
                                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosParaConsulta.getSequencialLoja())) {
                                                planejamento.setQuantidadeEstoqueLocal(produtoLojaService.consultarEstoqueModeloEeLoja(modeloAtivo, parametrosParaConsulta.getSequencialLoja(), null, parametrosParaConsulta.getTipoProduto(), null, null));
                                        }
                                        planejamento.setQuantidadeEstoqueGeral(produtoLojaService.consultarEstoqueModeloEeLoja(modeloAtivo, null, null, parametrosParaConsulta.getTipoProduto(), null, null));
                                        if (planejamento.getQuantidadeEstoqueGeral() > 0) {
                                                planejamentos.add(planejamento);
                                        }
                                }
                        }
                }
               
                if (parametrosParaConsulta.getTipoOrdenacao().equals(TipoOrdenacaoPlanejamentoCompras.QUANTIDADE_COMPRAR.getValor())) {
                        return new ArrayList<RankingComprasTransferenciasDTO>(ordenador.ordenar(planejamentos));
                }
                return planejamentos;
        }
       
        private Boolean modeloNaoEstaPresenteNaLista(List<RankingModeloDTO> rankingModelos, Modelo modeloAtivo) {
                for (RankingModeloDTO rankingModelo : rankingModelos) {
                        if (rankingModelo.getModelo().getSequencial().equals(modeloAtivo.getSequencial())) {
                                return false;
                        }
                }
                return true;
        }
       
        @Override
        public List<RankingComprasTransferenciasEstiloDTO> consultarDetalhamentoPlanejamentoParaCompras(ParametrosConsultaParaComprasTransferenciasDTO parametrosParaConsulta, Modelo modelo) {
                List<RankingComprasTransferenciasEstiloDTO> estilos = new ArrayList<RankingComprasTransferenciasEstiloDTO>();
                for (TipoEstiloProduto estiloProduto : TipoEstiloProduto.values()) {
                        parametrosParaConsulta.setEstilo(StringUtil.setarUpperCase(estiloProduto.getValor()));
                        RankingComprasTransferenciasEstiloDTO estilo = vendaRepository.consultarEstoqueEeVendasPorEstilo(parametrosParaConsulta, modelo);
                        estilo.setRankingsPorLoja(vendaRepository.consultarEstoqueEeVendasEstiloPorLoja(parametrosParaConsulta, modelo));
                        estilo.setQuantidadeMinimaComprar(parametrosParaConsulta.getQuantidadeMinimaComprar());
                        estilos.add(estilo);
                }
                return estilos;
        }

        @Override
        public List<RankingVendedorDTO> consultarRankingPromocaoInterna(Date dataInicial, Date dataFinal) {
                List<RankingVendedorDTO> rankingVendedores = new ArrayList<RankingVendedorDTO>();
                List<Vendedor> vendedores = vendedorService.consultarVendedoresColaboradoresAtivos(null);
                for (Vendedor vendedor : vendedores) {
                        RankingVendedorDTO ranking = consultarRankingPromocaoInternaDoVendedor(vendedor, dataInicial, dataFinal);
                        if (ranking.getValorTotalVendido() > new Double(0.0)) {
                                rankingVendedores.add(ranking);
                        }
                }
                return (List<RankingVendedorDTO>) ordenador.ordenar(rankingVendedores);
        }
       
        @Override
        public RankingVendedorDTO consultarRankingPromocaoInternaDoVendedor(Vendedor vendedor, Date dataInicial, Date dataFinal) {
                ParametrosConsultaVendasDTO parametrosConsultaVendas = new ParametrosConsultaVendasDTO();
                parametrosConsultaVendas.setDataInicial(DataUtils.getDataComHorarioMinimo(dataInicial));
                parametrosConsultaVendas.setDataFinal(DataUtils.getDataComHorarioMaximo(dataFinal));
                parametrosConsultaVendas.setVendedor(vendedor);
                RankingVendedorDTO rankingVendedor = new RankingVendedorDTO();
                rankingVendedor.setVendedor(vendedor);
               
                rankingVendedor.setQuantidadePedidos(lancamentoService.obterQuantidadeVendasDosProdutosDaPromocaoInterna(parametrosConsultaVendas));
//              if (rankingVendedor.getQuantidadePedidos() >= ConstantesSEC.ProdutosPromocaoInterna.QUANTIDADE_MINIMA_RECEBIMENTO) {
                        rankingVendedor.setValorTotalVendido(lancamentoService.obterValorTotalVendidoDosProdutosDaPromocaoInterna(parametrosConsultaVendas) * ConstantesSEC.ProdutosPromocaoInterna.PERCENTUAL);
//              } else {
//                      rankingVendedor.setValorTotalVendido(new Double(0.0));
//              }
               
                ParametrosConsultaVendasDTO parametrosConsultaVendasDoDia = new ParametrosConsultaVendasDTO();
                parametrosConsultaVendasDoDia.setDataInicial(DataUtils.getDataComHorarioMinimo(DataUtils.getDataAtual()));
                parametrosConsultaVendasDoDia.setDataFinal(DataUtils.getDataComHorarioMaximo(DataUtils.getDataAtual()));
                parametrosConsultaVendasDoDia.setVendedor(vendedor);
                rankingVendedor.setValorTotalVendidoDoDia(lancamentoService.obterValorTotalVendidoDosProdutosDaPromocaoInterna(parametrosConsultaVendasDoDia));
                return rankingVendedor;
        }
       
        @Override
        public List<VendasDTO> consultarVendas(ParametrosConsultaVendasDTO parametrosConsultaVendasDTO) {
                return vendaRepository.consultarVendas(parametrosConsultaVendasDTO);
        }
*/     
        /*
        @Override
        public List<RankingVendedorDTO> consultarRankingVendedores(Date dataInicial, Date dataFinal) {
                List<RankingVendedorDTO> rankingVendedores = new ArrayList<RankingVendedorDTO>();
                List<Vendedor> vendedores = vendedorService.consultarVendedoresColaboradores();
                for (Vendedor vendedor : vendedores) {
                        ParametrosConsultaVendasDTO parametrosConsultaVendas = new ParametrosConsultaVendasDTO();
                        parametrosConsultaVendas.setDataInicial(DataUtils.getDataComHorarioMinimo(dataInicial));
                        parametrosConsultaVendas.setDataFinal(DataUtils.getDataComHorarioMaximo(dataFinal));
                        parametrosConsultaVendas.setVendedor(vendedor);
                        RankingVendedorDTO rankingVendedor = new RankingVendedorDTO();
                        rankingVendedor.setVendedor(vendedor);
                        rankingVendedor.setValorTotalVendido(obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsultaVendas));
                        rankingVendedor.setQuantidadePedidos(obterQuantidadePedidos(vendedor, dataInicial, dataFinal));
                        rankingVendedores.add(rankingVendedor);
                }
                return (List<RankingVendedorDTO>) ordenador.ordenar(rankingVendedores);
        }
        */
       
}