Subversion Repositories Integrator Subversion

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

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import br.com.ec.controller.util.UtilBean;
import br.com.ec.domain.dto.ParametrosConsultaProdutoDTO;
import br.com.ec.domain.dto.ProdutoHistoricoDTO;
import br.com.ec.domain.dto.ProdutoHistoricoDetalhesDTO;
import br.com.ec.domain.model.Cliente;
import br.com.ec.domain.model.Cupom;
import br.com.ec.domain.model.EstoqueAuditoria;
import br.com.ec.domain.model.Loja;
import br.com.ec.domain.model.Modelo;
import br.com.ec.domain.model.Pagamento;
import br.com.ec.domain.model.Pedido;
import br.com.ec.domain.model.PedidoHistorico;
import br.com.ec.domain.model.PedidoProduto;
import br.com.ec.domain.model.Pendencia;
import br.com.ec.domain.model.Perfil;
import br.com.ec.domain.model.Produto;
import br.com.ec.domain.model.ProdutoLoja;
import br.com.ec.domain.model.Usuario;
import br.com.ec.domain.model.tipos.TipoCupom;
import br.com.ec.domain.model.tipos.TipoDevolucao;
import br.com.ec.domain.model.tipos.TipoEstoqueAuditoria;
import br.com.ec.domain.model.tipos.TipoEstoqueAuditoriaVerificacao;
import br.com.ec.domain.model.tipos.TipoGenero;
import br.com.ec.domain.model.tipos.TipoProduto;
import br.com.ec.domain.model.tipos.TipoRelatorio;
import br.com.ec.domain.model.tipos.TipoSituacaoPedido;
import br.com.ec.domain.service.cupom.CupomService;
import br.com.ec.domain.service.email.impl.GerenciadorEmailImpl;
import br.com.ec.domain.service.estoqueauditoria.EstoqueAuditoriaService;
import br.com.ec.domain.service.pagamento.PagamentoService;
import br.com.ec.domain.service.pedido.PedidoService;
import br.com.ec.domain.service.pendencia.PendenciaService;
import br.com.ec.domain.service.perfil.PerfilService;
import br.com.ec.domain.service.produto.ProdutoService;
import br.com.ec.domain.service.produtodaloja.ProdutoLojaService;
import br.com.ec.domain.shared.ConstantesSEC;
import br.com.ec.infrastructure.repository.ProdutoRepository;
import br.com.ec.infrastructure.repository.TransferenciaRepository;
import br.edu.cesmac.core.exception.NegocioException;
import br.edu.cesmac.core.generic.AbstractService;
import br.edu.cesmac.core.generic.GenericRepository;
import br.edu.cesmac.core.util.DataUtils;
import br.edu.cesmac.core.util.StringUtil;
import br.edu.cesmac.core.util.VerificadorUtil;
import br.edu.cesmac.core.validador.Validador;

@Service
public class ProdutoServiceImpl extends AbstractService<Produto> implements ProdutoService {
       
        private ProdutoRepository produtoRepository;
        private TransferenciaRepository transferenciaRepository;
        private ProdutoLojaService produtoLojaService;
        private EstoqueAuditoriaService estoqueAuditoriaService;
        private PerfilService perfilService;
        private CupomService cupomService;
        private PagamentoService pagamentoService;
        private PedidoService pedidoService;
        private PendenciaService pendenciaService;

        @Autowired
        public ProdutoServiceImpl(Validador validador, ProdutoRepository produtoRepository,
                        TransferenciaRepository transferenciaRepository, ProdutoLojaService produtoLojaService,
                        EstoqueAuditoriaService estoqueAuditoriaService, PerfilService perfilService, CupomService cupomService,
                        PagamentoService pagamentoService, PedidoService pedidoService, PendenciaService pendenciaService) {
                super(validador);
                this.produtoRepository = produtoRepository;
                this.transferenciaRepository = transferenciaRepository;
                this.produtoLojaService = produtoLojaService;
                this.estoqueAuditoriaService = estoqueAuditoriaService;
                this.perfilService = perfilService;
                this.cupomService = cupomService;
                this.pagamentoService = pagamentoService;
                this.pedidoService = pedidoService;
                this.pendenciaService = pendenciaService;
        }

        @Override
        protected GenericRepository<Produto> getRepository() {
                return produtoRepository;
        }
       
        @Override
        public void cadastrar(Produto produto) {
                setarNovoCodigoDoProduto(produto);
                super.cadastrar(produto);
        }
       
        private void setarNovoCodigoDoProduto(Produto produto) {
                Long novoCodigo = consultarUltimoCodigo();
                if (VerificadorUtil.naoEstaNulo(novoCodigo)) {
                        novoCodigo = novoCodigo + 1;
                        produto.setCodigo(String.format("%06d", novoCodigo));
                } else {
                        produto.setCodigo(String.format("%06d", new Long(1)));
                }
        }
       
        @Override
        protected void regrasNegocioCadastrar(Produto produto) {
                verificarObrigatoriedades(produto);
                verificarSeCodigoRapidoJaExiste(produto);
                verificarSeCodigoEANJaExiste(produto);
                setarFalsoParaIndicadores(produto);
                produto.setAtivo(true);
        }

        @Override
        protected void regrasNegocioAlterar(Produto produto) {
                verificarObrigatoriedades(produto);
                verificarSeCodigoRapidoJaExiste(produto);
                verificarSeCodigoEANJaExiste(produto);
                setarFalsoParaIndicadores(produto);
        }
       
        private void verificarObrigatoriedades(Produto produto) {
                StringBuilder excecoes = new StringBuilder();
                if (VerificadorUtil.estaNuloOuVazio(produto.getCodigoEAN()) &&
                                VerificadorUtil.naoEstaNuloOuVazio(produto.getCodigoEANTributado())) {
                        excecoes.append("Código de Barras Tributado; ");
                }
                if (produto.getTipo().equals(TipoProduto.CAPA.getValor())) {
                        if (VerificadorUtil.estaNuloOuVazio(produto.getModelo())) {
                                excecoes.append("Modelo do produto; ");
                        }
                        if (VerificadorUtil.estaNuloOuVazio(produto.getEstilo())) {
                                excecoes.append("Estilo do produto; ");
                        }
                }
                if (produto.tipoProdutoTributado()) {
                        if (VerificadorUtil.estaNulo(produto.getTributacao())) {
                                excecoes.append("Tributação do produto; ");
                        }
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(excecoes)) {
                        throw new NegocioException("Obrigatório informar: " + excecoes.toString());
                }
        }
       
        private void verificarSeCodigoRapidoJaExiste(Produto produto) {
                if (VerificadorUtil.naoEstaNuloOuVazio(produto.getCodigoRapido())) {
                        Produto produtoConsultado = produtoRepository.consultarProdutoPorCodigoRapido(produto.getCodigoRapido());
                        if (VerificadorUtil.naoEstaNulo(produtoConsultado)) {
                                if (!produtoConsultado.getSequencial().equals(produto.getSequencial())) {
                                        throw new NegocioException("Código rápido do produto já existente");
                                }
                        }
                }
        }
       
        private void verificarSeCodigoEANJaExiste(Produto produto) {
                if (VerificadorUtil.naoEstaNuloOuVazio(produto.getCodigoEAN())) {
                        Produto produtoConsultado = produtoRepository.consultarProdutoPorCodigoEAN(produto.getCodigoEAN());
                        if (VerificadorUtil.naoEstaNulo(produtoConsultado)) {
                                if (!produtoConsultado.getSequencial().equals(produto.getSequencial())) {
                                        throw new NegocioException("Código de Barras já existente.");
                                }
                        }
                }
        }
       
        private void setarFalsoParaIndicadores(Produto produto) {
                if (VerificadorUtil.estaNulo(produto.getIndicadorFavorito())) {
                        produto.setIndicadorFavorito(false);
                }
        }
       
        @Override
        public List<Produto> consultarProdutoPorParametros(ParametrosConsultaProdutoDTO parametrosConsultaProduto) {
                return produtoRepository.consultarProdutoPorParametros(parametrosConsultaProduto);
        }
       
        @Override
        public List<Produto> consultarCompativeis(Produto produto) {
                return produtoRepository.consultarCompativeis(produto);
        }

        @Override
        public Produto detalharProduto(Produto produto) {
                Produto produtoDetalhado = produtoRepository.detalharProduto(produto);
                produtoDetalhado.setTransferenciasAbertas(transferenciaRepository.consultarTransferenciasAbertas(produtoDetalhado));
                produtoDetalhado.setPedidosPendentes(pedidoService.consultarPedidosNaoAtendidos(produtoDetalhado));
                return produtoDetalhado;
        }
       
        @Override
        public Produto consultarProdutoPorCodigoOuCodigoEAN(String codigoProduto) {
                Produto produtoSelecionado = null;
                if (VerificadorUtil.naoEstaNuloOuVazio(codigoProduto)) {
                        codigoProduto = codigoProduto.trim();
                        if (codigoProduto.length() < 7) {
                                produtoSelecionado = this.consultarProdutoPorCodigo(UtilBean.padraoCodigoProduto(codigoProduto));
                        } else {
                                produtoSelecionado = this.consultarProdutoPorCodigoEAN(codigoProduto);
                        }
                }
                if (VerificadorUtil.estaNulo(produtoSelecionado)) {
                        return this.consultarProdutoPorCodigo("000000");
                }
                return produtoSelecionado;
        }
       
        @Override
        public Produto consultarProdutoPorCodigoRapidoOuCodigoEAN(String codigoRapidoOuCodigoEAN) {
                Produto produtoSelecionado = null;
                if (VerificadorUtil.naoEstaNuloOuVazio(codigoRapidoOuCodigoEAN)) {
                        codigoRapidoOuCodigoEAN = codigoRapidoOuCodigoEAN.trim();
                        if (codigoRapidoOuCodigoEAN.length() < 7) {
                                produtoSelecionado = this.consultarProdutoPorCodigoRapido(codigoRapidoOuCodigoEAN);
                        } else {
                                produtoSelecionado = this.consultarProdutoPorCodigoEAN(codigoRapidoOuCodigoEAN);
                        }
                }
                if (VerificadorUtil.estaNulo(produtoSelecionado)) {
                        return this.consultarProdutoPorCodigo("000000");
                }
                return produtoSelecionado;
        }
       
        @Override
        public Produto consultarProdutoPorCodigo(String codigoProduto) {
                return produtoRepository.consultarProdutoPorCodigo(codigoProduto.trim());
        }
       
        @Override
        public Produto consultarProdutoPorCodigoEAN(String codigoEAN) {
                codigoEAN = StringUtil.retornarApenasNumeros(codigoEAN);
                if (VerificadorUtil.naoEstaNuloOuVazio(codigoEAN)) {
                        return produtoRepository.consultarProdutoPorCodigoEAN(codigoEAN.trim());
                }
                return null;
        }
       
        @Override
        public Produto consultarProdutoPorCodigoRapido(String codigoRapido) {
                return produtoRepository.consultarProdutoPorCodigoRapido(codigoRapido.trim());
        }
       
        @Override
        public Long consultarUltimoCodigo() {
                return produtoRepository.consultarUltimoCodigo();
        }

        @Override
        public Produto consultarProdutoPorCodigoParaContagem(String codigoProduto, Loja loja, Usuario usuarioParaContagem) {
                Produto produto = this.consultarProdutoPorCodigoOuCodigoEAN(codigoProduto);
                verificarSeProdutoConstaNaContagem(produto, loja, usuarioParaContagem);
                return produto;
        }
       
        private void verificarSeProdutoConstaNaContagem(Produto produto, Loja loja, Usuario usuarioParaContagem) {
                ParametrosConsultaProdutoDTO parametrosConsulta = new ParametrosConsultaProdutoDTO();
                ((ParametrosConsultaProdutoDTO)parametrosConsulta).setProduto(produto);
                ((ParametrosConsultaProdutoDTO)parametrosConsulta).setLojaSelecionadaParaContagem(loja);
                ((ParametrosConsultaProdutoDTO)parametrosConsulta).setConsultarAtivo(1);
                ((ParametrosConsultaProdutoDTO)parametrosConsulta).setUsuarioParaContagem(usuarioParaContagem);
                if (this.obterQuantidadeDeRegistrosParametrosConsulta(parametrosConsulta) == 0) {
                        throw new NegocioException("PRODUTO NÃO CONSTA PARA CONTAGEM NA LOJA");
                }
        }

        @Override
        public void lancarAvaria(EstoqueAuditoria estoqueAuditoria, Loja loja, Produto produto, Usuario usuario) {
                lancarMudancaEstoque(estoqueAuditoria, loja, produto, usuario, TipoEstoqueAuditoria.AVARIA.getValor());
        }
       
        @Override
        public void lancarTroca(EstoqueAuditoria estoqueAuditoria, Loja loja, Produto produto, Usuario usuario) {
                if (estoqueAuditoria.getEhDevolucaoMesmoProduto()) {
                        estoqueAuditoria.setSequencial(lancarMudancaEstoque(estoqueAuditoria, loja, produto, usuario, TipoEstoqueAuditoria.TROCA.getValor()).getSequencial());
                } else {
                        estoqueAuditoria.setSequencial(lancarDevolucao(estoqueAuditoria, loja, produto, usuario, TipoEstoqueAuditoria.DEVOLUCAO.getValor()).getSequencial());
                }
                vincularPedidoComTroca(estoqueAuditoria);
        }
       
        private void vincularPedidoComTroca(EstoqueAuditoria estoqueAuditoria) {
                if (VerificadorUtil.naoEstaNulo(estoqueAuditoria.getPedidoParaVincular())) {
                        PedidoHistorico pedidoHistorico = new PedidoHistorico();
                        pedidoHistorico.setDataHistorico(DataUtils.getDataAtual());
                        pedidoHistorico.setObservacao("TROCA REALIZADA: " + estoqueAuditoria.getSequencial());
                        pedidoHistorico.setTipoSituacao(TipoSituacaoPedido.FINALIZADO.getValor());
                        pedidoHistorico.setUsuario(estoqueAuditoria.getUsuario());
                        pedidoHistorico.setPedido(estoqueAuditoria.getPedidoParaVincular());
                        if (VerificadorUtil.estaNulo(estoqueAuditoria.getPedidoParaVincular().getHistorico())) {
                                estoqueAuditoria.getPedidoParaVincular().setHistorico(new ArrayList<PedidoHistorico>());
                        }
                        estoqueAuditoria.getPedidoParaVincular().getHistorico().add(pedidoHistorico);
                        estoqueAuditoria.getPedidoParaVincular().setTipoSituacao(TipoSituacaoPedido.FINALIZADO.getValor());
                        estoqueAuditoria.getPedidoParaVincular().setDataUltimaAlteracaoSituacao(DataUtils.getDataAtual());
                        pedidoService.alterar(estoqueAuditoria.getPedidoParaVincular());
                }
        }

        private EstoqueAuditoria lancarMudancaEstoque(EstoqueAuditoria estoqueAuditoria, Loja loja, Produto produto, Usuario usuario, String tipoEstoqueAuditoria) {
                ProdutoLoja produtoLoja = produtoLojaService.consultarProdutoLoja(produto, loja);
                if (VerificadorUtil.naoEstaNulo(produtoLoja)) {
                        if (VerificadorUtil.estaNulo(produtoLoja.getQuantidadeEstoque())) {
                                produtoLoja.setQuantidadeEstoque(0);
                        }
                        String observacao = estoqueAuditoria.getObservacao();
                        if (VerificadorUtil.naoEstaNuloOuVazio(estoqueAuditoria.getNumeroLote())) {
                                observacao = "LOTE [" + estoqueAuditoria.getNumeroLote() + "] : " + observacao;
                        }
                        estoqueAuditoria = cadastrarAuditoria(usuario, produtoLoja, tipoEstoqueAuditoria, produtoLoja.getQuantidadeEstoque(), produtoLoja.getQuantidadeEstoque() - 1, estoqueAuditoria.getCliente(), observacao, TipoEstoqueAuditoriaVerificacao.NAO_VERIFICADO.getValor());
                        produtoLoja.setQuantidadeEstoque(produtoLoja.getQuantidadeEstoque() - 1);
                        produtoLojaService.alterar(produtoLoja);
                }
                return estoqueAuditoria;
        }
       
        private EstoqueAuditoria lancarDevolucao(EstoqueAuditoria estoqueAuditoria, Loja loja, Produto produto, Usuario usuario, String tipoEstoqueAuditoria) {
                verificarDadosPreenchidos(estoqueAuditoria);
               
                ProdutoLoja produtoLoja = produtoLojaService.consultarProdutoLoja(produto, loja);
                if (VerificadorUtil.naoEstaNulo(produtoLoja)) {
                        if (VerificadorUtil.estaNulo(produtoLoja.getQuantidadeEstoque())) {
                                produtoLoja.setQuantidadeEstoque(0);
                        }
                        Cupom cupomGerado = null;
                        if (estoqueAuditoria.getTipoDevolucao().equals(TipoDevolucao.CUPOM.getValor())) {
                                cupomGerado = new Cupom();
                                cupomGerado.setCodigo(cupomService.gerarCodigoValido());
                                cupomGerado.setDataHoraEmissao(DataUtils.getDataAtual());
                                cupomGerado.setPublico(false);
                                cupomGerado.setAtivo(true);
                                cupomGerado.setTipoCupom(TipoCupom.REEMBOLSO.getValor());
                                cupomGerado.setCliente(estoqueAuditoria.getCliente());
                                cupomGerado.setValor(estoqueAuditoria.getValorDevolvido());
                                cupomGerado.setLimiteUtilizacao(true);
                                cupomGerado.setObservacao("CUPOM: " + cupomGerado.getCodigo() + "\nREEMBOLSO DO PRODUTO: " + estoqueAuditoria.getProduto().getDescricaoCompletaCapa());
                                cupomService.cadastrar(cupomGerado);
                                estoqueAuditoria.setObservacao("CUPOM GERADO: " + cupomGerado.getCodigo() + "\n" + estoqueAuditoria.getObservacao());
                        }
                        Pagamento pagamentoGerado = null;
                        if (estoqueAuditoria.getTipoDevolucao().equals(TipoDevolucao.DINHEIRO.getValor())) {
                                pagamentoGerado = new Pagamento();
                                pagamentoGerado.setLoja(loja);
                                pagamentoGerado.setData(DataUtils.getDataAtual());
                                pagamentoGerado.setDescricao("DEVOLUÇÃO DO PRODUTO: " + estoqueAuditoria.getProduto().getCodigoProdutoPadrao());
                                pagamentoGerado.setValor(estoqueAuditoria.getValorDevolvido());
                                pagamentoGerado.setUsuario(usuario);
                                pagamentoGerado.setLancado(false);
                                pagamentoService.cadastrar(pagamentoGerado);
                                estoqueAuditoria.setObservacao("DEVOLUÇÃO EM DINHEIRO: " + estoqueAuditoria.getValorDevolvido() + "\n" + estoqueAuditoria.getObservacao());
                        }
                        if (estoqueAuditoria.getTipoDevolucao().equals(TipoDevolucao.ESTORNO_CARTAO.getValor()) ||
                                        estoqueAuditoria.getTipoDevolucao().equals(TipoDevolucao.TRANSFERENCIA.getValor())) {
                                String diaAtual = DataUtils.converterDataComHorarioParaString(DataUtils.getDataAtual());
                                StringBuilder conteudo = new StringBuilder();
                                conteudo.append("OPERAÇÃO REALIZADA POR: " + usuario.getNome() + "\n");
                                conteudo.append("VALOR PARA DEVOLVER: R$" + StringUtil.formatarValor(estoqueAuditoria.getValorDevolvido()) + "\n");
                                if (estoqueAuditoria.getTipoDevolucao().equals(TipoDevolucao.TRANSFERENCIA.getValor())) {
                                        conteudo.append("DADOS BANCÁRIOS: " + estoqueAuditoria.getDadosBancarios() + "\n");
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(estoqueAuditoria.getSequencialVenda())) {
                                        conteudo.append("ID DA VENDA: " + estoqueAuditoria.getSequencialVenda() + "\n");
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(estoqueAuditoria.getNumeroNotaFiscal())) {
                                        conteudo.append("Nº DA NOTA FISCAL: " + estoqueAuditoria.getNumeroNotaFiscal() + "\n");
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(estoqueAuditoria.getDataVenda())) {
                                        conteudo.append("DATA DA VENDA: " + DataUtils.converterDataComHorarioParaString(estoqueAuditoria.getDataVenda()) + "\n");
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(estoqueAuditoria.getDescricaoDaLoja())) {
                                        conteudo.append("LOJA: " + estoqueAuditoria.getDescricaoDaLoja() + "\n");
                                }
                                conteudo.append("OBSERVAÇÕES: " + estoqueAuditoria.getObservacao() + "\n\n");
                                if (VerificadorUtil.naoEstaNulo(estoqueAuditoria.getCliente())) {
                                        conteudo.append("DADOS DO CLIENTE:\n");
                                        conteudo.append("NOME: " + estoqueAuditoria.getCliente().getNome() + "\n");
                                        conteudo.append("CPF/CNPJ: " + estoqueAuditoria.getCliente().getCpfCnpjFormatado() + "\n");
                                        conteudo.append("EMAIL: " + estoqueAuditoria.getCliente().getEmail() + "\n");
                                        conteudo.append("TELEFONE: " + estoqueAuditoria.getCliente().getTelefone() + "\n");
                                        conteudo.append("CONTATO: " + estoqueAuditoria.getCliente().getContato() + "\n\n");
                                }
                                conteudo.append("DATA DA SOLICITAÇÃO: " + diaAtual + "\n");
                                conteudo.append("__________________________________________________\n\n");
                               
                                if (estoqueAuditoria.getTipoDevolucao().equals(TipoDevolucao.ESTORNO_CARTAO.getValor())) {
                                        new GerenciadorEmailImpl()
                                                .comEmailsDestino(ConstantesSEC.DESTINATARIOS_EMAIL_DIRECAO)
                                                .comAssunto("ESPAÇO CASE - SOLICITAÇÃO DE ESTORNO : " + diaAtual)
                                                .comConteudo(conteudo.toString())
                                                .enviar();
                                }
                                if (estoqueAuditoria.getTipoDevolucao().equals(TipoDevolucao.TRANSFERENCIA.getValor())) {
                                        new GerenciadorEmailImpl()
                                                .comEmailsDestino(ConstantesSEC.DESTINATARIOS_EMAIL_DIRECAO)
                                                .comAssunto("ESPAÇO CASE - SOLICITAÇÃO DE TRANSFERÊNCIA : " + diaAtual)
                                                .comConteudo(conteudo.toString())
                                                .enviar();
                                }
                                try {
                                        Pendencia pendencia = new Pendencia();
                                        pendencia.setDescricao("SOLICITAÇÃO DE " + TipoDevolucao.parse(estoqueAuditoria.getTipoDevolucao()).getDescricao() + ": " + diaAtual);
                                        pendencia.setUsuario(usuario);
                                        pendencia.setData(DataUtils.getDataAtual());
                                        pendencia.setLoja(loja);
                                        Perfil perfilRh = new Perfil();
                                        perfilRh.setCodigo(ConstantesSEC.SETOR_FINANCEIRO_2);
                                        pendencia.setPerfil(perfilRh);
                                        pendenciaService.cadastrar(pendencia);
                                } catch (Exception e) {}
                        }
                       
                        estoqueAuditoria = cadastrarAuditoria(usuario, produtoLoja, tipoEstoqueAuditoria, produtoLoja.getQuantidadeEstoque(), produtoLoja.getQuantidadeEstoque(), estoqueAuditoria.getCliente(), estoqueAuditoria.getObservacao(), TipoEstoqueAuditoriaVerificacao.NAO_VERIFICADO.getValor());
                        if (VerificadorUtil.naoEstaNulo(cupomGerado)) {
                                cupomGerado.setObservacao("AUDITORIA: " + estoqueAuditoria.getSequencial() + "\n" + cupomGerado.getObservacao());
                                cupomService.alterar(cupomGerado);
                        }
                        if (VerificadorUtil.naoEstaNulo(pagamentoGerado)) {
                                pagamentoGerado.setDescricao("AUDITORIA: " + estoqueAuditoria.getSequencial() + "\n" + pagamentoGerado.getDescricao());
                                pagamentoService.alterar(pagamentoGerado);
                        }
                }
                return estoqueAuditoria;
        }
       
        private void verificarDadosPreenchidos(EstoqueAuditoria estoqueAuditoria) {
                if (VerificadorUtil.estaNuloOuVazio(estoqueAuditoria.getObservacao())) {
                        throw new NegocioException("Informe os motivos da devolução (OBSERVAÇÔES)");
                }
               
                if (VerificadorUtil.estaNuloOuVazio(estoqueAuditoria.getValorDevolvido()) ||
                                (estoqueAuditoria.getValorDevolvido() <= 0.0)) {
                        throw new NegocioException("Informe o valor devolvido");
                }
                if (estoqueAuditoria.getTipoDevolucao().equals(TipoDevolucao.TRANSFERENCIA.getValor()) ||
                                estoqueAuditoria.getTipoDevolucao().equals(TipoDevolucao.ESTORNO_CARTAO.getValor())) {
                        if (VerificadorUtil.estaNuloOuVazio(estoqueAuditoria.getCliente())) {
                                throw new NegocioException("Informe o cliente com o contato e/ou email");
                        }
                        if (VerificadorUtil.estaNuloOuVazio(estoqueAuditoria.getCliente().getContato()) &&
                                        VerificadorUtil.estaNuloOuVazio(estoqueAuditoria.getCliente().getEmail())) {
                                throw new NegocioException("Informe o contato ou email do cliente");
                        }
                        if (estoqueAuditoria.getTipoDevolucao().equals(TipoDevolucao.TRANSFERENCIA.getValor())) {
                                if (VerificadorUtil.estaNuloOuVazio(estoqueAuditoria.getDadosBancarios())) {
                                        throw new NegocioException("Informe os dados bancários do cliente");
                                }
                        }
                }
        }

        private EstoqueAuditoria cadastrarAuditoria(Usuario usuario, ProdutoLoja produtoLoja, String tipoEstoqueAuditoria, Integer quantidadeEstoqueAnterior, Integer quantidadeEstoqueNovo, Cliente cliente, String observacao, String tipoVerificacao) {
                return estoqueAuditoriaService.cadastrarAuditoria(usuario, produtoLoja, quantidadeEstoqueAnterior, quantidadeEstoqueNovo, DataUtils.getDataAtual(), tipoEstoqueAuditoria, cliente, observacao, tipoVerificacao);
        }
       
        @Override
        public void desativarProduto(Produto produto) {
                produto.setAtivo(false);
                this.alterar(produto);
        }
       
        @Override
        public void ativarProduto(Produto produto) {
                produto.setAtivo(true);
                this.alterar(produto);
        }
       
        @Override
        public void realizarContagem(ProdutoLoja produtoLoja, Integer quantidadeEstoque, String localizacao, Usuario usuario, Boolean indicadorAvaria) {
                if (VerificadorUtil.estaNulo(quantidadeEstoque)) {
                        throw new NegocioException("É preciso informar o estoque");
                }
                verificarSeUsuarioLogadoEhVendedorOuSuperior(usuario);
                produtoLoja.setLocalizacao(localizacao);
                if (VerificadorUtil.naoEstaNulo(produtoLoja.getDataContagemPreparacao())) {
                        if (diferencaMaiorEmDias(ConstantesSEC.StatusContagem.CONTAGEM_AMARELO_30_DIAS, produtoLoja.getDataContagemPreparacao(), DataUtils.getDataAtual())) {
                                produtoLoja.setDataContagemPreparacao(null);
                        }
                }
                if (VerificadorUtil.estaNulo(produtoLoja.getDataContagemPreparacao())) {
                        produtoLoja.setDataContagemPreparacao(DataUtils.getDataAtual());
                        produtoLoja.setQuantidadeEstoqueContagem(quantidadeEstoque);
                        produtoLoja.setUsuarioUltimaContagemPreparacao(usuario);
                        produtoLojaService.alterar(produtoLoja);
                } else if (VerificadorUtil.estaNulo(produtoLoja.getDataContagem()) ||
                                        produtoLoja.getDataContagem().before(produtoLoja.getDataContagemPreparacao()) ||
                                        produtoLoja.getIndicadorContagemSolicitada() ||
                                        produtoLoja.getUsuarioUltimaContagem().equals(produtoLoja.getUsuarioUltimaContagemPreparacao())) {
                        verificarSeUsuarioDePreparacaoDiferente(produtoLoja, usuario);
                        verificarSeProdutoPossuiTransferenciasAbertas(produtoLoja);
                        Integer quantidadeEstoqueAnterior = produtoLoja.getQuantidadeEstoque();
                        Integer quantidadeEstoqueNovo = quantidadeEstoque;
                       
                        if (temDivergenciaContagem(produtoLoja, quantidadeEstoqueNovo)) {
                                solicitarContagemCasoDivergentes(produtoLoja, quantidadeEstoqueNovo, usuario);
                        } else {
                                produtoLoja.setDataContagem(DataUtils.getDataAtual());
                                produtoLoja.setUsuarioUltimaContagem(usuario);
                                produtoLoja.setQuantidadeEstoque(quantidadeEstoqueNovo);
                                produtoLoja.setIndicadorContagemSolicitada(false);
                                produtoLojaService.alterar(produtoLoja);
                                if (quantidadeEstoqueAnterior != quantidadeEstoqueNovo) {
                                        cadastrarAuditoria(usuario, produtoLoja, TipoEstoqueAuditoria.CONTAGEM.getValor(), quantidadeEstoqueAnterior, quantidadeEstoqueNovo, null, "", TipoEstoqueAuditoriaVerificacao.NAO_VERIFICADO.getValor());
                                }
                                if (quantidadeEstoqueNovo > 0) {
                                        solicitarEntrarEmContatoCasoExistaPedidoParaLojaSolicitante(produtoLoja.getLoja(), usuario, produtoLoja.getProduto());
                                }
                        }
                } else {
                        throw new NegocioException("Contagem indisponível, informe à gestão");
                }
        }
       
        private Boolean diferencaMaiorEmDias(Integer quantidadeDias, Date dataAnterior, Date dataPosterior) {
                Date dataComDias = DataUtils.acrescentarDias(dataAnterior, quantidadeDias);
                return dataComDias.before(dataPosterior);
        }

        private boolean temDivergenciaContagem(ProdutoLoja produtoLoja, Integer quantidadeEstoqueNovo) {
                ProdutoHistoricoDTO produtoHistorico = new ProdutoHistoricoDTO();
                produtoHistorico.setProduto(produtoLoja.getProduto());
                Integer quantidadeEntradas = 0;
                List<ProdutoHistoricoDTO> entradas = produtoRepository.consultarHistoricoDeEntradas(produtoLoja.getProduto(), produtoLoja.getLoja(),
                                produtoLoja.getDataContagemPreparacao(), DataUtils.getDataAtual());
                for (ProdutoHistoricoDTO entrada : entradas) {
                        quantidadeEntradas = quantidadeEntradas + entrada.getQuantidadeLancamentos().intValue();
                }
                Integer quantidadeSaidas = 0;
                List<ProdutoHistoricoDTO> saidas = produtoRepository.consultarHistoricoDeSaidas(produtoLoja.getProduto(), produtoLoja.getLoja(),
                                produtoLoja.getDataContagemPreparacao(), DataUtils.getDataAtual());
                for (ProdutoHistoricoDTO saida : saidas) {
                        quantidadeSaidas = quantidadeSaidas + saida.getQuantidadeLancamentos().intValue();
                }
                if (VerificadorUtil.estaNulo(produtoLoja.getQuantidadeEstoqueContagem())) {
                        produtoLoja.setQuantidadeEstoqueContagem(produtoLoja.getQuantidadeEstoque());
                }
                return !(produtoLoja.getQuantidadeEstoqueContagem() + quantidadeEntradas - quantidadeSaidas == quantidadeEstoqueNovo);
        }

        private void verificarSeUsuarioDePreparacaoDiferente(ProdutoLoja produtoLoja, Usuario usuario) {
                if (produtoLoja.getUsuarioUltimaContagemPreparacao().equals(usuario)) {
                        throw new NegocioException("Usuário já realizou a preparação da contagem");
                }
        }

        @Override
        public void realizarContagemDireta(ProdutoLoja produtoLoja, Integer quantidadeEstoque, String localizacao, Usuario usuario, Boolean indicadorAvaria) {
                if (VerificadorUtil.estaNulo(quantidadeEstoque)) {
                        throw new NegocioException("É preciso informar o estoque");
                }
                verificarSeUsuarioLogadoEhVendedorOuSuperior(usuario);
                verificarSeProdutoPossuiTransferenciasAbertas(produtoLoja);
                Integer quantidadeEstoqueAnterior = produtoLoja.getQuantidadeEstoque();
                Integer quantidadeEstoqueNovo = quantidadeEstoque;
                produtoLoja.setLocalizacao(localizacao);
                produtoLoja.setDataContagemPreparacao(DataUtils.getDataAtual());
                produtoLoja.setDataContagem(DataUtils.getDataAtual());
                produtoLoja.setUsuarioUltimaContagem(usuario);
                produtoLoja.setUsuarioUltimaContagemPreparacao(usuario);
                produtoLoja.setQuantidadeEstoqueContagem(quantidadeEstoqueNovo);
                produtoLoja.setQuantidadeEstoque(quantidadeEstoqueNovo);
                produtoLoja.setIndicadorContagemSolicitada(false);
                produtoLojaService.alterar(produtoLoja);
                if (quantidadeEstoqueAnterior != quantidadeEstoqueNovo) {
                        cadastrarAuditoria(usuario, produtoLoja, TipoEstoqueAuditoria.CONTAGEM.getValor(), quantidadeEstoqueAnterior, quantidadeEstoqueNovo, null, "", TipoEstoqueAuditoriaVerificacao.VERIFICADO_SEM_PENDENCIA.getValor());
                }
                if (quantidadeEstoqueNovo > 0) {
                        solicitarEntrarEmContatoCasoExistaPedidoParaLojaSolicitante(produtoLoja.getLoja(), usuario, produtoLoja.getProduto());
                }
        }
       
        private void solicitarContagemCasoDivergentes(ProdutoLoja produtoLoja, Integer quantidadeEstoqueNovo, Usuario usuarioContagem) {
                produtoLoja.setDataContagemPreparacao(DataUtils.getDataAtual());
                produtoLoja.setQuantidadeEstoqueContagem(quantidadeEstoqueNovo);
                produtoLoja.setUsuarioUltimaContagemPreparacao(usuarioContagem);
                produtoLojaService.alterar(produtoLoja);
        }

        private void verificarSeProdutoPossuiTransferenciasAbertas(ProdutoLoja produtoLoja) {
                if (transferenciaRepository.verificarSeProdutoPossuiTransferenciasAbertas(produtoLoja)) {
                        throw new NegocioException("Não é permitido contar produto em transferência");
                }
        }
       
        private void verificarSeUsuarioLogadoEhVendedorOuSuperior(Usuario usuario) {
                if (!perfilService.temPerfilVendedor(usuario) &&
                        !perfilService.temPerfilGerenteDeLojistica(usuario) &&
                        !perfilService.temPerfilGerenteDeCompras(usuario) &&
                        !perfilService.temPerfilRecursosHumanos(usuario)) {
                        throw new NegocioException("Sem permissão para esta operação");
                }
        }
       
        @Override
        public void realizarContagem(Produto produto, Loja loja) {
                ProdutoLoja produtoLoja = new ProdutoLoja();
                produtoLoja.setProduto(produto);
                produtoLoja.setLoja(loja);
                produtoLoja.setDataContagem(DataUtils.getDataAtual());
                produtoLoja.setIndicadorContagemSolicitada(false);
                produtoLojaService.alterar(produtoLoja);
        }
       
        @Override
        public void transferirEstoque(Loja lojaEntrada, Loja lojaSaida, Usuario usuario, Produto produto, Integer quantidadeEstoque) {
                verificarParametrosParaTransferencia(lojaEntrada, lojaSaida, produto, quantidadeEstoque);
               
                Integer quantidadeEstoqueAnteriorEntrada = produtoLojaService.consultarEstoqueProdutoEeLoja(produto, lojaEntrada);
                Integer quantidadeEstoqueAnteriorSaida = produtoLojaService.consultarEstoqueProdutoEeLoja(produto, lojaSaida);
               
                produtoLojaService.alterarEstoqueAcrescentandoQuantidadeInformada(quantidadeEstoque, produto, lojaEntrada);
                produtoLojaService.alterarEstoqueAcrescentandoQuantidadeInformada(-quantidadeEstoque, produto, lojaSaida);
               
                cadastrarAuditoria(usuario, new ProdutoLoja(produto, lojaEntrada), TipoEstoqueAuditoria.TRANSFERENCIA.getValor(),
                                quantidadeEstoqueAnteriorEntrada, quantidadeEstoqueAnteriorEntrada + quantidadeEstoque, null, "", TipoEstoqueAuditoriaVerificacao.VERIFICADO_SEM_PENDENCIA.getValor());
               
                cadastrarAuditoria(usuario, new ProdutoLoja(produto, lojaSaida), TipoEstoqueAuditoria.TRANSFERENCIA.getValor(),
                                quantidadeEstoqueAnteriorSaida, quantidadeEstoqueAnteriorSaida - quantidadeEstoque, null, "", TipoEstoqueAuditoriaVerificacao.VERIFICADO_SEM_PENDENCIA.getValor());
               
                realizarContagemComZeroEstoqueNaLojaEntrada(lojaEntrada, usuario, produto, quantidadeEstoqueAnteriorEntrada, quantidadeEstoque);
                solicitarEntrarEmContatoCasoExistaPedidoParaLojaSolicitante(lojaEntrada, usuario, produto);
        }

        private void realizarContagemComZeroEstoqueNaLojaEntrada(Loja lojaEntrada, Usuario usuario, Produto produto, Integer quantidadeEstoqueAnteriorEntrada, Integer quantidadeEstoque) {
                if (quantidadeEstoqueAnteriorEntrada == 0) {
                        ProdutoLoja produtoLoja = produtoLojaService.consultarProdutoLoja(produto, lojaEntrada);
                        produtoLoja.setQuantidadeEstoqueContagem(quantidadeEstoque);
                        produtoLoja.setDataContagem(DataUtils.getDataAtual());
                        produtoLoja.setDataContagemPreparacao(DataUtils.getDataAtual());
                        produtoLoja.setUsuarioUltimaContagem(usuario);
                        produtoLoja.setUsuarioUltimaContagemPreparacao(usuario);
                        produtoLoja.setIndicadorContagemSolicitada(false);
                        produtoLojaService.alterar(produtoLoja);
                }
        }
       
        private void solicitarEntrarEmContatoCasoExistaPedidoParaLojaSolicitante(Loja lojaEntrada, Usuario usuario, Produto produto) {
                pedidoService.solicitarEntrarEmContatoCasoExistaPedidoParaLojaSolicitante(lojaEntrada, produto);
        }
       
        private void verificarParametrosParaTransferencia(Loja lojaEntrada, Loja lojaSaida, Produto produto, Integer quantidade) {
                if (VerificadorUtil.estaNulo(lojaEntrada) || VerificadorUtil.estaNulo(lojaSaida) || VerificadorUtil.estaNulo(produto)) {
                        throw new NegocioException("Obrigatório informar as lojas para transferência");
                } else {
                        if (lojaEntrada.getSequencial().equals(lojaSaida.getSequencial())) {
                                throw new NegocioException("Não é permitido transferir para uma mesma loja.");
                        }
                        if (quantidade == 0) {
                                throw new NegocioException("Obrigatório informar a quantidade.");
                        }
                }
        }
       
        @Override
        public Integer quantidadeTotalEstoque(Loja loja) {
                return produtoRepository.quantidadeTotalEstoque(loja);
        }
       
        @Override
        public Double valorTotalEstoque(Loja loja, Modelo modelo) {
                return produtoRepository.valorTotalEstoque(loja, modelo);
        }
       
        @Override
        public Integer quantidadeEstoque(ParametrosConsultaProdutoDTO parametrosConsulta) {
                return produtoRepository.quantidadeEstoque(parametrosConsulta);
        }
       
        @Override
        public Integer quantidadeEstoque(ParametrosConsultaProdutoDTO parametrosConsulta, Long sequencialLoja) {
                return produtoRepository.quantidadeEstoque(parametrosConsulta, sequencialLoja);
        }
       
        @Override
        public Integer quantidadeParaContagem(Loja loja) {
                ParametrosConsultaProdutoDTO parametrosConsulta = new ParametrosConsultaProdutoDTO();
                ((ParametrosConsultaProdutoDTO)parametrosConsulta).setLojaSelecionadaParaContagem(loja);
                ((ParametrosConsultaProdutoDTO)parametrosConsulta).setConsultarAtivo(1);
                return this.obterQuantidadeDeRegistrosParametrosConsulta(parametrosConsulta);
        }
       
        @Override
        public Integer solicitarContagem(ParametrosConsultaProdutoDTO parametrosConsulta) {
                List<Produto> produtos = produtoRepository.consultarPassandoParametrosConsulta(parametrosConsulta, 0, produtoRepository.obterQuantidadeDeRegistrosParametrosConsulta(parametrosConsulta), null, null, new HashMap<String, Object>());
                for (Produto produto : produtos) {
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLojaSelecionadaParaContagem())) {
                                produtoLojaService.solicitarContagem(produto, parametrosConsulta.getLojaSelecionadaParaContagem(), true);
                        } else {
                                produtoLojaService.solicitarContagem(produto, null, true);
                        }
                }
                return produtos.size();
        }
       
        @Override
        public void cancelarContagem(ParametrosConsultaProdutoDTO parametrosConsulta) {
                List<Produto> produtos = produtoRepository.consultarPassandoParametrosConsulta(parametrosConsulta, 0, produtoRepository.obterQuantidadeDeRegistrosParametrosConsulta(parametrosConsulta), null, null, new HashMap<String, Object>());
                for (Produto produto : produtos) {
                        produtoLojaService.cancelarContagem(produto, parametrosConsulta.getLojaSelecionadaParaContagem());
                }
        }
       
        @Override
        public void zerarEstoque(ParametrosConsultaProdutoDTO parametrosConsulta, Usuario usuario) {
                List<Produto> produtos = produtoRepository.consultarPassandoParametrosConsulta(parametrosConsulta, 0, produtoRepository.obterQuantidadeDeRegistrosParametrosConsulta(parametrosConsulta), null, null, new HashMap<String, Object>());
                for (Produto produto : produtos) {
                        List<ProdutoLoja> lista = produtoLojaService.consultar(new ProdutoLoja(produto, parametrosConsulta.getLojaSelecionadaParaContagem()), 0, produtoLojaService.obterQuantidadeDeRegistrosPassandoEntidade(new ProdutoLoja(produto, parametrosConsulta.getLojaSelecionadaParaContagem())));
                        for (ProdutoLoja produtoLoja : lista) {
                                produtoLoja.setIndicadorContagemSolicitada(false);
                                produtoLojaService.alterar(produtoLoja);
                                if (produtoLoja.getQuantidadeEstoque() > 0 ) {
                                        cadastrarAuditoria(usuario, produtoLoja, TipoEstoqueAuditoria.CONTAGEM.getValor(), produtoLoja.getQuantidadeEstoque(), 0, null, "", TipoEstoqueAuditoriaVerificacao.VERIFICADO_SEM_PENDENCIA.getValor());
                                        produtoLojaService.alterarEstoqueAcrescentandoQuantidadeInformada(-produtoLoja.getQuantidadeEstoque(), produtoLoja.getProduto(), produtoLoja.getLoja());
                                }
                        }
                }
        }
       
        @Override
        public List<ProdutoHistoricoDTO> consultarHistorico(Produto produto, Integer ultimosMeses) {
                List<ProdutoHistoricoDTO> historico = new ArrayList<ProdutoHistoricoDTO>();
                for (int mes = 0; mes <= ultimosMeses; mes++) {
                        Calendar calendarData = new GregorianCalendar();
                        calendarData.setTime(DataUtils.acrescentarMeses(DataUtils.getDataAtual(), mes * -1));
                        historico.addAll(produtoRepository.consultarHistorico(produto,
                                DataUtils.getPrimeiroDiaDoMes(calendarData.get(Calendar.MONTH)+1, calendarData.get(Calendar.YEAR)),
                                DataUtils.getUltimoDiaDoMes(calendarData.get(Calendar.MONTH)+1, calendarData.get(Calendar.YEAR))));
                }
                return historico;
        }
       
        @Override
        public List<ProdutoHistoricoDetalhesDTO> detalharHistorico(ProdutoHistoricoDTO produtoHistorico) {
                return produtoRepository.detalharHistorico(produtoHistorico,
                                DataUtils.getPrimeiroDiaDoMes(new Integer(produtoHistorico.getMes()), new Integer(produtoHistorico.getAno())),
                                DataUtils.getUltimoDiaDoMes(new Integer(produtoHistorico.getMes()), new Integer(produtoHistorico.getAno())));
        }
       
        @Override
        public Integer quantidadeProdutosParaRetirarDoOnline(Loja loja) {
                ParametrosConsultaProdutoDTO parametrosConsulta = new ParametrosConsultaProdutoDTO();
                parametrosConsulta.setLojaSelecionada(loja.getSequencial());
                parametrosConsulta.setTipoRelatorioProduto(TipoRelatorio.RETIRAR_SITE.getValor());
                return produtoRepository.obterQuantidadeDeRegistrosParametrosConsulta(parametrosConsulta);
        }
       
        @Override
        public Integer quantidadeProdutosParaRetirarDoOnlineMatriz() {
                ParametrosConsultaProdutoDTO parametrosConsulta = new ParametrosConsultaProdutoDTO();
                parametrosConsulta.setLojaSelecionada(ConstantesSEC.SEQUENCIAL_MATRIZ_ESTOQUE_9);
                parametrosConsulta.setTipoRelatorioProduto(TipoRelatorio.RETIRAR_SITE.getValor());
                return produtoRepository.obterQuantidadeDeRegistrosParametrosConsulta(parametrosConsulta);
        }
       
        @Override
        public Integer quantidadeProdutosParaRetirarDoOnlineShoplog() {
                ParametrosConsultaProdutoDTO parametrosConsulta = new ParametrosConsultaProdutoDTO();
                parametrosConsulta.setLojaSelecionada(ConstantesSEC.SEQUENCIAL_QUIOSQUE_PATIO_5);
                parametrosConsulta.setTipoRelatorioProduto(TipoRelatorio.RETIRAR_SHOPLOG.getValor());
                return produtoRepository.obterQuantidadeDeRegistrosParametrosConsulta(parametrosConsulta);
        }
       
        @Override
        public Date dataUltimaVenda(Produto produto) {
                return produtoRepository.dataUltimaVenda(produto);
        }
       
        @Override
        public Integer quantidadeProdutosAdicionadosSite(Date dataInicial, Date dataFinal) {
                return produtoRepository.quantidadeProdutosAdicionadosSite(dataInicial, dataFinal);
        }
       
        @Override
        public Integer quantidadeProdutosOnline() {
                return produtoRepository.quantidadeProdutosOnline();
        }
       
        @Override
        public Integer quantidadeProdutosFavoritosOffline(Loja loja) {
                return produtoRepository.quantidadeProdutosFavoritosOffline(loja);
        }
       
        @Override
        public void verificarPedidosProdutoParaEntrarEmContato(Produto produto, Long sequencialCompra) {
                if (!produto.tipoProdutoEhServico()) {
                        List<Pedido> pedidosProduto = new ArrayList<Pedido>();
                        List<Produto> compativeis = consultarCompativeis(produto);
                        for (Produto produtoCompatival : compativeis) {
                                pedidosProduto.addAll(pedidoService.consultarPedidosDoProdutoOuModeloPendentes(produtoCompatival));
                        }
                       
                        for (Pedido pedidoConsultado : pedidosProduto) {
                                Boolean atualizarPedido = false;
                                Boolean atualizarPedidoCompativel = false;
                                for (Produto produtoCompatival : compativeis) {
                                        if (VerificadorUtil.naoEstaNuloOuVazio(pedidoConsultado.getProdutos())) {
                                                for (PedidoProduto pedidoProduto : pedidoConsultado.getProdutos()) {
                                                        if (pedidoProduto.getProduto().getSequencial().equals(produtoCompatival.getSequencial())) {
                                                                if (!produto.getSequencial().equals(produtoCompatival.getSequencial())) {
                                                                        atualizarPedidoCompativel = true;
                                                                }
                                                                atualizarPedido = true;
                                                                break;
                                                        }
                                                }
                                        } else if (VerificadorUtil.estaNulo(pedidoConsultado.getTipoProduto())) {
                                                atualizarPedido = true;
                                        } else if (VerificadorUtil.estaNulo(pedidoConsultado.getGenero())) {
                                                if (pedidoConsultado.getTipoProduto().equals(produtoCompatival.getTipo())) {
                                                        atualizarPedido = true;
                                                }
                                        } else if (pedidoConsultado.getTipoProduto().equals(produtoCompatival.getTipo()) &&
                                                        (produtoCompatival.getGenero().equals(TipoGenero.UNISSEX.getValor()) ||
                                                         pedidoConsultado.getGenero().equals(TipoGenero.UNISSEX.getValor()) ||
                                                         pedidoConsultado.getGenero().equals(produtoCompatival.getGenero()))) {
                                                if (VerificadorUtil.naoEstaNulo(pedidoConsultado.getEstiloProduto()) &&
                                                        VerificadorUtil.estaNulo(pedidoConsultado.getCorProduto())) {
                                                        if (pedidoConsultado.getEstiloProduto().equals(produtoCompatival.getEstilo())) {
                                                                atualizarPedido = true;
                                                        }
                                                } else if (VerificadorUtil.estaNulo(pedidoConsultado.getEstiloProduto()) &&
                                                                   VerificadorUtil.naoEstaNulo(pedidoConsultado.getCorProduto())) {
                                                        if (VerificadorUtil.naoEstaNulo(produtoCompatival.getCor())) {
                                                                if (pedidoConsultado.getCorProduto().equals(produtoCompatival.getCor())) {
                                                                        atualizarPedido = true;
                                                                }
                                                        }
                                                } else if (VerificadorUtil.naoEstaNulo(pedidoConsultado.getEstiloProduto()) &&
                                                                   VerificadorUtil.naoEstaNulo(pedidoConsultado.getCorProduto())) {
                                                        if (pedidoConsultado.getEstiloProduto().equals(produtoCompatival.getEstilo())) {
                                                                if (VerificadorUtil.naoEstaNulo(produtoCompatival.getCor())) {
                                                                        if (pedidoConsultado.getCorProduto().equals(produtoCompatival.getCor())) {
                                                                                atualizarPedido = true;
                                                                        }
                                                                }
                                                        }
                                                } else if (VerificadorUtil.estaNulo(pedidoConsultado.getEstiloProduto()) &&
                                                                   VerificadorUtil.estaNulo(pedidoConsultado.getCorProduto())) {
                                                        atualizarPedido = true;
                                                }
                                        }
                                }
                                if (atualizarPedido) {
                                        pedidoConsultado = pedidoService.consultarPedidoCompleto(pedidoConsultado);
                                        PedidoHistorico pedidoHistorico = new PedidoHistorico();
                                        pedidoHistorico.setPedido(pedidoConsultado);
                                        pedidoHistorico.setTipoSituacao(TipoSituacaoPedido.ENTRAR_EM_CONTATO.getValor());
                                        pedidoHistorico.setDataHistorico(DataUtils.getDataAtual());
                                        if (atualizarPedidoCompativel) {
                                                pedidoHistorico.setObservacao("PRODUTO COMPATÍVEL DISPONÍVEL PELA COMPRA ID " + sequencialCompra);
                                        } else {
                                                pedidoHistorico.setObservacao("PRODUTO DISPONÍVEL PELA COMPRA ID " + sequencialCompra);
                                        }
                                        if (VerificadorUtil.estaNulo(pedidoConsultado.getHistorico())) {
                                                pedidoConsultado.setHistorico(new ArrayList<PedidoHistorico>());
                                        }
                                        pedidoConsultado.setTipoSituacao(TipoSituacaoPedido.ENTRAR_EM_CONTATO.getValor());
                                        pedidoConsultado.setDataUltimaAlteracaoSituacao(DataUtils.getDataAtual());
                                        pedidoConsultado.setUsuarioAtendimento(null);
                                        pedidoConsultado.getHistorico().add(pedidoHistorico);
                                        pedidoService.alterar(pedidoConsultado);
                                }
                        }
                }
        }
       
}