Subversion Repositories Integrator Subversion

Rev

Rev 631 | Rev 694 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

package br.com.ec.repository.jpa;

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

import javax.persistence.Query;
import javax.persistence.TypedQuery;

import org.springframework.stereotype.Repository;

import br.com.ec.core.util.DataUtils;
import br.com.ec.core.util.VerificadorUtil;
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.RankingComprasTransferenciasEstiloDTO;
import br.com.ec.domain.dto.RankingComprasTransferenciasEstiloPorLojaDTO;
import br.com.ec.domain.dto.RankingModeloDTO;
import br.com.ec.domain.dto.RankingProdutoDTO;
import br.com.ec.domain.dto.RankingProdutoDTONovo;
import br.com.ec.domain.dto.VendaDTO;
import br.com.ec.domain.dto.consulta.ParametrosConsultaModelosMaisVendidosDTO;
import br.com.ec.domain.dto.consulta.ParametrosConsultaPorPeriodoDTO;
import br.com.ec.domain.dto.consulta.ParametrosConsultaProdutosVendidosDTO;
import br.com.ec.domain.dto.consulta.ParametrosConsultaVendasDTO;
import br.com.ec.domain.model.Venda;
import br.com.ec.domain.model.tipos.TipoEstiloProduto;
import br.com.ec.domain.model.tipos.TipoGenero;
import br.com.ec.domain.model.tipos.TipoOrdenacaoMaisVendidos;
import br.com.ec.domain.model.tipos.TipoProduto;
import br.com.ec.domain.shared.ConstantesSEC;
import br.com.ec.repository.SistemaAbstractRepository;
import br.com.ec.repository.VendaRepository;

@Repository
public class VendaRepositoryJpaImpl extends SistemaAbstractRepository<Venda> implements VendaRepository {

        @Override
        protected String getColunaOrdenadora() {
                return "dataVenda";
        }
       
        @Override
        public Integer obterQuantidadeDeVendas(ParametrosConsultaVendasDTO parametrosConsultaVendasDTO) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT COUNT(*) FROM Venda e ");
                sql.append("WHERE 1=1 ");
                setarStringParametrosConsulta(sql, parametrosConsultaVendasDTO);
                try {
                        TypedQuery<Long> query = getEntityManager().createQuery(sql.toString(), Long.class);
                        setarQueryParametrosConsulta(query, parametrosConsultaVendasDTO);
                        return query.getSingleResult().intValue();
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
       
        @Override
        public Double obterValorTotalBrutoDeVendas(ParametrosConsultaVendasDTO parametrosConsultaVendasDTO) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT SUM(l.valorVenda) FROM Venda e ");
                sql.append("LEFT JOIN e.listaLancamentos l ");
                sql.append("WHERE l.ativo IS TRUE ");
                setarStringParametrosConsulta(sql, parametrosConsultaVendasDTO);
                try {
                        TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
                        setarQueryParametrosConsulta(query, parametrosConsultaVendasDTO);
                        Double total = query.getSingleResult();
                        if (VerificadorUtil.estaNulo(total)) {
                                return new Double(0.0);
                        }
                        return total;
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
       
        @Override
        public Double obterValorDeCuponsUtilizadosPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsultaVendasDTO) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT SUM(vp.valorPagamento) FROM VendaFormaPagamento vp ");
                sql.append("LEFT JOIN vp.venda e ");
                sql.append("WHERE vp.formaPagamento.codigo = 16 ");
                parametrosConsultaVendasDTO.setIndicadorComissionado(null);
//              parametrosConsultaVendasDTO.setTipoProduto(null);
                setarStringParametrosConsulta(sql, parametrosConsultaVendasDTO);
                try {
                        TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
                        setarQueryParametrosConsulta(query, parametrosConsultaVendasDTO);
                        Double total = query.getSingleResult();
                        if (VerificadorUtil.estaNulo(total)) {
                                return new Double(0.0);
                        }
                        return total;
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
       
        @Override
        public Double obterValorDeMaquinetasPorPessoa(Long sequencialPessoaMaquineta, Date dataInicio, Date dataFim) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT SUM(vp.valorPagamento) FROM VendaFormaPagamento vp ");
                sql.append("LEFT JOIN vp.venda e ");
                sql.append("WHERE vp.formaPagamento.codigo IN :formasDePagamento ");
                sql.append("AND e.maquineta.pessoa.sequencial = :sequencialPessoaMaquineta ");
                sql.append("AND (e.dataVenda BETWEEN :dataInicial AND :dataFinal OR e.dataVenda = :dataInicial OR e.dataVenda = :dataFinal) ");
                try {
                        TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
                        query.setParameter("formasDePagamento", FormaPagamentoDTO.codigosFormasDePagamentoViaCartao());
                        query.setParameter("sequencialPessoaMaquineta", sequencialPessoaMaquineta);
                        query.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(dataInicio));
                        query.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(dataFim));
                       
                        Double total = query.getSingleResult();
                        if (VerificadorUtil.estaNulo(total)) {
                                return new Double(0.0);
                        }
                        return total;
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
       
        private void setarStringParametrosConsulta(StringBuilder sql, ParametrosConsultaVendasDTO parametros) {
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getSequencialLoja())) {
                        sql.append("AND e.loja.sequencial = :sequencialLoja ");
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getTipoSituacaoVenda())) {
                        sql.append("AND e.tipoSituacao = :tipoSituacao ");
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getSequencialVendedor())) {
                        sql.append("AND e.vendedor.sequencial = :sequencialVendedor ");
                }
                /*
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getIndicacao())) {
                        sql.append("AND e.indicacao.sequencial = :sequencialIndicacao ");
                }
                */

                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getIndicadorComissionado())) {
                        sql.append("AND l.produto.indicadorComissionado = :indicadorComissionado ");
                }
                /*
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getTipoProduto())) {
                        sql.append("AND l.produto.tipo = :tipoProduto ");
                }
                //TODO: VERIFICAR LANÇAMENTOS COM MAIS PAGAMENTOS QUE LANÇAMENTOS
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getSituacaoFinanceiraVenda())) {
                        if (parametros.getSituacaoFinanceiraVenda().equals(br.com.ec.domain.model.tipos.TipoSituacaoFinanceira.NENHUMA.getValor())) {
                                sql.append("AND (SELECT COUNT(c) FROM Conta c WHERE c.venda = e) = 0 ");
//                                      sql.append("AND ((SELECT COUNT(vf) FROM VendaFormaPagamento vf WHERE vf.venda = e) > (SELECT COUNT(cr) FROM ContaAReceber cr WHERE cr.venda = e)) ");
                        }
                        if (parametros.getSituacaoFinanceiraVenda().equals(br.com.ec.domain.model.tipos.TipoSituacaoFinanceira.QUITADO.getValor())) {
                                sql.append("AND (SELECT COUNT(p) FROM Parcela p WHERE p.conta.venda = e AND p.dataPagamento is null AND p.indicadorAtivo = true) = 0 ");
                                sql.append("AND (SELECT COUNT(c) FROM Conta c WHERE c.venda = e AND c.indicadorAtivo = true) > 0 ");
                        }
                        if (parametros.getSituacaoFinanceiraVenda().equals(br.com.ec.domain.model.tipos.TipoSituacaoFinanceira.PENDENCIAS.getValor())) {
                                sql.append("AND ((SELECT COUNT(p) FROM Parcela p WHERE p.conta.venda = e AND p.dataPagamento is null AND p.indicadorAtivo = true) > 0 ");
                                sql.append("OR (SELECT COUNT(c) FROM Conta c WHERE c.venda = e AND c.indicadorAtivo = true) = 0) ");
                        }
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getFormaPagamento())) {
                        sql.append("AND (SELECT COUNT(p) FROM VendaFormaPagamento p WHERE p.venda = e AND p.formaPagamento.codigo = :codigoFormaPagamento) > 0 ");
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getBandeiraCartao())) {
                        sql.append("AND (SELECT COUNT(b) FROM VendaFormaPagamento b WHERE b.venda = e AND b.bandeiraCartao.codigo = :codigoBandeiraCartao) > 0 ");
                }
                */

                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getSequencialVenda())) {
                        sql.append("AND e.sequencial = :sequencialVenda ");
                } else if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getParametrosPeriodoDTO().getDataSelecionada())
                                || VerificadorUtil.naoEstaNuloOuVazio(parametros.getParametrosPeriodoDTO().getDataInicial())
                                || VerificadorUtil.naoEstaNuloOuVazio(parametros.getParametrosPeriodoDTO().getDataFinal())) {
                        sql.append("AND e.dataVenda >= :dataInicial ");
                        sql.append("AND e.dataVenda <= :dataFinal ");
                }
                /*
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getCodigoCupom())) {
                        sql.append("AND (SELECT COUNT(cl) FROM Lancamento cl WHERE cl.venda = e AND cl.cupom.codigo = :codigoCupom) > 0) ");
                }
                */

        }
       
        private void setarQueryParametrosConsulta(Query query, ParametrosConsultaVendasDTO parametros) {
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getSequencialLoja())) {
                        query.setParameter("sequencialLoja", parametros.getSequencialLoja());
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getTipoSituacaoVenda())) {
                        query.setParameter("tipoSituacao", parametros.getTipoSituacaoVenda());
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getSequencialVendedor())) {
                        query.setParameter("sequencialVendedor", parametros.getSequencialVendedor());
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getIndicadorComissionado())) {
                        query.setParameter("indicadorComissionado", parametros.getIndicadorComissionado());
                }
                /*
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getIndicacao())) {
                        query.setParameter("sequencialIndicacao", parametros.getIndicacao().getSequencial());
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getTipoProduto())) {
                        query.setParameter("tipoProduto", parametros.getTipoProduto());
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getFormaPagamento())) {
                        query.setParameter("codigoFormaPagamento", parametros.getFormaPagamento().getCodigo());
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getBandeiraCartao())) {
                        query.setParameter("codigoBandeiraCartao", parametros.getBandeiraCartao().getCodigo());
                }
                 */

                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getSequencialVenda())) {
                        query.setParameter("sequencialVenda", parametros.getSequencialVenda());
                } else if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getParametrosPeriodoDTO().getDataInicial())
                                && VerificadorUtil.naoEstaNuloOuVazio(parametros.getParametrosPeriodoDTO().getDataFinal())) {
                        Date dataInicial = DataUtils.getDataComHorarioMinimo(parametros.getParametrosPeriodoDTO().getDataInicial());
                        Date dataFinal = DataUtils.getDataComHorarioMaximo(parametros.getParametrosPeriodoDTO().getDataFinal());
                        query.setParameter("dataInicial", dataInicial);
                        query.setParameter("dataFinal", dataFinal);
                } else if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getParametrosPeriodoDTO().getDataSelecionada())) {
                        Date dataInicial = DataUtils.getDataComHorarioMinimo(parametros.getParametrosPeriodoDTO().getDataSelecionada());
                        Date dataFinal = DataUtils.getDataComHorarioMaximo(parametros.getParametrosPeriodoDTO().getDataSelecionada());
                        query.setParameter("dataInicial", dataInicial);
                        query.setParameter("dataFinal", dataFinal);
                }
                /*
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getCodigoCupom())) {
                        query.setParameter("codigoCupom", parametros.getCodigoCupom());
                }
                */

        }
       
        @Override
        public List<RankingModeloDTO> consultarModelosMaisVendidos(ParametrosConsultaModelosMaisVendidosDTO parametrosConsulta) {
                List<RankingModeloDTO> modelos = new ArrayList<RankingModeloDTO>();
                try {  
                        StringBuilder sql = new StringBuilder();
                        sql.append("SELECT COUNT(l), m.seq_modelo, m.dsc_modelo, m.ind_favorito ");
                       
                        // CONSULTANDO ESTOQUE DO MODELO
                        sql.append(",(SELECT SUM(pl.qtd_estoque) FROM sc_sec.sec_produto_loja pl ");
                        sql.append("LEFT JOIN sc_sec.sec_produto pp ON pp.seq_produto = pl.seq_produto ");
                        sql.append("LEFT JOIN sc_sec.sec_modelo mm ON mm.seq_modelo = pp.seq_modelo ");
                        sql.append("WHERE mm.seq_modelo = m.seq_modelo AND pp.tip_produto = 'C') ");
                       
                        sql.append("FROM sc_sec.sec_lancamento l ");
                        sql.append("LEFT JOIN sc_sec.sec_venda v ON l.seq_venda = v.seq_venda ");
                        sql.append("LEFT JOIN sc_sec.sec_produto p ON p.seq_produto = l.seq_produto ");
                        sql.append("LEFT JOIN sc_sec.sec_modelo m ON m.seq_modelo = p.seq_modelo ");
                        sql.append("WHERE v.dth_venda <= :dataFinal AND v.dth_venda > :dataInicial ");
                        sql.append("AND p.tip_produto = 'C' ");
                        sql.append("AND m.seq_modelo IS NOT NULL ");
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
                                sql.append("AND v.seq_loja = :sequencialLoja ");
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialModelo())) {
                                sql.append("AND m.seq_modelo = :sequencialModelo ");
                        }
                        sql.append("GROUP BY m.seq_modelo, m.dsc_modelo ");
                        sql.append("ORDER BY COUNT(l) DESC ");
                       
                        Query query = getEntityManager().createNativeQuery(sql.toString());
                        Date dataInicial = DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial());
                        Date dataFinal = DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal());
                        query.setParameter("dataInicial", dataInicial);
                        query.setParameter("dataFinal", dataFinal);
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
                                query.setParameter("sequencialLoja", parametrosConsulta.getSequencialLoja());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialModelo())) {
                                query.setParameter("sequencialModelo", parametrosConsulta.getSequencialModelo());
                        }
                       
                        List<Object[]> resultList = query.getResultList();
                       
                        for (Object[] objects : resultList) {
                                RankingModeloDTO rankingModeloDTO = new RankingModeloDTO();
                                ModeloDTO modeloDTO = new ModeloDTO(Long.parseLong(objects[1].toString()), objects[2].toString(), null);
                                modeloDTO.setIndicadorFavorito(Boolean.parseBoolean(objects[3].toString()));
                                rankingModeloDTO.setModelo(modeloDTO);
                                rankingModeloDTO.setQuantidadeVendas(Integer.valueOf(objects[0].toString()));
                                rankingModeloDTO.setQuantidadeEstoqueGeral(Integer.valueOf(objects[4].toString()));
                                modelos.add(rankingModeloDTO);
                        }
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
                return modelos;
                /*
               
                sql.append("SELECT new br.com.ec.domain.dto.RankingModeloDTO(l.produto.modelo, SUM(l.valorVenda), SUM(l.valorCompra), COUNT(l.produto.modelo), ");
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
                        sql.append("(");
                        sql.append(adicionarConsultaDoEstoque(parametrosConsulta.getSequencialLoja(), "l.produto.modelo", parametrosConsulta.getTipoProduto(), parametrosConsulta.getEstiloProduto()));
                        sql.append("), ");
                }
                sql.append("(");
                sql.append(adicionarConsultaDoEstoque(null, "l.produto.modelo", parametrosConsulta.getTipoProduto(), parametrosConsulta.getEstiloProduto()));
                sql.append(")) FROM Lancamento l ");
                sql.append("WHERE l.venda.dataVenda >= :dataInicial AND l.venda.dataVenda <= :dataFinal ");
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
                        sql.append("AND l.venda.loja.sequencial = :sequencialLoja ");
                }
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
                        sql.append("AND l.produto.tipo = :tipoProduto ");
                }
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
                        sql.append("AND l.produto.modelo = :modelo ");
                }
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getEstiloProduto())) {
                        sql.append("AND l.produto.estilo = :estiloProduto ");
                }
                sql.append("GROUP BY l.produto.modelo ");
                if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.LUCRO.getValor())) {
                        sql.append("ORDER BY SUM(l.valorVenda - l.valorCompra) DESC ");
                } else if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.QUANTIDADE.getValor())) {
                        sql.append("ORDER BY COUNT(l.produto.modelo) DESC ");
                } else if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.VALOR_VENDIDO.getValor())) {
                        sql.append("ORDER BY SUM(l.valorVenda) DESC ");
                }
                try {
                        TypedQuery<RankingModeloDTO> query = getEntityManager().createQuery(sql.toString(), RankingModeloDTO.class)
                                        .setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial()))
                                        .setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal()));
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getQuantidadeModelos())) {
                                query.setMaxResults(parametrosConsulta.getQuantidadeModelos());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
                                query.setParameter("sequencialLoja", parametrosConsulta.getSequencialLoja());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
                                query.setParameter("tipoProduto", parametrosConsulta.getTipoProduto());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
                                query.setParameter("modelo", parametrosConsulta.getModelo());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getEstiloProduto())) {
                                query.setParameter("estiloProduto", parametrosConsulta.getEstiloProduto());
                        }
                        return query.getResultList();
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
                */

        }
       
        @Override
        public List<RankingComprasTransferenciasEstiloDTO> consultarRankingPorEstilo(Long sequencialModelo, ParametrosConsultaPorPeriodoDTO parametrosConsultaPorPeriodoDTO) {
                List<RankingComprasTransferenciasEstiloDTO> rankingPorEstilo = new ArrayList<RankingComprasTransferenciasEstiloDTO>();
                try {  
                        StringBuilder sql = new StringBuilder();
                        sql.append("SELECT p.tip_estilo ");
                       
                        sql.append("," + adicionarConsultaVendasRankingPorEstilo("vendas_estilo_a", TipoProduto.CAPA.getValor(), TipoGenero.UNISSEX.getValor()));
                        sql.append("," + adicionarConsultaVendasRankingPorEstilo("vendas_estilo_b", TipoProduto.CAPA.getValor(), TipoGenero.MASCULINO.getValor()));
                        sql.append("," + adicionarConsultaVendasRankingPorEstilo("vendas_estilo_c", TipoProduto.CAPA.getValor(), TipoGenero.FEMININO.getValor()));
                       
                        sql.append("," + adicionarConsultaEstoqueRankingPorEstilo("estoque_estilo_a", TipoProduto.CAPA.getValor(), TipoGenero.UNISSEX.getValor()));
                        sql.append("," + adicionarConsultaEstoqueRankingPorEstilo("estoque_estilo_b", TipoProduto.CAPA.getValor(), TipoGenero.MASCULINO.getValor()));
                        sql.append("," + adicionarConsultaEstoqueRankingPorEstilo("estoque_estilo_c", TipoProduto.CAPA.getValor(), TipoGenero.FEMININO.getValor()));
                       
                        sql.append("FROM sc_sec.sec_produto_loja AS pl ");
                        sql.append("LEFT JOIN sc_sec.sec_produto p ON p.seq_produto = pl.seq_produto ");
                        sql.append("LEFT JOIN sc_sec.sec_modelo m ON m.seq_modelo = p.seq_modelo ");
                        sql.append("WHERE m.seq_modelo = :sequencialModelo ");
                        sql.append("AND p.tip_produto = '" + TipoProduto.CAPA.getValor() + "' ");
                        sql.append("GROUP BY p.tip_estilo ");
                       
                        String orderSql = "ORDER BY (";
                        for (TipoEstiloProduto estiloProduto : TipoEstiloProduto.values()) {
                                orderSql = orderSql + "p.tip_estilo = '" + estiloProduto.getValor() + "', ";
                        }
                        orderSql = orderSql + ") DESC ";
                        sql.append(orderSql.replace(", )", ")"));
//                      sql.append("ORDER BY p.tip_estilo IN :tiposEstilos");
                       
                        Query query = getEntityManager().createNativeQuery(sql.toString());
                        Date dataInicial = DataUtils.getDataComHorarioMinimo(parametrosConsultaPorPeriodoDTO.getDataInicial());
                        Date dataFinal = DataUtils.getDataComHorarioMaximo(parametrosConsultaPorPeriodoDTO.getDataFinal());
                        query.setParameter("dataInicial", dataInicial);
                        query.setParameter("dataFinal", dataFinal);
                        query.setParameter("sequencialModelo", sequencialModelo);
//                      query.setParameter("tiposEstilos", TipoEstiloProduto.values());
                       
                        List<Object[]> resultList = query.getResultList();
                        for (Object[] objects : resultList) {
                                RankingComprasTransferenciasEstiloDTO rankingEstiloDTO = new RankingComprasTransferenciasEstiloDTO();
                                if (VerificadorUtil.naoEstaNuloOuVazio(objects[0])) {
                                        rankingEstiloDTO.setEstilo(TipoEstiloProduto.parse(objects[0].toString()));
                                        rankingEstiloDTO.setQuantidadeVendasUnissex(Integer.valueOf(retornarValorSeExitir(objects[1])));
                                        rankingEstiloDTO.setQuantidadeVendasMasculino(Integer.valueOf(retornarValorSeExitir(objects[2])));
                                        rankingEstiloDTO.setQuantidadeVendasFeminino(Integer.valueOf(retornarValorSeExitir(objects[3])));
                                        rankingEstiloDTO.setQuantidadeEstoqueUnissex(Integer.valueOf(retornarValorSeExitir(objects[4])));
                                        rankingEstiloDTO.setQuantidadeEstoqueMasculino(Integer.valueOf(retornarValorSeExitir(objects[5])));
                                        rankingEstiloDTO.setQuantidadeEstoqueFeminino(Integer.valueOf(retornarValorSeExitir(objects[6])));
                                        rankingPorEstilo.add(rankingEstiloDTO);
                                }
                        }
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
                return rankingPorEstilo;
        }
       
        private String adicionarConsultaVendasRankingPorEstilo(String alias, String tipoProduto, String tipoGenero) {
                StringBuilder sql = new StringBuilder();
                sql.append("(SELECT COUNT(*) FROM sc_sec.sec_lancamento ll ");
                sql.append("LEFT JOIN sc_sec.sec_venda vv ON ll.seq_venda = vv.seq_venda ");
                sql.append("LEFT JOIN sc_sec.sec_produto pp ON pp.seq_produto = ll.seq_produto ");
                sql.append("LEFT JOIN sc_sec.sec_modelo mm ON mm.seq_modelo = pp.seq_modelo ");
                sql.append("WHERE vv.dth_venda <= :dataFinal AND vv.dth_venda >= :dataInicial ");
                sql.append("AND mm.seq_modelo = :sequencialModelo AND pp.tip_estilo = p.tip_estilo ");
                sql.append("AND pp.tip_produto = '" + tipoProduto + "' AND pp.tip_genero LIKE '" + tipoGenero + "') ");
                sql.append("AS " + alias + " ");
                return sql.toString();
        }
       
        private String adicionarConsultaEstoqueRankingPorEstilo(String alias, String tipoProduto, String tipoGenero) {
                StringBuilder sql = new StringBuilder();
                sql.append("(SELECT SUM(pll.qtd_estoque) FROM sc_sec.sec_produto_loja pll ");
                sql.append("LEFT JOIN sc_sec.sec_produto pp ON pp.seq_produto = pll.seq_produto ");
                sql.append("LEFT JOIN sc_sec.sec_modelo mm ON mm.seq_modelo = pp.seq_modelo ");
                sql.append("WHERE mm.seq_modelo = :sequencialModelo AND pp.tip_estilo = p.tip_estilo ");
                sql.append("AND pp.tip_produto = '" + tipoProduto + "' AND pp.tip_genero LIKE '" + tipoGenero + "') ");
                sql.append("AS " + alias + " ");
                return sql.toString();
        }
       
        @Override
        public List<RankingComprasTransferenciasEstiloPorLojaDTO> consultarRankingPorEstiloPorLoja(Long sequencialModelo,
                        String tipoEstilo, ParametrosConsultaPorPeriodoDTO parametrosConsultaPorPeriodoDTO) {
                List<RankingComprasTransferenciasEstiloPorLojaDTO> rankingPorEstiloPorLoja = new ArrayList<RankingComprasTransferenciasEstiloPorLojaDTO>();
                try {  
                        StringBuilder sql = new StringBuilder();
                        sql.append("SELECT pl.seq_loja, lj.dsc_loja ");
                       
                        sql.append("," + adicionarConsultaVendasRankingPorEstiloPorLoja("vendas_estilo_loja_a", TipoProduto.CAPA.getValor(), TipoGenero.UNISSEX.getValor()));
                        sql.append("," + adicionarConsultaVendasRankingPorEstiloPorLoja("vendas_estilo_loja_b", TipoProduto.CAPA.getValor(), TipoGenero.MASCULINO.getValor()));
                        sql.append("," + adicionarConsultaVendasRankingPorEstiloPorLoja("vendas_estilo_loja_c", TipoProduto.CAPA.getValor(), TipoGenero.FEMININO.getValor()));
                       
                        sql.append("," + adicionarConsultaEstoqueRankingPorEstiloPorLoja("estoque_estilo_loja_a", TipoProduto.CAPA.getValor(), TipoGenero.UNISSEX.getValor()));
                        sql.append("," + adicionarConsultaEstoqueRankingPorEstiloPorLoja("estoque_estilo_loja_b", TipoProduto.CAPA.getValor(), TipoGenero.MASCULINO.getValor()));
                        sql.append("," + adicionarConsultaEstoqueRankingPorEstiloPorLoja("estoque_estilo_loja_c", TipoProduto.CAPA.getValor(), TipoGenero.FEMININO.getValor()));
                       
                        sql.append("FROM sc_sec.sec_produto_loja pl ");
                        sql.append("LEFT JOIN sc_sec.sec_loja lj ON lj.seq_loja = pl.seq_loja ");
                        sql.append("LEFT JOIN sc_sec.sec_produto p ON p.seq_produto = pl.seq_produto ");
                        sql.append("LEFT JOIN sc_sec.sec_modelo m ON m.seq_modelo = p.seq_modelo ");
                        sql.append("WHERE m.seq_modelo = :sequencialModelo ");
                        sql.append("AND p.tip_produto = '" + TipoProduto.CAPA.getValor() + "' ");
                        sql.append("AND p.tip_estilo = :tipoEstilo ");
                        sql.append("AND lj.ind_ativo IS TRUE ");
                        sql.append("GROUP BY lj.num_ordem, pl.seq_loja, lj.dsc_loja ");
                        sql.append("ORDER BY lj.num_ordem ");
                       
                        Query query = getEntityManager().createNativeQuery(sql.toString());
                        Date dataInicial = DataUtils.getDataComHorarioMinimo(parametrosConsultaPorPeriodoDTO.getDataInicial());
                        Date dataFinal = DataUtils.getDataComHorarioMaximo(parametrosConsultaPorPeriodoDTO.getDataFinal());
                        query.setParameter("dataInicial", dataInicial);
                        query.setParameter("dataFinal", dataFinal);
                        query.setParameter("sequencialModelo", sequencialModelo);
                        query.setParameter("tipoEstilo", tipoEstilo);
                       
                        List<Object[]> resultList = query.getResultList();
                        for (Object[] objects : resultList) {
                                RankingComprasTransferenciasEstiloPorLojaDTO rankingEstiloPorLojaDTO = new RankingComprasTransferenciasEstiloPorLojaDTO();
                                rankingEstiloPorLojaDTO.setLojaDTO(new LojaDTO(Long.parseLong(retornarValorSeExitir(objects[0])), retornarValorSeExitir(objects[1])));
                                rankingEstiloPorLojaDTO.setQuantidadeVendasUnissex(Integer.valueOf(retornarValorSeExitir(objects[2])));
                                rankingEstiloPorLojaDTO.setQuantidadeVendasMasculino(Integer.valueOf(retornarValorSeExitir(objects[3])));
                                rankingEstiloPorLojaDTO.setQuantidadeVendasFeminino(Integer.valueOf(retornarValorSeExitir(objects[4])));
                                rankingEstiloPorLojaDTO.setQuantidadeEstoqueUnissex(Integer.valueOf(retornarValorSeExitir(objects[5])));
                                rankingEstiloPorLojaDTO.setQuantidadeEstoqueMasculino(Integer.valueOf(retornarValorSeExitir(objects[6])));
                                rankingEstiloPorLojaDTO.setQuantidadeEstoqueFeminino(Integer.valueOf(retornarValorSeExitir(objects[7])));
                                rankingPorEstiloPorLoja.add(rankingEstiloPorLojaDTO);
                        }
                       
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
                return rankingPorEstiloPorLoja;
        }
       
        private String adicionarConsultaVendasRankingPorEstiloPorLoja(String alias, String tipoProduto, String tipoGenero) {
                StringBuilder sql = new StringBuilder();
                sql.append("(SELECT COUNT(*) FROM sc_sec.sec_lancamento ll ");
                sql.append("LEFT JOIN sc_sec.sec_venda vv ON ll.seq_venda = vv.seq_venda ");
                sql.append("LEFT JOIN sc_sec.sec_produto pp ON pp.seq_produto = ll.seq_produto ");
                sql.append("LEFT JOIN sc_sec.sec_modelo mm ON mm.seq_modelo = pp.seq_modelo ");
                sql.append("WHERE vv.dth_venda <= :dataFinal AND vv.dth_venda >= :dataInicial ");
                sql.append("AND vv.seq_loja = pl.seq_loja ");
                sql.append("AND mm.seq_modelo = :sequencialModelo AND pp.tip_estilo = :tipoEstilo ");
                sql.append("AND pp.tip_produto = '" + tipoProduto + "' AND pp.tip_genero LIKE '" + tipoGenero + "') ");
                sql.append("AS " + alias + " ");
                return sql.toString();
        }
       
        private String adicionarConsultaEstoqueRankingPorEstiloPorLoja(String alias, String tipoProduto, String tipoGenero) {
                StringBuilder sql = new StringBuilder();
                sql.append("(SELECT SUM(pll.qtd_estoque) FROM sc_sec.sec_produto_loja pll ");
                sql.append("LEFT JOIN sc_sec.sec_produto pp ON pp.seq_produto = pll.seq_produto ");
                sql.append("LEFT JOIN sc_sec.sec_modelo mm ON mm.seq_modelo = pp.seq_modelo ");
                sql.append("WHERE pll.seq_loja = pl.seq_loja AND mm.seq_modelo = :sequencialModelo ");
                sql.append("AND pp.tip_estilo = :tipoEstilo ");
                sql.append("AND pp.tip_produto = '" + tipoProduto + "' AND pp.tip_genero LIKE '" + tipoGenero + "') ");
                sql.append("AS " + alias + " ");
                return sql.toString();
        }
       
        private String retornarValorSeExitir(Object objeto) {
                String valor = "0";
                if (VerificadorUtil.naoEstaNulo(objeto)) {
                        valor = objeto.toString();
                }
                return valor;
        }

        /*
        private String adicionarConsultaDoEstoque(Long sequencialLoja, String modelo, String tipoProduto, String estiloProduto) {
                sql.append("SELECT SUM(pl.quantidadeEstoque) FROM ProdutoLoja pl ");
                sql.append("WHERE pl.produto.modelo = " + modelo + " ");
                if (VerificadorUtil.naoEstaNuloOuVazio(sequencialLoja)) {
                        sql.append("AND pl.loja.sequencial = :sequencialLoja ");
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(tipoProduto)) {
                        sql.append("AND pl.produto.tipo = :tipoProduto ");
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(estiloProduto)) {
                        sql.append("AND pl.produto.estilo = :estiloProduto ");
                }
                return sql.toString().trim();
        }
         */

       
        /*
        private void setarParametrosStringConsultarVendaPorLojaEePeriodo(StringBuilder sql, Venda venda, Date dataInicial, Date dataFinal) {
                setarStringParametrosConsultar(sql, venda);
                if (VerificadorUtil.naoEstaNuloOuVazio(dataInicial) && VerificadorUtil.naoEstaNuloOuVazio(dataFinal)) {
                        sql.append("AND e.dataVenda >= :dataInicial AND e.dataVenda <= :dataFinal ");
                }
        }
        */

/*
        @Override
        protected void setarStringParametrosConsultar(StringBuilder sql, Venda venda) {
                if (VerificadorUtil.naoEstaNuloOuVazio(venda)) {
                        if (VerificadorUtil.naoEstaNuloOuVazio(venda.getSequencialDaLoja())) {
                                sql.append("AND e.loja.sequencial = :sequencialLoja ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(venda.getVendedor())) {
                                sql.append("AND e.vendedor.sequencial = :sequencialVendedor ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(venda.getIndicacao())) {
                                sql.append("AND e.indicacao.sequencial = :sequencialIndicacao ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(venda.getTipoSituacao())) {
                                sql.append("AND e.tipoSituacao = :tipoSituacao ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(venda.getDataVenda())) {
                                sql.append("AND e.dataVenda >= :dataInicial ");
                                sql.append("AND e.dataVenda <= :dataFinal ");
                        }
                }
        }
       
        @Override
        protected void setarQueryParametrosConsultar(Query query, Venda venda) {
                if (VerificadorUtil.naoEstaNuloOuVazio(venda)) {
                        if (VerificadorUtil.naoEstaNuloOuVazio(venda.getSequencialDaLoja())) {
                                query.setParameter("sequencialLoja", venda.getSequencialDaLoja());
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(venda.getSequencialDoVendedor())) {
                                query.setParameter("sequencialVendedor", venda.getSequencialDoVendedor());
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(venda.getIndicacao())) {
                                query.setParameter("sequencialIndicacao", venda.getIndicacao());
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(venda.getTipoSituacao())) {
                                query.setParameter("tipoSituacao", venda.getTipoSituacao());
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(venda.getDataVenda())) {
                                Date dataInicial = DataUtils.getDataComHorarioMinimo(venda.getDataVenda());
                                Date dataFinal = DataUtils.getDataComHorarioMaximo(venda.getDataVenda());
                                query.setParameter("dataInicial", dataInicial);
                                query.setParameter("dataFinal", dataFinal);
                        }
                }
        }
       
        @Override
        public List<Venda> consultarVendasPorDemanda(ParametrosConsulta<Venda> parametrosConsulta, Integer primeiroRegistro,
                        Integer tamanhoPagina, String sortField, String orderSort, Map<String, Object> filters) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT DISTINCT e FROM Venda e ");
                sql.append("LEFT JOIN FETCH e.listaLancamentos l ");
                sql.append("LEFT JOIN FETCH e.listaVendaFormaPagamentos p ");
                sql.append("WHERE 1=1 ");
               
                try {
                        setarStringParametrosConsulta(sql, parametrosConsulta);
                        sql.append("ORDER BY e.dataVenda");
                        TypedQuery<Venda> query = (TypedQuery<Venda>) getEntityManager().createQuery(sql.toString(), Venda.class);
                        setarQueryParametrosConsulta(query, parametrosConsulta);
               
                        return query.setFirstResult(primeiroRegistro).setMaxResults(tamanhoPagina).getResultList();
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
       
        @Override
        public List<Venda> consultarVendaPorParametros(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT DISTINCT e FROM Venda e ");
                sql.append("LEFT JOIN FETCH e.listaLancamentos l ");
                sql.append("LEFT JOIN FETCH e.listaVendaFormaPagamentos p ");
                sql.append("WHERE 1=1 ");
               
                try {
                        setarStringParametrosConsulta(sql, parametrosConsultaVendas);
                        sql.append("ORDER BY e.dataVenda");
                        TypedQuery<Venda> query = (TypedQuery<Venda>) getEntityManager().createQuery(sql.toString(), Venda.class);
                        setarQueryParametrosConsulta(query, parametrosConsultaVendas);
                        return query.getResultList();
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
       
        @Override
        public Venda detalharVenda(Venda venda) {
                StringBuilder jpql = new StringBuilder();
                try {
                        jpql.append("SELECT c FROM Venda c ");
                        //jpql.append("LEFT JOIN FETCH c.listaPedidos p ");
                        //jpql.append("LEFT JOIN FETCH c.listaVendas v ");
                        jpql.append("WHERE c = :venda");
                        return getEntityManager().createQuery(jpql.toString(), Venda.class).setParameter("venda", venda).getSingleResult();
                } catch (NoResultException e) {
                        return null;
                }
        }
       
        @Override
        public Venda detalharVendaCompleta(Venda venda) {
                StringBuilder jpql = new StringBuilder();
                try {
                        jpql.append("SELECT c FROM Venda c ");
                        jpql.append("LEFT JOIN FETCH c.listaLancamentos l ");
                        jpql.append("LEFT JOIN FETCH c.listaVendaFormaPagamentos p ");
                        jpql.append("WHERE c = :venda");
                        return getEntityManager().createQuery(jpql.toString(), Venda.class).setParameter("venda", venda).getSingleResult();
                } catch (NoResultException e) {
                        return null;
                }
        }
       
        @Override
        public List<Venda> consultarVendasDoDia(Long sequencialLoja, Date data) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT DISTINCT v FROM Venda v ");
                sql.append("LEFT JOIN FETCH v.listaVendaFormaPagamentos p ");
                sql.append("WHERE v.loja.sequencial = :sequencialLoja ");
                sql.append("AND v.dataVenda >= :dataInicial AND v.dataVenda <= :dataFinal ");
                try {
                        sql.append("ORDER BY v.dataVenda");
                        return getEntityManager().createQuery(sql.toString(), Venda.class)
                                                .setParameter("sequencialLoja", sequencialLoja)
                                                .setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(data))
                                                .setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(data))
                                                .getResultList();
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
       
       
        private void setarParametrosQueryConsultarVendaPorLojaEePeriodo(Query query, Venda venda, Date dataInicial, Date dataFinal) {
                setarQueryParametrosConsultar(query, venda);
                if (VerificadorUtil.naoEstaNuloOuVazio(dataInicial) && VerificadorUtil.naoEstaNuloOuVazio(dataFinal)) {
                        query.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(dataInicial));
                        query.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(dataFinal));
                }
        }
       
        @Override
        public Double obterValorTotalBrutoDeVendasPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsulta) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT SUM(l.valorVenda) FROM Venda e ");
                sql.append("LEFT JOIN e.listaLancamentos l ");
                sql.append("WHERE l.ativo IS TRUE ");
                try {
                        setarStringParametrosConsulta(sql, parametrosConsulta);
                        TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
                        setarQueryParametrosConsulta(query, parametrosConsulta);
                        Double total = query.getSingleResult();
                        if (VerificadorUtil.estaNulo(total)) {
                                return new Double(0.0);
                        }
                        return total;
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
       
        @Override
        public Double obterValorDeCuponsUtilizadosPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsulta) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT SUM(p.valorPagamento) FROM VendaFormaPagamento p ");
                sql.append("LEFT JOIN p.venda e ");
                sql.append("WHERE p.formaPagamento.codigo = 16 ");
               
                parametrosConsulta.setIndicadorComissionado(null);
                parametrosConsulta.setTipoProduto(null);
               
                setarStringParametrosConsulta(sql, parametrosConsulta);
*/
             
                /*
                sql.append("AND (SELECT COUNT(l) FROM Lancamento l WHERE l.venda = e AND l.ativo = true) > 0 ");
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getLoja())) {
                        sql.append("AND e.loja.sequencial = :sequencialLoja ");
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getVendedor())) {
                        sql.append("AND e.vendedor.sequencial = :sequencialVendedor ");
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataVendas())
                                || VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataInicial())
                                || VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataFinal())) {
                        sql.append("AND e.dataVenda >= :dataInicial ");
                        sql.append("AND e.dataVenda <= :dataFinal ");
                }
                */

/*     
                try {
                        TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
                        setarQueryParametrosConsulta(query, parametrosConsulta);
*/
                     
                        /*
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getLoja())) {
                                query.setParameter("sequencialLoja", parametrosConsulta.getLoja().getSequencial());
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getVendedor())) {
                                query.setParameter("sequencialVendedor", parametrosConsulta.getVendedor().getSequencial());
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataInicial())
                                        && VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataFinal())) {
                                Date dataInicial = DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial());
                                Date dataFinal = DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal());
                                query.setParameter("dataInicial", dataInicial);
                                query.setParameter("dataFinal", dataFinal);
                        } else if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataVendas())) {
                                Date dataInicial = DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataVendas());
                                Date dataFinal = DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataVendas());
                                query.setParameter("dataInicial", dataInicial);
                                query.setParameter("dataFinal", dataFinal);
                        }
                        */

/*     
                        Double total = query.getSingleResult();
                        if (VerificadorUtil.estaNulo(total)) {
                                return new Double(0.0);
                        }
                        return total;
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
       
        @Override
        public Double obterValorTotalDeDescontosPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsulta) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT SUM(l.valorVarejo - l.valorVenda) FROM Venda e ");
                sql.append("LEFT JOIN e.listaLancamentos l ");
                sql.append("WHERE l.ativo IS TRUE ");
                try {
                        setarStringParametrosConsulta(sql, parametrosConsulta);
                        TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
                        setarQueryParametrosConsulta(query, parametrosConsulta);
                        Double total = query.getSingleResult();
                        if (VerificadorUtil.estaNulo(total)) {
                                return new Double(0.0);
                        }
                        return total;
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
        */

        @Override
        public Double obterValorTotalBrutoDeVendasPorParametrosEeFormasDePagamento(ParametrosConsultaVendasDTO parametrosConsultaVendas, List<FormaPagamentoDTO> formasDePagamento) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT SUM(vp.valorPagamento) FROM VendaFormaPagamento vp ");
                sql.append("LEFT JOIN vp.venda e ");
                sql.append("LEFT JOIN vp.formaPagamento f ");
                sql.append("WHERE vp.formaPagamento.codigo != ");
                sql.append(ConstantesSEC.FormasDePagamento.FORMAPAGAMENTO_CUPOM);
                sql.append(" ");
                try {
                        sql = setarParametrosFormasDePagamento(sql, formasDePagamento);
                        sql = setarParametrosLojasSelecionadas(sql, parametrosConsultaVendas.getLojasSelecionadasDTO());
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendas.getVendedorSelecionado())) {
                                sql.append("AND e.vendedor.sequencial = :sequencialVendedor ");
                        }
                        setarStringParametrosConsulta(sql, parametrosConsultaVendas);
                        TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
                        setarQueryParametrosConsulta(query, parametrosConsultaVendas);
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendas.getVendedorSelecionado())) {
                                query.setParameter("sequencialVendedor", parametrosConsultaVendas.getVendedorSelecionado().getSequencial());
                        }
                        Double total = query.getSingleResult();
                        if (VerificadorUtil.estaNulo(total)) {
                                return new Double(0.0);
                        }
                        return total;
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }

        private StringBuilder setarParametrosFormasDePagamento(StringBuilder sql, List<FormaPagamentoDTO> formasPagamento) {
                if (VerificadorUtil.naoEstaNuloOuVazio(formasPagamento)) {
                        sql.append("AND vp.formaPagamento.codigo IN (");
                        for (FormaPagamentoDTO formaPagamento : formasPagamento) {
                                if (!formaPagamento.formaPagamentoEhCupom()) {
                                        sql.append(formaPagamento.getCodigo() + ",");
                                }
                        }
                        sql.append(") ");
                }
                return new StringBuilder(sql.toString().replace(",)", ")"));
        }
       
        private StringBuilder setarParametrosLojasSelecionadas(StringBuilder sql, List<LojaDTO> lojasSelecionadas) {
                if (VerificadorUtil.naoEstaNuloOuVazio(lojasSelecionadas)) {
                        sql.append("AND vp.venda.loja.sequencial IN (");
                        for (LojaDTO loja : lojasSelecionadas) {
                                sql.append(loja.getSequencial() + ",");
                        }
                        sql.append(") ");
                }
                return new StringBuilder(sql.toString().replace(",)", ")"));
        }
       
        @Override
        public Double obterValorTotalLiquidoDeVendas(ParametrosConsultaVendasDTO parametrosConsulta) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT SUM(e.valor) FROM Parcela e ");
                sql.append("INNER JOIN e.conta c ");
                sql.append("WHERE e.indicadorAtivo IS TRUE ");
                try {
                        setarParametrosStringConsultarValorTotalLiquidoVenda(sql, parametrosConsulta);
                        TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
                        setarParametrosQueryConsultarValorTotalLiquidoVenda(query, parametrosConsulta);
                       
                        Double total = query.getSingleResult();
                        if (VerificadorUtil.estaNulo(total)) {
                                return new Double(0.0);
                        }
                        return total;
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
       
        private void setarParametrosStringConsultarValorTotalLiquidoVenda(StringBuilder sql, ParametrosConsultaVendasDTO parametrosConsulta) {
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getSequencialLoja())) {
                        sql.append("AND e.conta.venda.loja.sequencial = :sequencialLoja ");
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getSequencialVendedor())) {
                        sql.append("AND e.conta.venda.vendedor.sequencial = :sequencialVendedor ");
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataInicialDoPeriodo()) && VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataFinalDoPeriodo())) {
                        sql.append("AND e.conta.venda.dataVenda >= :dataInicial AND e.conta.venda.dataVenda <= :dataFinal ");
                }
                /*
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getIndicacao())) {
                        sql.append("AND e.conta.venda.indicacao.sequencial = :sequencialIndicacao ");
                }
                 */

        }
       
        private void setarParametrosQueryConsultarValorTotalLiquidoVenda(Query query, ParametrosConsultaVendasDTO parametrosConsulta) {
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getSequencialLoja())) {
                        query.setParameter("sequencialLoja", parametrosConsulta.getSequencialLoja());
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getSequencialVendedor())) {
                        query.setParameter("sequencialVendedor", parametrosConsulta.getSequencialVendedor());
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataInicialDoPeriodo()) && VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataFinalDoPeriodo())) {
                        query.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicialDoPeriodo()));
                        query.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinalDoPeriodo()));
                }
                /*
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getIndicacao())) {
                        query.setParameter("sequencialIndicacao", parametrosConsulta.getIndicacao().getSequencial());
                }
                */

        }
       
        @Override
        public Double obterValorProdutosUtilizadosEmVendas(ParametrosConsultaVendasDTO parametrosConsulta) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT SUM(l.valorCompra) FROM Venda e ");
                sql.append("LEFT JOIN e.listaLancamentos l ");
                sql.append("WHERE l.ativo IS TRUE ");
                try {
                        setarStringParametrosConsulta(sql, parametrosConsulta);
                        TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
                        setarQueryParametrosConsulta(query, parametrosConsulta);
                        Double total = query.getSingleResult();
                        if (VerificadorUtil.estaNulo(total)) {
                                return new Double(0.0);
                        }
                        return total;
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
       
        @Override
        public List<AuditoriaVendaDTO> consultarAuditoriaVenda(Date dataSelecionada, Long sequencialLojaSelecionada) {
                StringBuilder sql = new StringBuilder();
//              (Long sequencialVenda, Long sequencialLoja, Date dataHoraVenda, Double valorTotal, Double valorTrocaCancelamento)
                sql.append("SELECT new br.com.ec.domain.dto.AuditoriaVendaDTO(");
                sql.append("v.sequencial, v.loja.sequencial, v.dataVenda, SUM(vfp.valorPagamento), ");
                sql.append("(SELECT SUM(vfpcupom.valorPagamento) FROM VendaFormaPagamento vfpcupom WHERE ");
                sql.append("vfpcupom.venda.sequencial = v.sequencial AND vfpcupom.formaPagamento.codigo = 16)");
                sql.append(") FROM Venda v ");
                sql.append("LEFT JOIN v.listaVendaFormaPagamentos vfp ON vfp.formaPagamento.codigo <> 16 ");
                sql.append("WHERE v.loja.sequencial = :sequencialLojaSelecionada ");
                sql.append("AND v.dataVenda >= :dataInicial AND v.dataVenda <= :dataFinal ");
                sql.append("GROUP BY (v.sequencial) ");
                sql.append("ORDER BY (v.dataVenda) ");
                try {
                        TypedQuery<AuditoriaVendaDTO> query = getEntityManager().createQuery(sql.toString(), AuditoriaVendaDTO.class);
                        query.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(dataSelecionada));
                        query.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(dataSelecionada));
                        query.setParameter("sequencialLojaSelecionada", sequencialLojaSelecionada);
                        return query.getResultList();
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
       
       
       
        /*

        @Override
        public Integer obterQuantidadeProdutosVendidosPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsulta) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT COUNT(l) FROM Venda e ");
                sql.append("LEFT JOIN e.listaLancamentos l ");
                sql.append("WHERE l.ativo IS TRUE ");
                try {
                        setarStringParametrosConsulta(sql, parametrosConsulta);
                        TypedQuery<Long> query = getEntityManager().createQuery(sql.toString(), Long.class);
                        setarQueryParametrosConsulta(query, parametrosConsulta);
                        return query.getSingleResult().intValue();
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
       
        @Override
        public Integer obterQuantidadeProdutosVendidosPorLojaEePeriodoNaoVivo(ParametrosConsultaVendasDTO parametrosConsulta) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT COUNT(l) FROM Venda e ");
                sql.append("LEFT JOIN e.listaLancamentos l ");
                sql.append("WHERE l.ativo IS TRUE AND l.produto.tipo not like 'V' ");
                try {
                        setarStringParametrosConsulta(sql, parametrosConsulta);
                        TypedQuery<Long> query = getEntityManager().createQuery(sql.toString(), Long.class);
                        setarQueryParametrosConsulta(query, parametrosConsulta);
                        return query.getSingleResult().intValue();
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
       
        @Override
        public GraficoAcumuladoDTO consultarGrafico(String mes, String ano) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT ");
                Calendar data = DataUtils.obterCalendario(DataUtils.obterData(1, new Integer(mes)-1, new Integer(ano)));
                int qntMaximaDias = data.getActualMaximum(Calendar.DAY_OF_MONTH);
                for (int i = 1; i <= qntMaximaDias; i++) {
                        String dia = String.format("%02d", i);
                        sql.append("SUM(D.DIA" + dia + ") AS dia" + dia);
                        if (i < qntMaximaDias) {
                                sql.append(", ");
                        } else {
                                sql.append(" ");
                        }
                }
                sql.append(" FROM ");
                sql.append("(SELECT ");
                for (int i = 1; i <= qntMaximaDias; i++) {
                        String dia = String.format("%02d", i);
                        sql.append("CASE date(v.dth_venda) WHEN '" + ano + "-" + mes + "-" + dia + "' THEN SUM(l.val_venda) END AS DIA" + dia);
                        if (i < qntMaximaDias) {
                                sql.append(", ");
                        } else {
                                sql.append(" ");
                        }
                }
                sql.append("FROM sc_sec.sec_lancamento l, sc_sec.sec_venda v ");
                sql.append("WHERE l.seq_venda = v.seq_venda AND l.ind_ativo is true ");
                sql.append("GROUP BY date(v.dth_venda) ");
                sql.append(") AS D ");
               
                try {
                        Query query = getEntityManager().createNativeQuery(sql.toString());
                        Object[] valores = new Object[31];
                        Object[] resultado = (Object[]) query.getSingleResult();
                        for (int i = 0; i < resultado.length; i++) {
                                valores[i] = resultado[i];
                        }
                        GraficoAcumuladoDTO grafico = new GraficoAcumuladoDTO();
                        grafico.setDIA_01(retornarValorEmString(valores[0]));
                        grafico.setDIA_02(retornarValorEmString(valores[1]));
                        grafico.setDIA_03(retornarValorEmString(valores[2]));
                        grafico.setDIA_04(retornarValorEmString(valores[3]));
                        grafico.setDIA_05(retornarValorEmString(valores[4]));
                        grafico.setDIA_06(retornarValorEmString(valores[5]));
                        grafico.setDIA_07(retornarValorEmString(valores[6]));
                        grafico.setDIA_08(retornarValorEmString(valores[7]));
                        grafico.setDIA_09(retornarValorEmString(valores[8]));
                        grafico.setDIA_10(retornarValorEmString(valores[9]));
                        grafico.setDIA_11(retornarValorEmString(valores[10]));
                        grafico.setDIA_12(retornarValorEmString(valores[11]));
                        grafico.setDIA_13(retornarValorEmString(valores[12]));
                        grafico.setDIA_14(retornarValorEmString(valores[13]));
                        grafico.setDIA_15(retornarValorEmString(valores[14]));
                        grafico.setDIA_16(retornarValorEmString(valores[15]));
                        grafico.setDIA_17(retornarValorEmString(valores[16]));
                        grafico.setDIA_18(retornarValorEmString(valores[17]));
                        grafico.setDIA_19(retornarValorEmString(valores[18]));
                        grafico.setDIA_20(retornarValorEmString(valores[19]));
                        grafico.setDIA_21(retornarValorEmString(valores[20]));
                        grafico.setDIA_22(retornarValorEmString(valores[21]));
                        grafico.setDIA_23(retornarValorEmString(valores[22]));
                        grafico.setDIA_24(retornarValorEmString(valores[23]));
                        grafico.setDIA_25(retornarValorEmString(valores[24]));
                        grafico.setDIA_26(retornarValorEmString(valores[25]));
                        grafico.setDIA_27(retornarValorEmString(valores[26]));
                        grafico.setDIA_28(retornarValorEmString(valores[27]));
                        grafico.setDIA_29(retornarValorEmString(valores[28]));
                        grafico.setDIA_30(retornarValorEmString(valores[29]));
                        grafico.setDIA_31(retornarValorEmString(valores[30]));
                        return grafico;
                } catch(Exception ex) {
                        return null;
                }
        }
       
        private Double retornarValorEmString(Object objeto) {
                try {
                        return new Double(objeto.toString());
                } catch (Exception e) {
                        return new Double(0.0);
                }
        }
        */

       
        private String adicionarEstoque(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
                StringBuilder sql = new StringBuilder();
                sql.append(", (SELECT SUM(pl.quantidadeEstoque) FROM ProdutoLoja pl WHERE pl.produto = l.produto ");
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
                        sql.append("AND pl.loja.sequencial = :sequencialLoja ");
                }
                sql.append(")");
                return sql.toString();
        }

/*
        /*private String adicionarConsumoMedioDiario(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
                StringBuilder sql = new StringBuilder();
                sql.append(", (SELECT COUNT(*) FROM Lancamento lc WHERE lc.produto = l.produto AND lc.ativo = true ");
                sql.append("WHERE lc.venda.dataVenda >= :dataInicial AND lc.venda.dataVenda <= :dataFinal) ");
//              String dataAnterior = DataUtil.retornarDataFormatadaEmFormatoTexto("yyyy-MM-dd", DataUtils.acrescentarMeses(DataUtils.getDataAtual(), -2));
//              sql.append("AND lc.venda.dataVenda >= :dataDoisMesesAnterior) ");
                return sql.toString();
        }*/

       
        private String adicionarSolicitacaoCompraProduto() {
                StringBuilder sql = new StringBuilder();
//              sql.append(", (SELECT COUNT(*) > 0 FROM ProdutoPedidoCompra ppc WHERE ppc.produto = l.produto)");
//              sql.append(", (SELECT ppc.status, ppc.quantidadeParaComprar FROM ProdutoPedidoCompra ppc WHERE ppc.produto = l.produto)");
//              sql.append(", (SELECT (ppc) FROM ProdutoPedidoCompra ppc WHERE ppc.produto = l.produto)");
                sql.append(", (SELECT ppc.status FROM ProdutoPedidoCompra ppc WHERE ppc.produto = l.produto)");
                sql.append(", (SELECT ppc.quantidadeParaComprar FROM ProdutoPedidoCompra ppc WHERE ppc.produto = l.produto)");
                return sql.toString();
        }
       
        @Override
        public List<RankingProdutoDTO> consultarProdutosVendidos(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
                StringBuilder sql = new StringBuilder();
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getTipoOrdenacao())) {
                        if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.DATA.getValor())) {
                                sql.append("SELECT new br.com.ec.domain.dto.RankingProdutoDTO(l.produto, l.venda, l.valorVenda, l.valorVarejo - l.valorVenda");
                                sql.append(adicionarEstoque(parametrosConsulta));
                                sql.append(adicionarSolicitacaoCompraProduto());
                                sql.append(") FROM Lancamento l ");
                        } else {
                                sql.append("SELECT new br.com.ec.domain.dto.RankingProdutoDTO(l.produto, SUM(l.valorVenda), SUM(l.valorCompra), SUM(l.valorVarejo - l.valorVenda), COUNT(l.produto), MAX(l.venda.dataVenda)");
                                sql.append(adicionarEstoque(parametrosConsulta));
                                sql.append(adicionarSolicitacaoCompraProduto());
                                sql.append(") FROM Lancamento l ");
                        }
                } else {
                        sql.append("SELECT new br.com.ec.domain.dto.RankingProdutoDTO(l.produto, l.venda, l.valorVenda, l.valorVarejo - l.valorVenda");
                        sql.append(adicionarEstoque(parametrosConsulta));
                        sql.append(adicionarSolicitacaoCompraProduto());
                        sql.append(") FROM Lancamento l ");
                }
                sql.append("WHERE l.venda.dataVenda >= :dataInicial AND l.venda.dataVenda <= :dataFinal ");
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
                        sql.append("AND l.venda.loja.sequencial = :sequencialLoja ");
                }
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
                        sql.append("AND l.produto.tipo = :tipoProduto ");
                }
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getProduto())) {
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCodigo())) {
                                sql.append("AND l.produto.codigo = :codigo ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getDescricao())) {
                                sql.append("AND ");
                                sql.append(sqlConsultarSemAcento("l.produto.descricao"));
                                sql.append(" like upper(:descricao) ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getEstilo())) {
                                sql.append("AND l.produto.estilo = :tipoEstilo ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCor())) {
                                sql.append("AND l.produto.cor = :tipoCor ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getGenero())) {
                                sql.append("AND l.produto.genero = :tipoGenero ");
                        }
                }
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getMarca())) {
                        sql.append("AND l.produto.modelo.marca.sequencial = :sequencialMarcaDoModelo ");
                }
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
                        sql.append("AND l.produto.modelo.sequencial = :sequencialModelo ");
                }
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getFornecedor())) {
                        sql.append("AND :fornecedor in (SELECT fp.fornecedor FROM FornecedorProduto fp WHERE fp.produto.sequencial = l.produto.sequencial) ");
                }
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getVendedor())) {
                        sql.append("AND l.venda.vendedor = :vendedor ");
                }
               
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getTipoOrdenacao())) {
                        if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.DATA.getValor())) {
                                sql.append("ORDER BY l.venda.dataVenda DESC ");
                        } else {
                                sql.append("GROUP BY l.produto ");
                                if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.LUCRO.getValor())) {
                                        sql.append("ORDER BY SUM(l.valorVenda - l.valorCompra) DESC ");
                                } else if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.QUANTIDADE.getValor())) {
                                        sql.append("ORDER BY COUNT(l.produto) DESC ");
                                } else if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.VALOR_VENDIDO.getValor())) {
                                        sql.append("ORDER BY SUM(l.valorVenda) DESC ");
                                }
                        }
                } else {
                        sql.append("ORDER BY l.venda.dataVenda DESC ");
                }
                try {
                        TypedQuery<RankingProdutoDTO> query = getEntityManager().createQuery(sql.toString(), RankingProdutoDTO.class)
                                        .setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial()))
                                        .setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal()));
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getQuantidadeProdutos())) {
                                query.setMaxResults(parametrosConsulta.getQuantidadeProdutos());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
                                query.setParameter("sequencialLoja", parametrosConsulta.getLoja().getSequencial());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
                                query.setParameter("tipoProduto", parametrosConsulta.getTipoProduto());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getProduto())) {
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCodigo())) {
                                        query.setParameter("codigo", parametrosConsulta.getProduto().getCodigoProdutoPadrao());
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getDescricao())) {
                                        query.setParameter("descricao", "%" + removerAcentuacao(parametrosConsulta.getProduto().getDescricao()) + "%");
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getEstilo())) {
                                        query.setParameter("tipoEstilo", parametrosConsulta.getProduto().getEstilo());
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCor())) {
                                        query.setParameter("tipoCor", parametrosConsulta.getProduto().getCor());
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getGenero())) {
                                        query.setParameter("tipoGenero", parametrosConsulta.getProduto().getGenero());
                                }
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getMarca())) {
                                query.setParameter("sequencialMarcaDoModelo", parametrosConsulta.getMarca().getSequencial());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
                                query.setParameter("sequencialModelo", parametrosConsulta.getModelo().getSequencial());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getFornecedor())) {
                                query.setParameter("fornecedor", parametrosConsulta.getFornecedor());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getVendedor())) {
                                query.setParameter("vendedor", parametrosConsulta.getVendedor());
                        }

                        /*if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSomenteParaComprar())) {
                                query.setParameter("quantidadeMinimaComprar", parametrosConsulta.getQuantidadeMinimaComprar());
                        }*/

                        /*if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getTipoOrdenacao())) {
                                if (!parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.DATA.getValor())) {
                                        query.setParameter("dataDoisMesesAnterior", DataUtils.acrescentarMeses(DataUtils.getDataComHorarioMinimo(DataUtils.getDataAtual()), -2));
                                }
                        }*/


                        return query.getResultList();
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
       
        @Override
        public List<RankingProdutoDTONovo> consultarProdutosVendidosDTO(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT new br.com.ec.domain.dto.RankingProdutoDTO(l.produto, SUM(l.valorVenda), SUM(l.valorCompra), SUM(l.valorVarejo - l.valorVenda), COUNT(l.produto), MAX(l.venda.dataVenda)");
                sql.append(adicionarEstoque(parametrosConsulta));
                sql.append(adicionarSolicitacaoCompraProduto());
                sql.append(") FROM Lancamento l ");
                sql.append("WHERE l.venda.dataVenda >= :dataInicial AND l.venda.dataVenda <= :dataFinal ");
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
                        sql.append("AND l.venda.loja.sequencial = :sequencialLoja ");
                }
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
                        sql.append("AND l.produto.tipo = :tipoProduto ");
                }
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getProduto())) {
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCodigo())) {
                                sql.append("AND l.produto.codigo = :codigo ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getDescricao())) {
                                sql.append("AND ");
                                sql.append(sqlConsultarSemAcento("l.produto.descricao"));
                                sql.append(" like upper(:descricao) ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getEstilo())) {
                                sql.append("AND l.produto.estilo = :tipoEstilo ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCor())) {
                                sql.append("AND l.produto.cor = :tipoCor ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getGenero())) {
                                sql.append("AND l.produto.genero = :tipoGenero ");
                        }
                }
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getMarca())) {
                        sql.append("AND l.produto.modelo.marca.sequencial = :sequencialMarcaDoModelo ");
                }
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
                        sql.append("AND l.produto.modelo.sequencial = :sequencialModelo ");
                }
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getFornecedor())) {
                        sql.append("AND :fornecedor in (SELECT fp.fornecedor FROM FornecedorProduto fp WHERE fp.produto.sequencial = l.produto.sequencial) ");
                }
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getVendedor())) {
                        sql.append("AND l.venda.vendedor = :vendedor ");
                }
               
                sql.append("GROUP BY l.produto ");
                sql.append("ORDER BY COUNT(l.produto) DESC ");
                try {
                        TypedQuery<RankingProdutoDTONovo> query = getEntityManager().createQuery(sql.toString(), RankingProdutoDTONovo.class)
                                        .setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial()))
                                        .setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal()));
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getQuantidadeProdutos())) {
                                query.setMaxResults(parametrosConsulta.getQuantidadeProdutos());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
                                query.setParameter("sequencialLoja", parametrosConsulta.getLoja().getSequencial());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
                                query.setParameter("tipoProduto", parametrosConsulta.getTipoProduto());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getProduto())) {
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCodigo())) {
                                        query.setParameter("codigo", parametrosConsulta.getProduto().getCodigoProdutoPadrao());
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getDescricao())) {
                                        query.setParameter("descricao", "%" + removerAcentuacao(parametrosConsulta.getProduto().getDescricao()) + "%");
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getEstilo())) {
                                        query.setParameter("tipoEstilo", parametrosConsulta.getProduto().getEstilo());
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCor())) {
                                        query.setParameter("tipoCor", parametrosConsulta.getProduto().getCor());
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getGenero())) {
                                        query.setParameter("tipoGenero", parametrosConsulta.getProduto().getGenero());
                                }
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getMarca())) {
                                query.setParameter("sequencialMarcaDoModelo", parametrosConsulta.getMarca().getSequencial());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
                                query.setParameter("sequencialModelo", parametrosConsulta.getModelo().getSequencial());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getFornecedor())) {
                                query.setParameter("fornecedor", parametrosConsulta.getFornecedor());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getVendedor())) {
                                query.setParameter("vendedor", parametrosConsulta.getVendedor());
                        }

                        /*if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSomenteParaComprar())) {
                                query.setParameter("quantidadeMinimaComprar", parametrosConsulta.getQuantidadeMinimaComprar());
                        }*/

                        /*if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getTipoOrdenacao())) {
                                if (!parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.DATA.getValor())) {
                                        query.setParameter("dataDoisMesesAnterior", DataUtils.acrescentarMeses(DataUtils.getDataComHorarioMinimo(DataUtils.getDataAtual()), -2));
                                }
                        }*/


                        return query.getResultList();
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
       
        @Override
        public VendaDTO detalharPorSequencial(Long sequencialVenda) {
                StringBuilder jpql = new StringBuilder();
                jpql.append("SELECT new br.com.ec.domain.dto.VendaDTO(");
                jpql.append(VendaDTO.CONSULTA_DTO_SIMPLES);
                jpql.append(") FROM Venda e ");
                jpql.append("WHERE e.sequencial = :sequencialVenda ");
                try {
                        return getEntityManager().createQuery(jpql.toString(), VendaDTO.class)
                                        .setParameter("sequencialVenda", sequencialVenda)
                                        .getSingleResult();
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
       
        /*
        @Override
        public List<RankingProdutoDTO> consultarProdutosVendidosResumido(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT CAST(l.seq_produto AS VARCHAR), COUNT(l.seq_produto) ");
                sql.append(adicionarEstoqueSqlNativo(parametrosConsulta));
                sql.append(" FROM sc_sec.sec_lancamento l ");
                sql.append("LEFT JOIN sc_sec.sec_venda v ON v.seq_venda = l.seq_venda ");
                sql.append("LEFT JOIN sc_sec.sec_loja lj ON v.seq_loja = lj.seq_loja ");
                sql.append("LEFT JOIN sc_sec.sec_produto p ON p.seq_produto = l.seq_produto ");
                sql.append("LEFT JOIN sc_sec.sec_modelo m ON m.seq_modelo = p.seq_modelo ");
                sql.append("LEFT JOIN sc_sec.sec_marca ma ON ma.seq_marca = m.seq_marca ");
                sql.append("WHERE v.dth_venda >= :dataInicial AND v.dth_venda <= :dataFinal ");
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
                        sql.append("AND lj.seq_loja = :sequencialLoja ");
                }
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
                        sql.append("AND p.tip_produto = :tipoProduto ");
                }
               
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getProduto())) {
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getSequencial())) {
                                sql.append("AND p.seq_produto = :sequencialProduto ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCodigo())) {
                                sql.append("AND p.cod_produto = :codigo ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getDescricao())) {
                                sql.append("AND ");
                                sql.append(sqlConsultarSemAcento("p.dsc_produto"));
                                sql.append(" like upper(:descricao) ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getEstilo())) {
                                sql.append("AND p.tip_estilo = :tipoEstilo ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCor())) {
                                sql.append("AND p.tip_cor = :tipoCor ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getGenero())) {
                                sql.append("AND p.tip_genero = :tipoGenero ");
                        }
                }
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getMarca())) {
                        sql.append("AND ma.seq_marcal = :sequencialMarcaDoModelo ");
                }
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
                        sql.append("AND m.seq_modelo = :sequencialModelo ");
                }
               
                sql.append("GROUP BY l.seq_produto ");
//              if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.QUANTIDADE.getValor())) {
//                      sql.append("ORDER BY COUNT(l.seq_produto) DESC ");
//              }
                try {
                        Query query = getEntityManager().createNativeQuery(sql.toString())
                                        .setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial()))
                                        .setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal()));
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getPrimeiroRegistro())) {
                                if (parametrosConsulta.getPrimeiroRegistro() > 0) {
                                        query.setFirstResult(parametrosConsulta.getPrimeiroRegistro());
                                }
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTamanhoPagina())) {
                                if (parametrosConsulta.getTamanhoPagina() > 0) {
                                        query.setMaxResults(parametrosConsulta.getTamanhoPagina());
                                } else {
                                        query.setMaxResults(parametrosConsulta.getQuantidadeProdutos());
                                }
                        } else {
                                query.setMaxResults(parametrosConsulta.getQuantidadeProdutos());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
                                query.setParameter("sequencialLoja", parametrosConsulta.getLoja().getSequencial());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
                                query.setParameter("tipoProduto", parametrosConsulta.getTipoProduto());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getProduto())) {
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getSequencial())) {
                                        query.setParameter("sequencialProduto", parametrosConsulta.getProduto().getSequencial());
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCodigo())) {
                                        query.setParameter("codigo", parametrosConsulta.getProduto().getCodigoProdutoPadrao());
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getDescricao())) {
                                        query.setParameter("descricao", "%" + removerAcentuacao(parametrosConsulta.getProduto().getDescricao()) + "%");
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getEstilo())) {
                                        query.setParameter("tipoEstilo", parametrosConsulta.getProduto().getEstilo());
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCor())) {
                                        query.setParameter("tipoCor", parametrosConsulta.getProduto().getCor());
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getGenero())) {
                                        query.setParameter("tipoGenero", parametrosConsulta.getProduto().getGenero());
                                }
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getMarca())) {
                                query.setParameter("sequencialMarcaDoModelo", parametrosConsulta.getMarca().getSequencial());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
                                query.setParameter("sequencialModelo", parametrosConsulta.getModelo().getSequencial());
                        }
                        List<Object[]> resultList = query.getResultList();
                        List<RankingProdutoDTO> produtos = new ArrayList<RankingProdutoDTO>();
                        for (Object[] objects : resultList) {
                                RankingProdutoDTO rankingProduto = new RankingProdutoDTO();
                                Produto produto = new Produto();
                                if (VerificadorUtil.naoEstaNulo(objects[0])) {
                                        produto.setSequencial(Long.parseLong(objects[0].toString()));
                                }
                                rankingProduto.setProduto(produto);
                                if (VerificadorUtil.naoEstaNulo(objects[1])) {
                                        rankingProduto.setQuantidadeVendas(Long.parseLong(objects[1].toString()));
                                }
                                if (VerificadorUtil.naoEstaNulo(objects[2])) {
                                        rankingProduto.setQuantidadeEstoque(Long.parseLong(objects[2].toString()));
                                }
                                produtos.add(rankingProduto);
                        }
                        return produtos;
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
       
        @Override
        public List<RankingProdutoDTO> consultarProdutosParaTransferir(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT CAST(l.seq_produto AS VARCHAR) AS produto, COUNT(l.seq_produto) AS vendas ");
                sql.append(" FROM sc_sec.sec_lancamento l ");
                sql.append("LEFT JOIN sc_sec.sec_venda v ON v.seq_venda = l.seq_venda ");
                sql.append("LEFT JOIN sc_sec.sec_loja lj ON v.seq_loja = lj.seq_loja ");
                sql.append("LEFT JOIN sc_sec.sec_produto p ON p.seq_produto = l.seq_produto ");
                sql.append("LEFT JOIN sc_sec.sec_modelo m ON m.seq_modelo = p.seq_modelo ");
                sql.append("LEFT JOIN sc_sec.sec_marca ma ON ma.seq_marca = m.seq_marca ");
                sql.append("WHERE ");
                sql.append(adicionarParametrosSqlNativo(parametrosConsulta));
                sql.append("GROUP BY l.seq_produto, ma.dsc_marca, m.dsc_modelo ");
                sql.append("HAVING ");
                for (Loja loja : parametrosConsulta.getLojasParaConsulta()) {
                        sql.append(adicionarHavingSqlNativo(parametrosConsulta, loja.getSequencial()));
                        sql.append(" OR ");
                }
                sql.append(" (SELECT SUM(pl.qtd_estoque) AS estoque FROM sc_sec.sec_produto_loja pl WHERE pl.seq_produto = l.seq_produto AND pl.seq_loja in (");
                for (Loja loja : parametrosConsulta.getLojasParaConsulta()) {
                        sql.append(" ").append(loja.getSequencial()).append(", ");
                }
                sql.deleteCharAt(sql.length()-1);
                sql.deleteCharAt(sql.length()-1);
                sql.append(" )) = 0 ");
                sql.append("ORDER BY ma.dsc_marca, m.dsc_modelo ");
                try {
                        Query query = getEntityManager().createNativeQuery(sql.toString())
                                        .setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial()))
                                        .setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal()));
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getPrimeiroRegistro())) {
                                if (parametrosConsulta.getPrimeiroRegistro() > 0) {
                                        query.setFirstResult(parametrosConsulta.getPrimeiroRegistro());
                                }
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTamanhoPagina())) {
                                if (parametrosConsulta.getTamanhoPagina() > 0) {
                                        query.setMaxResults(parametrosConsulta.getTamanhoPagina());
                                } else {
                                        query.setMaxResults(parametrosConsulta.getQuantidadeProdutos());
                                }
                        } else {
                                query.setMaxResults(parametrosConsulta.getQuantidadeProdutos());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
                                query.setParameter("sequencialLoja", parametrosConsulta.getLoja().getSequencial());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
                                query.setParameter("tipoProduto", parametrosConsulta.getTipoProduto());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getProduto())) {
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getSequencial())) {
                                        query.setParameter("sequencialProduto", parametrosConsulta.getProduto().getSequencial());
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCodigo())) {
                                        query.setParameter("codigo", parametrosConsulta.getProduto().getCodigoProdutoPadrao());
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getDescricao())) {
                                        query.setParameter("descricao", "%" + removerAcentuacao(parametrosConsulta.getProduto().getDescricao()) + "%");
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getEstilo())) {
                                        query.setParameter("tipoEstilo", parametrosConsulta.getProduto().getEstilo());
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCor())) {
                                        query.setParameter("tipoCor", parametrosConsulta.getProduto().getCor());
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getGenero())) {
                                        query.setParameter("tipoGenero", parametrosConsulta.getProduto().getGenero());
                                }
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getMarca())) {
                                query.setParameter("sequencialMarcaDoModelo", parametrosConsulta.getMarca().getSequencial());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
                                query.setParameter("sequencialModelo", parametrosConsulta.getModelo().getSequencial());
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getIndicadorModeloFavorito())) {
                                query.setParameter("indicadorModeloFavorito", parametrosConsulta.getIndicadorModeloFavorito());
                        }
                        List<Object[]> resultList = query.getResultList();
                        List<RankingProdutoDTO> produtos = new ArrayList<RankingProdutoDTO>();
                        for (Object[] objects : resultList) {
                                RankingProdutoDTO rankingProduto = new RankingProdutoDTO();
                                Produto produto = new Produto();
                                if (VerificadorUtil.naoEstaNulo(objects[0])) {
                                        System.out.println(objects[0].toString());
                                        produto.setSequencial(Long.parseLong(objects[0].toString()));
                                }
                                rankingProduto.setProduto(produto);
                                produtos.add(rankingProduto);
                        }
                        return produtos;
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
       
        private String adicionarVendasSqlNativo(ParametrosConsultaProdutosVendidosDTO parametrosConsulta, Long sequencialLoja) {
                StringBuilder sql = new StringBuilder("");
                sql.append(", (SELECT COUNT(lanc.seq_produto) FROM sc_sec.sec_lancamento lanc ");
                sql.append("LEFT JOIN sc_sec.sec_venda v ON v.seq_venda = lanc.seq_venda ");
                sql.append("LEFT JOIN sc_sec.sec_loja lj ON v.seq_loja = lj.seq_loja ");
                sql.append("WHERE v.dth_venda >= :dataInicial AND v.dth_venda <= :dataFinal ");
                sql.append("AND lanc.seq_produto = l.seq_produto AND lj.seq_loja = ");
                sql.append(sequencialLoja);
                sql.append(" GROUP BY lanc.seq_produto) AS vendas" + sequencialLoja + " ");
                return sql.toString();
        }
       
        private String adicionarEstoqueSqlNativo(ParametrosConsultaProdutosVendidosDTO parametrosConsulta, Long sequencialLoja) {
                StringBuilder sql = new StringBuilder();
                sql.append(", (SELECT SUM(pl.qtd_estoque) FROM sc_sec.sec_produto_loja pl ");
                sql.append("WHERE pl.seq_produto = l.seq_produto ");
                sql.append("AND pl.seq_loja = ");
                sql.append(sequencialLoja);
                sql.append(") AS estoque" + sequencialLoja + " ");
                return sql.toString();
        }
       
        private String adicionarHavingSqlNativo(ParametrosConsultaProdutosVendidosDTO parametrosConsulta, Long sequencialLoja) {
                StringBuilder sql = new StringBuilder();
                sql.append("((SELECT SUM(pl.qtd_estoque) AS estoque FROM sc_sec.sec_produto_loja pl WHERE pl.seq_produto = l.seq_produto AND pl.seq_loja = ");
                sql.append(sequencialLoja);
                sql.append(") - (");
                sql.append("SELECT COUNT(lanc.seq_produto) FROM sc_sec.sec_lancamento lanc ");
                sql.append("LEFT JOIN sc_sec.sec_venda v ON v.seq_venda = lanc.seq_venda ");
                sql.append("LEFT JOIN sc_sec.sec_loja lj ON v.seq_loja = lj.seq_loja ");
                sql.append("WHERE v.dth_venda >= :dataInicial AND v.dth_venda <= :dataFinal AND lanc.seq_produto = l.seq_produto ");
                sql.append("AND lj.seq_loja = ");
                sql.append(sequencialLoja);
                sql.append(" GROUP BY lanc.seq_produto) ");
                sql.append("* 1) * -1 > 0 ");
                return sql.toString();
        }
       
        private String adicionarEstoqueSqlNativo(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
                StringBuilder sql = new StringBuilder();
                sql.append(", (");
                sql.append("SELECT SUM(pl.qtd_estoque) FROM sc_sec.sec_produto_loja pl ");
                sql.append("WHERE pl.seq_produto = l.seq_produto ");
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
                        sql.append("AND pl.seq_loja = :sequencialLoja ");
                }
                sql.append(") ");
                return sql.toString();
        }

        private String adicionarParametrosSqlNativo(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
                StringBuilder sql = new StringBuilder("v.dth_venda >= :dataInicial AND v.dth_venda <= :dataFinal ");
               
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLojaSelecionada()) &&
                                VerificadorUtil.naoEstaNulo(parametrosConsulta.getEstoqueMinimo())) {
                        sql.append("AND (");
                        sql.append("SELECT SUM(pl.qtd_estoque) FROM sc_sec.sec_produto_loja pl ");
                        sql.append("WHERE pl.seq_produto = l.seq_produto ");
                        sql.append("AND pl.seq_loja = ");
                        sql.append(parametrosConsulta.getLojaSelecionada().getSequencial());
                        sql.append(") >= ");
                        sql.append(parametrosConsulta.getEstoqueMinimo());
                        sql.append(" ");
                }
               
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
                        sql.append("AND lj.seq_loja = :sequencialLoja ");
                }
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
                        sql.append("AND p.tip_produto = :tipoProduto ");
                }
               
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getProduto())) {
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getSequencial())) {
                                sql.append("AND p.seq_produto = :sequencialProduto ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCodigo())) {
                                sql.append("AND p.cod_produto = :codigo ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getDescricao())) {
                                sql.append("AND ");
                                sql.append(sqlConsultarSemAcento("p.dsc_produto"));
                                sql.append(" like upper(:descricao) ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getEstilo())) {
                                sql.append("AND p.tip_estilo = :tipoEstilo ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCor())) {
                                sql.append("AND p.tip_cor = :tipoCor ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getGenero())) {
                                sql.append("AND p.tip_genero = :tipoGenero ");
                        }
                }
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getMarca())) {
                        sql.append("AND ma.seq_marcal = :sequencialMarcaDoModelo ");
                }
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
                        sql.append("AND m.seq_modelo = :sequencialModelo ");
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getIndicadorModeloFavorito())) {
                        sql.append("AND m.ind_favorito = :indicadorModeloFavorito ");
                }
                return sql.toString();
        }

        @Override
        public List<RankingProdutoDTO> consultarProdutosMaisVendidos(Date dataInicial, Date dataFinal, Integer quantidadeProdutos, String tipoOrdenacao, Long sequencialLoja, String tipoProduto,
                        Produto produto, Marca marca) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT new br.com.ec.domain.dto.RankingProdutoDTO(l.produto, SUM(l.valorVenda), SUM(l.valorCompra), SUM(l.valorVarejo - l.valorVenda), COUNT(l.produto)) FROM Lancamento l ");
                sql.append("WHERE l.venda.dataVenda >= :dataInicial AND l.venda.dataVenda <= :dataFinal ");
                if (VerificadorUtil.naoEstaNulo(sequencialLoja)) {
                        sql.append("AND l.venda.loja.sequencial = :sequencialLoja ");
                }
                if (VerificadorUtil.naoEstaNulo(tipoProduto)) {
                        sql.append("AND l.produto.tipo = :tipoProduto ");
                }
                if (VerificadorUtil.naoEstaNulo(produto)) {
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getCodigo())) {
                                sql.append("AND l.produto.codigo = :codigo ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getDescricao())) {
                                sql.append("AND ");
                                sql.append(sqlConsultarSemAcento("l.produto.descricao"));
                                sql.append(" like upper(:descricao) ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getEstilo())) {
                                sql.append("AND l.produto.estilo = :tipoEstilo ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getGenero())) {
                                sql.append("AND l.produto.genero = :tipoGenero ");
                        }
                }
                if (VerificadorUtil.naoEstaNulo(marca)) {
                        sql.append("AND l.produto.modelo.marca.sequencial = :sequencialMarcaDoModelo ");
                }
               
                sql.append("GROUP BY l.produto ");
                if (tipoOrdenacao.equals(TipoOrdenacaoMaisVendidos.LUCRO.getValor())) {
                        sql.append("ORDER BY SUM(l.valorVenda - l.valorCompra) DESC ");
                } else if (tipoOrdenacao.equals(TipoOrdenacaoMaisVendidos.QUANTIDADE.getValor())) {
                        sql.append("ORDER BY COUNT(l.produto) DESC ");
                } else if (tipoOrdenacao.equals(TipoOrdenacaoMaisVendidos.VALOR_VENDIDO.getValor())) {
                        sql.append("ORDER BY SUM(l.valorVenda) DESC ");
                }
                try {
                        TypedQuery<RankingProdutoDTO> query = getEntityManager().createQuery(sql.toString(), RankingProdutoDTO.class)
                                        .setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(dataInicial))
                                        .setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(dataFinal))
                                        .setMaxResults(quantidadeProdutos);
                        if (VerificadorUtil.naoEstaNulo(sequencialLoja)) {
                                query.setParameter("sequencialLoja", sequencialLoja);
                        }
                        if (VerificadorUtil.naoEstaNulo(tipoProduto)) {
                                query.setParameter("tipoProduto", tipoProduto);
                        }
                        if (VerificadorUtil.naoEstaNulo(produto)) {
                                if (VerificadorUtil.naoEstaNuloOuVazio(produto.getCodigo())) {
                                        query.setParameter("codigo", produto.getCodigoProdutoPadrao());
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(produto.getDescricao())) {
                                        query.setParameter("descricao", "%" + removerAcentuacao(produto.getDescricao()) + "%");
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(produto.getEstilo())) {
                                        query.setParameter("tipoEstilo", produto.getEstilo());
                                }
                                if (VerificadorUtil.naoEstaNuloOuVazio(produto.getGenero())) {
                                        query.setParameter("tipoGenero", produto.getGenero());
                                }
                        }
                        if (VerificadorUtil.naoEstaNulo(marca)) {
                                query.setParameter("sequencialMarcaDoModelo", marca.getSequencial());
                        }
                        return query.getResultList();
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
       
        private String adicionarQueryConsultaDoEstoque(Long sequencialLoja, Modelo modelo, String tipoProduto, String estiloProduto) {
                try {
                        TypedQuery<Long> query = getEntityManager().createQuery(sql.toString(), Long.class);
                        if (VerificadorUtil.naoEstaNuloOuVazio(sequencialLoja)) {
                                query.setParameter("sequencialLoja", sequencialLoja);
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(tipoProduto)) {
                                query.setParameter("tipoProduto", tipoProduto);
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(estiloProduto)) {
                                query.setParameter("estiloProduto", estiloProduto);
                        }
//                              if (VerificadorUtil.naoEstaNuloOuVazio(genero)) {
//                                      query.setParameter("tipoGenero", genero);
//                              }
                        query.setParameter("sequencialModelo", modelo.getSequencial());
//                              if (VerificadorUtil.naoEstaNuloOuVazio(descricaoProduto)) {
//                                      query.setParameter("descricaoProduto", "%" + removerAcentuacao(descricaoProduto) + "%");
//                              }
                        return sql.toString();
        }
*/

/*
        @Override
        public List<VendasDTO> consultarVendas(ParametrosConsultaVendasDTO parametrosConsultaVendasDTO) {
                StringBuilder sql = new StringBuilder();
                try {
                        sql.append("SELECT ");
                        sql.append("v.seq_venda, ");
                        sql.append("l.dsc_loja, v.dth_venda, ");
                        sql.append("(SELECT SUM(lc.val_venda) FROM sc_sec.sec_lancamento lc WHERE lc.seq_venda = v.seq_venda AND lc.ind_ativo = true), ");
                        sql.append("v.tip_situacao, ");
                        sql.append("us.dsc_nome, v.dsc_observacao, ");
                        sql.append("p.cod_produto, m.dsc_modelo, p.dsc_produto, lanc.val_venda ");
                        sql.append("FROM sc_sec.sec_venda v ");
                        sql.append("LEFT JOIN sc_sec.sec_loja l ON l.seq_loja = v.seq_loja ");
                        sql.append("LEFT JOIN sc_sec.sec_vendedor ve ON ve.seq_vendedor = v.seq_vendedor ");
                        sql.append("LEFT JOIN sc_sec.sec_usuario us ON us.seq_pessoa = ve.seq_pessoa ");
                        sql.append("LEFT JOIN sc_sec.sec_lancamento lanc ON lanc.seq_venda = v.seq_venda ");
                        sql.append("LEFT JOIN sc_sec.sec_produto p ON p.seq_produto = lanc.seq_produto ");
                        sql.append("LEFT JOIN sc_sec.sec_modelo m ON m.seq_modelo = p.seq_modelo ");
                        sql.append("WHERE 1=1 ");
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getLoja())) {
                                sql.append("AND l.seq_loja.sequencial = :sequencialLoja ");
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getSituacaoVenda())) {
                                sql.append("AND v.tip_situacao = :tipoSituacao ");
                        }
//                      if (VerificadorUtil.naoEstaNuloOuVazio(((ParametrosConsultaVendasDTO)parametros).getVendedor())) {
//                              sql.append("AND e.vendedor.sequencial = :sequencialVendedor ");
//                      }
//                      if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getIndicacao())) {
//                              sql.append("AND e.indicacao.sequencial = :sequencialIndicacao ");
//                      }
*/

                        //TODO: VERIFICAR LANÇAMENTOS COM MAIS PAGAMENTOS QUE LANÇAMENTOS
                        /*
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getSituacaoFinanceiraVenda())) {
                                if (parametrosConsultaVendasDTO.getSituacaoFinanceiraVenda().equals(br.com.ec.domain.model.tipos.TipoSituacaoFinanceira.NENHUMA.getValor())) {
                                        sql.append("AND (SELECT COUNT(c) FROM Conta c WHERE c.venda = e) = 0 ");
//                                              sql.append("AND ((SELECT COUNT(vf) FROM VendaFormaPagamento vf WHERE vf.venda = e) > (SELECT COUNT(cr) FROM ContaAReceber cr WHERE cr.venda = e)) ");
                                }
                                if (parametrosConsultaVendasDTO.getSituacaoFinanceiraVenda().equals(br.com.ec.domain.model.tipos.TipoSituacaoFinanceira.QUITADO.getValor())) {
                                        sql.append("AND (SELECT COUNT(p) FROM Parcela p WHERE p.conta.venda = e AND p.dataPagamento is null AND p.indicadorAtivo = true) = 0 ");
                                        sql.append("AND (SELECT COUNT(c) FROM Conta c WHERE c.venda = e AND c.indicadorAtivo = true) > 0 ");
                                }
                                if (parametrosConsultaVendasDTO.getSituacaoFinanceiraVenda().equals(br.com.ec.domain.model.tipos.TipoSituacaoFinanceira.PENDENCIAS.getValor())) {
                                        sql.append("AND ((SELECT COUNT(p) FROM Parcela p WHERE p.conta.venda = e AND p.dataPagamento is null AND p.indicadorAtivo = true) > 0 ");
                                        sql.append("OR (SELECT COUNT(c) FROM Conta c WHERE c.venda = e AND c.indicadorAtivo = true) = 0) ");
                                }
                        }
                        */

/*     
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getDataVendas())
                                        || VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getDataInicial())
                                        || VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getDataFinal())) {
                                sql.append("AND v.dth_venda >= :dataInicial ");
                                sql.append("AND v.dth_venda <= :dataFinal ");
                        }
                       
                        sql.append("ORDER BY v.seq_venda ");
                       
                        Query query = getEntityManager().createNativeQuery(sql.toString());
                       
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getLoja())) {
                                query.setParameter("sequencialLoja", parametrosConsultaVendasDTO.getLoja().getSequencial());
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getSituacaoVenda())) {
                                query.setParameter("tipoSituacao", parametrosConsultaVendasDTO.getSituacaoVenda());
                        }
//                      if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getVendedor())) {
//                              query.setParameter("sequencialVendedor", parametrosConsultaVendasDTO.getVendedor().getSequencial());
//                      }
//                      if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getIndicacao())) {
//                              query.setParameter("sequencialIndicacao", ((ParametrosConsultaVendasDTO)parametros).getIndicacao().getSequencial());
//                      }
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getDataInicial())
                                        && VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getDataFinal())) {
                                Date dataInicial = DataUtils.getDataComHorarioMinimo(parametrosConsultaVendasDTO.getDataInicial());
                                Date dataFinal = DataUtils.getDataComHorarioMaximo(parametrosConsultaVendasDTO.getDataFinal());
                                query.setParameter("dataInicial", dataInicial);
                                query.setParameter("dataFinal", dataFinal);
                        } else if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getDataVendas())) {
                                Date dataInicial = DataUtils.getDataComHorarioMinimo(parametrosConsultaVendasDTO.getDataVendas());
                                Date dataFinal = DataUtils.getDataComHorarioMaximo(parametrosConsultaVendasDTO.getDataVendas());
                                query.setParameter("dataInicial", dataInicial);
                                query.setParameter("dataFinal", dataFinal);
                        }
                       
                        List<Object[]> resultList = query.getResultList();
                       
                        List<VendasDTO> vendas = new ArrayList<VendasDTO>();
               
                        // PREENCHER VENDAS
                        for (Object[] objects : resultList) {
                                VendasDTO venda = new VendasDTO();
                                venda.setSequencial(Long.parseLong(objects[0].toString()));
                                if (!vendas.contains(venda)) {
                                        venda.setDescricaoLoja(objects[1].toString());
//                                      System.out.println(objects[2].toString());
//                                      venda.setDataVenda(new Date(objects[2].toString()));
                                        venda.setValorVenda(Double.parseDouble(objects[3].toString()));
                                        venda.setTipoSituacao(objects[4].toString());
                                        venda.setNomeUsuario(objects[5].toString());
                                        venda.setObservacao(objects[6].toString());
                                        vendas.add(venda);
                                }
                        }
                       
                        for (Object[] objects : resultList) {
                                VendasDTO venda = new VendasDTO();
                                venda.setSequencial(Long.parseLong(objects[0].toString()));
                               
                                VendasLancamentoDTO lancamento = new VendasLancamentoDTO();
                                lancamento.setCodigoProduto(objects[7].toString());
                                if (VerificadorUtil.naoEstaNulo(objects[8])) {
                                        lancamento.setDescricaoModelo(objects[8].toString());
                                }
                                lancamento.setDescricaoProduto(objects[9].toString());
                                lancamento.setValorVenda(Double.parseDouble(objects[10].toString()));
                               
                                VendasDTO vendaCompleta = vendas.get(vendas.indexOf(venda));
                                vendaCompleta.getLancamentos().add(lancamento);
                                vendas.remove(vendas.indexOf(venda));
                                vendas.add(vendaCompleta);
                        }
                        return vendas;
                } catch (NoResultException e) {
                        return null;
                }
        }
       
        @Override
        public Integer obterQuantidadeProdutosVendidosPorEstiloEeGenero(Date dataInicial, Date dataFinal, Long sequencialLoja, Long sequencialModelo, String tipoProduto, String estiloProduto, String tipoGenero) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT COUNT(l) FROM Lancamento l ");
                sql.append("WHERE l.venda.dataVenda >= :dataInicial AND l.venda.dataVenda <= :dataFinal ");
                if (VerificadorUtil.naoEstaNulo(sequencialLoja)) {
                        sql.append("AND l.venda.loja.sequencial = :sequencialLoja ");
                }
                if (VerificadorUtil.naoEstaNulo(sequencialModelo)) {
                        sql.append("AND l.produto.modelo.sequencial = :sequencialModelo ");
                }
                if (VerificadorUtil.naoEstaNulo(tipoProduto)) {
                        sql.append("AND l.produto.tipo = :tipoProduto ");
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(estiloProduto)) {
                        sql.append("AND l.produto.estilo = :tipoEstilo ");
                }
                if (VerificadorUtil.naoEstaNuloOuVazio(tipoGenero)) {
                        sql.append("AND l.produto.genero = :tipoGenero ");
                }
*/
             
                /*sql.append("GROUP BY l.produto.estilo ");*/
/*     
                try {
                        TypedQuery<Long> query = getEntityManager().createQuery(sql.toString(), Long.class)
                                        .setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(dataInicial))
                                        .setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(dataFinal));
                        if (VerificadorUtil.naoEstaNulo(sequencialLoja)) {
                                query.setParameter("sequencialLoja", sequencialLoja);
                        }
                        if (VerificadorUtil.naoEstaNulo(sequencialModelo)) {
                                query.setParameter("sequencialModelo", sequencialModelo);
                        }
                        if (VerificadorUtil.naoEstaNulo(tipoProduto)) {
                                query.setParameter("tipoProduto", tipoProduto);
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(estiloProduto)) {
                                query.setParameter("tipoEstilo", estiloProduto);
                        }
                        if (VerificadorUtil.naoEstaNuloOuVazio(tipoGenero)) {
                                query.setParameter("tipoGenero", tipoGenero);
                        }
                        return query.getSingleResult().intValue();
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
*/
     
        /*
        @Override
        public RankingComprasTransferenciasEstiloDTO consultarVendasPorEstilo(ParametrosConsultaParaComprasTransferenciasDTO parametrosConsulta, Modelo modelo) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT new br.com.ec.domain.dto.RankingComprasTransferenciasEstiloDTO(");
                sql.append("l.produto.estilo");
                sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, null) + ")");
                sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.UNISSEX.getValor()) + ")");
                sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.MASCULINO.getValor()) + ")");
                sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.FEMININO.getValor()) + ")");
                sql.append(", COUNT(0), COUNT(0), COUNT(0), COUNT(0)");
                sql.append(") FROM Lancamento l ");
                sql.append("WHERE l.venda.dataVenda >= :dataInicial AND l.venda.dataVenda <= :dataFinal ");
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
                        sql.append("AND l.venda.loja.sequencial = :sequencialLoja ");
                }
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
                        sql.append("AND l.produto.tipo = :tipoProduto ");
                }
                sql.append("AND l.produto.modelo = :modelo ");
                sql.append("AND l.produto.estilo = :estiloProduto ");
                sql.append("GROUP BY l.produto.estilo ");
                try {
                        TypedQuery<RankingComprasTransferenciasEstiloDTO> query = getEntityManager().createQuery(sql.toString(), RankingComprasTransferenciasEstiloDTO.class)
                                        .setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial()))
                                        .setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal()));
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
                                query.setParameter("sequencialLoja", parametrosConsulta.getSequencialLoja());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
                                query.setParameter("tipoProduto", parametrosConsulta.getTipoProduto());
                        }
                        if (VerificadorUtil.naoEstaNulo(modelo)) {
                                query.setParameter("modelo", modelo);
                        }
                        query.setParameter("estiloProduto", parametrosConsulta.getEstilo());
                        return query.getSingleResult();
                } catch(NoResultException nr) {
                        RankingComprasTransferenciasEstiloDTO rankingComprasTransferenciasEstilo = new RankingComprasTransferenciasEstiloDTO();
                        rankingComprasTransferenciasEstilo.setEstilo(TipoEstiloProduto.parse(parametrosConsulta.getEstilo()));
                        return rankingComprasTransferenciasEstilo;
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
*/

/*
        private String adicionarConsultaQuantidadeVendasPorEstilo(ParametrosConsultaParaComprasTransferenciasDTO parametrosConsulta, String genero, Boolean consultarPorLoja) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT COUNT(lanc) FROM Lancamento lanc ");
                sql.append("WHERE lanc.venda.dataVenda >= :dataInicial AND lanc.venda.dataVenda <= :dataFinal ");
                sql.append("AND lanc.produto.modelo = :modelo ");
                sql.append("AND lanc.produto.estilo = :estiloProduto ");
                if (consultarPorLoja) {
                        sql.append("AND lanc.venda.loja = l ");
                }
                sql.append("AND lanc.produto.genero = '" + genero + "' ");
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
                        sql.append("AND lanc.produto.tipo = :tipoProduto ");
                }
                return sql.toString().trim();
        }
       
        @Override
        public RankingComprasTransferenciasEstiloDTO consultarEstoqueEeVendasPorEstilo(ParametrosConsultaParaComprasTransferenciasDTO parametrosConsulta, Modelo modelo) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT new br.com.ec.domain.dto.RankingComprasTransferenciasEstiloDTO(");
                sql.append("pLoja.produto.estilo");
                sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.UNISSEX.getValor(), false) + ")");
                sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.MASCULINO.getValor(), false) + ")");
                sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.FEMININO.getValor(), false) + ")");
                sql.append(", (" + adicionarConsultaEstoquePorEstilo(parametrosConsulta, TipoGenero.UNISSEX.getValor(), false) + ")");
                sql.append(", (" + adicionarConsultaEstoquePorEstilo(parametrosConsulta, TipoGenero.MASCULINO.getValor(), false) + ")");
                sql.append(", (" + adicionarConsultaEstoquePorEstilo(parametrosConsulta, TipoGenero.FEMININO.getValor(), false) + ")");
                sql.append(", (" + adicionarConsultaPedidosCompraPorEstilo(parametrosConsulta, TipoGenero.UNISSEX.getValor()) + ")");
                sql.append(", (" + adicionarConsultaPedidosCompraPorEstilo(parametrosConsulta, TipoGenero.MASCULINO.getValor()) + ")");
                sql.append(", (" + adicionarConsultaPedidosCompraPorEstilo(parametrosConsulta, TipoGenero.FEMININO.getValor()) + ")");
                // ADICIONAR QUANTIDADE JÁ SOLCITADO PARA COMPRA (VERIFICADO + SOLICITADO)
                sql.append(") FROM ProdutoLoja pLoja ");
                sql.append("WHERE pLoja.produto.estilo = :estiloProduto ");
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
                        sql.append("AND pLoja.loja.sequencialLoja = :sequencialLoja ");
                }
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
                        sql.append("AND pLoja.produto.tipo = :tipoProduto ");
                }
                sql.append("AND pLoja.produto.modelo = :modelo ");
                sql.append("GROUP BY pLoja.produto.estilo ");
                try {
                        TypedQuery<RankingComprasTransferenciasEstiloDTO> query = getEntityManager().createQuery(sql.toString(), RankingComprasTransferenciasEstiloDTO.class);
                        query.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial()));
                        query.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal()));
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
                                query.setParameter("sequencialLoja", parametrosConsulta.getSequencialLoja());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
                                query.setParameter("tipoProduto", parametrosConsulta.getTipoProduto());
                        }
                        if (VerificadorUtil.naoEstaNulo(modelo)) {
                                query.setParameter("modelo", modelo);
                        }
                        query.setParameter("estiloProduto", parametrosConsulta.getEstilo());
                        return query.getSingleResult();
                } catch(NoResultException nr) {
                        RankingComprasTransferenciasEstiloDTO rankingComprasTransferenciasEstilo = new RankingComprasTransferenciasEstiloDTO();
                        rankingComprasTransferenciasEstilo.setEstilo(TipoEstiloProduto.parse(parametrosConsulta.getEstilo()));
                        return rankingComprasTransferenciasEstilo;
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
       
        private String adicionarConsultaEstoquePorEstilo(ParametrosConsultaParaComprasTransferenciasDTO parametrosConsulta, String genero, Boolean consultarPorLoja) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT SUM(pl.quantidadeEstoque) FROM ProdutoLoja pl ");
                sql.append("WHERE pl.produto.modelo = :modelo ");
                sql.append("AND pl.produto.estilo = :estiloProduto ");
                if (consultarPorLoja) {
                        sql.append("AND pl.loja = l ");
                }
                sql.append("AND pl.produto.genero = '" + genero + "' ");
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
                        sql.append("AND pl.produto.tipo = :tipoProduto ");
                }
                return sql.toString().trim();
        }
       
        private String adicionarConsultaPedidosCompraPorEstilo(ParametrosConsultaParaComprasTransferenciasDTO parametrosConsulta, String genero) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT SUM(ppc.quantidadeParaComprar) FROM ProdutoPedidoCompra ppc ");
                sql.append("WHERE ppc.status IN ('" + TipoStatusPedidoCompra.VERIFICADO.getValor() + "','" + TipoStatusPedidoCompra.SOLICITADO.getValor() + "') ");
                sql.append("AND ppc.produto.modelo = :modelo ");
                sql.append("AND ppc.produto.estilo = :estiloProduto ");
                sql.append("AND ppc.produto.genero = '" + genero + "' ");
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
                        sql.append("AND ppc.produto.tipo = :tipoProduto ");
                }
                return sql.toString().trim();
        }
       
        @Override
        public List<RankingComprasTransferenciasEstiloPorLoja> consultarEstoqueEeVendasEstiloPorLoja(ParametrosConsultaParaComprasTransferenciasDTO parametrosConsulta, Modelo modelo) {
                StringBuilder sql = new StringBuilder();
                sql.append("SELECT new br.com.ec.domain.dto.RankingComprasTransferenciasEstiloPorLoja(");
                sql.append("l");
                sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.UNISSEX.getValor(), true) + ")");
                sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.MASCULINO.getValor(), true) + ")");
                sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.FEMININO.getValor(), true) + ")");
                sql.append(", (" + adicionarConsultaEstoquePorEstilo(parametrosConsulta, TipoGenero.UNISSEX.getValor(), true) + ")");
                sql.append(", (" + adicionarConsultaEstoquePorEstilo(parametrosConsulta, TipoGenero.MASCULINO.getValor(), true) + ")");
                sql.append(", (" + adicionarConsultaEstoquePorEstilo(parametrosConsulta, TipoGenero.FEMININO.getValor(), true) + ")");
                sql.append(", " + parametrosConsulta.getQuantidadeMinimaComprar());
                // ADICIONAR QUANTIDADE JÁ SOLICITADO PARA COMPRA (VERIFICADO + SOLICITADO)
                sql.append(") FROM Loja l ");
                sql.append("WHERE l.ativo IS TRUE ");
                sql.append("GROUP BY l, l.ordenador ");
                sql.append("ORDER BY l.ordenador ");
                try {
                        TypedQuery<RankingComprasTransferenciasEstiloPorLoja> query = getEntityManager().createQuery(sql.toString(), RankingComprasTransferenciasEstiloPorLoja.class);
                        query.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial()));
                        query.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal()));
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
                                query.setParameter("sequencialLoja", parametrosConsulta.getSequencialLoja());
                        }
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
                                query.setParameter("tipoProduto", parametrosConsulta.getTipoProduto());
                        }
                        if (VerificadorUtil.naoEstaNulo(modelo)) {
                                query.setParameter("modelo", modelo);
                        }
                        query.setParameter("estiloProduto", parametrosConsulta.getEstilo());
                        return query.getResultList();
                } catch(Exception ex) {
                        ex.printStackTrace();
                        return null;
                }
        }
*/


}