Subversion Repositories Integrator Subversion

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

import java.util.ArrayList;

import java.util.Date;

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.consulta.ParametrosConsultaModelosMaisVendidosDTO;

import br.com.ec.domain.dto.consulta.ParametrosConsultaPorPeriodoDTO;

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

                for (RankingModeloDTO rankingModelo : modelosMaisVendidos) {

                        RankingComprasTransferenciasDTO rankingComprasTransferenciasDTO = new RankingComprasTransferenciasDTO();

                        rankingComprasTransferenciasDTO.setRankingModelo(rankingModelo);

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

        }

        /*

        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 {