Subversion Repositories Integrator Subversion

Rev

Rev 583 | Rev 611 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
229 espaco 1 
package br.com.ec.repository.jpa;
2 
 
561 blopes 3 
import java.util.ArrayList;
229 espaco 4 
import java.util.Date;
261 espaco 5 
import java.util.List;
229 espaco 6 
 
230 espaco 7 
import javax.persistence.Query;
229 espaco 8 
import javax.persistence.TypedQuery;
9 
 
10 
import org.springframework.stereotype.Repository;
11 
 
12 
import br.com.ec.core.util.DataUtils;
230 espaco 13 
import br.com.ec.core.util.VerificadorUtil;
450 blopes 14 
import br.com.ec.domain.dto.AuditoriaVendaDTO;
261 espaco 15 
import br.com.ec.domain.dto.FormaPagamentoDTO;
264 espaco 16 
import br.com.ec.domain.dto.LojaDTO;
561 blopes 17 
import br.com.ec.domain.dto.ModeloDTO;
18 
import br.com.ec.domain.dto.RankingComprasTransferenciasEstiloDTO;
19 
import br.com.ec.domain.dto.RankingComprasTransferenciasEstiloPorLojaDTO;
20 
import br.com.ec.domain.dto.RankingModeloDTO;
582 blopes 21 
import br.com.ec.domain.dto.RankingProdutoDTO;
583 blopes 22 
import br.com.ec.domain.dto.RankingProdutoDTONovo;
561 blopes 23 
import br.com.ec.domain.dto.consulta.ParametrosConsultaModelosMaisVendidosDTO;
24 
import br.com.ec.domain.dto.consulta.ParametrosConsultaPorPeriodoDTO;
582 blopes 25 
import br.com.ec.domain.dto.consulta.ParametrosConsultaProdutosVendidosDTO;
230 espaco 26 
import br.com.ec.domain.dto.consulta.ParametrosConsultaVendasDTO;
259 espaco 27 
import br.com.ec.domain.model.Venda;
561 blopes 28 
import br.com.ec.domain.model.tipos.TipoEstiloProduto;
29 
import br.com.ec.domain.model.tipos.TipoGenero;
30 
import br.com.ec.domain.model.tipos.TipoOrdenacaoMaisVendidos;
31 
import br.com.ec.domain.model.tipos.TipoProduto;
261 espaco 32 
import br.com.ec.domain.shared.ConstantesSEC;
229 espaco 33 
import br.com.ec.repository.SistemaAbstractRepository;
34 
import br.com.ec.repository.VendaRepository;
35 
 
36 
@Repository
37 
public class VendaRepositoryJpaImpl extends SistemaAbstractRepository<Venda> implements VendaRepository {
38 
 
39 
        @Override
40 
        protected String getColunaOrdenadora() {
41 
                return "dataVenda";
42 
        }
43 
 
44 
        @Override
296 espaco 45 
        public Integer obterQuantidadeDeVendas(ParametrosConsultaVendasDTO parametrosConsultaVendasDTO) {
229 espaco 46 
                StringBuilder sql = new StringBuilder();
296 espaco 47 
                sql.append("SELECT COUNT(*) FROM Venda e ");
230 espaco 48 
                sql.append("WHERE 1=1 ");
49 
                setarStringParametrosConsulta(sql, parametrosConsultaVendasDTO);
229 espaco 50 
                try {
230 espaco 51 
                        TypedQuery<Long> query = getEntityManager().createQuery(sql.toString(), Long.class);
52 
                        setarQueryParametrosConsulta(query, parametrosConsultaVendasDTO);
53 
                        return query.getSingleResult().intValue();
229 espaco 54 
                } catch(Exception ex) {
55 
                        ex.printStackTrace();
56 
                        return null;
57 
                }
58 
        }
59 
 
230 espaco 60 
        @Override
296 espaco 61 
        public Double obterValorTotalBrutoDeVendas(ParametrosConsultaVendasDTO parametrosConsultaVendasDTO) {
230 espaco 62 
                StringBuilder sql = new StringBuilder();
296 espaco 63 
                sql.append("SELECT SUM(l.valorVenda) FROM Venda e ");
64 
                sql.append("LEFT JOIN e.listaLancamentos l ");
230 espaco 65 
                sql.append("WHERE l.ativo IS TRUE ");
66 
                setarStringParametrosConsulta(sql, parametrosConsultaVendasDTO);
67 
                try {
68 
                        TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
69 
                        setarQueryParametrosConsulta(query, parametrosConsultaVendasDTO);
70 
                        Double total = query.getSingleResult();
71 
                        if (VerificadorUtil.estaNulo(total)) {
72 
                                return new Double(0.0);
73 
                        }
74 
                        return total;
75 
                } catch(Exception ex) {
76 
                        ex.printStackTrace();
77 
                        return null;
78 
                }
79 
        }
80 
 
81 
        @Override
82 
        public Double obterValorDeCuponsUtilizadosPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsultaVendasDTO) {
83 
                StringBuilder sql = new StringBuilder();
268 espaco 84 
                sql.append("SELECT SUM(vp.valorPagamento) FROM VendaFormaPagamento vp ");
296 espaco 85 
                sql.append("LEFT JOIN vp.venda e ");
268 espaco 86 
                sql.append("WHERE vp.formaPagamento.codigo = 16 ");
230 espaco 87 
                setarStringParametrosConsulta(sql, parametrosConsultaVendasDTO);
88 
//              parametrosConsulta.setIndicadorComissionado(null);
89 
//              parametrosConsulta.setTipoProduto(null);
90 
                try {
91 
                        TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
92 
                        setarQueryParametrosConsulta(query, parametrosConsultaVendasDTO);
93 
                        Double total = query.getSingleResult();
94 
                        if (VerificadorUtil.estaNulo(total)) {
95 
                                return new Double(0.0);
96 
                        }
97 
                        return total;
98 
                } catch(Exception ex) {
99 
                        ex.printStackTrace();
100 
                        return null;
101 
                }
102 
        }
103 
 
265 espaco 104 
        @Override
105 
        public Double obterValorDeMaquinetasPorPessoa(Long sequencialPessoaMaquineta, Date dataInicio, Date dataFim) {
106 
                StringBuilder sql = new StringBuilder();
268 espaco 107 
                sql.append("SELECT SUM(vp.valorPagamento) FROM VendaFormaPagamento vp ");
296 espaco 108 
                sql.append("LEFT JOIN vp.venda e ");
268 espaco 109 
                sql.append("WHERE vp.formaPagamento.codigo IN :formasDePagamento ");
296 espaco 110 
                sql.append("AND e.maquineta.pessoa.sequencial = :sequencialPessoaMaquineta ");
111 
                sql.append("AND (e.dataVenda BETWEEN :dataInicial AND :dataFinal OR e.dataVenda = :dataInicial OR e.dataVenda = :dataFinal) ");
265 espaco 112 
                try {
113 
                        TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
114 
                        query.setParameter("formasDePagamento", FormaPagamentoDTO.codigosFormasDePagamentoViaCartao());
115 
                        query.setParameter("sequencialPessoaMaquineta", sequencialPessoaMaquineta);
116 
                        query.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(dataInicio));
117 
                        query.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(dataFim));
118 
 
119 
                        Double total = query.getSingleResult();
120 
                        if (VerificadorUtil.estaNulo(total)) {
121 
                                return new Double(0.0);
122 
                        }
123 
                        return total;
124 
                } catch(Exception ex) {
125 
                        ex.printStackTrace();
126 
                        return null;
127 
                }
128 
        }
129 
 
230 espaco 130 
        private void setarStringParametrosConsulta(StringBuilder sql, ParametrosConsultaVendasDTO parametros) {
131 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getSequencialLoja())) {
296 espaco 132 
                        sql.append("AND e.loja.sequencial = :sequencialLoja ");
230 espaco 133 
                }
253 espaco 134 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getTipoSituacaoVenda())) {
296 espaco 135 
                        sql.append("AND e.tipoSituacao = :tipoSituacao ");
230 espaco 136 
                }
264 espaco 137 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getSequencialVendedor())) {
296 espaco 138 
                        sql.append("AND e.vendedor.sequencial = :sequencialVendedor ");
230 espaco 139 
                }
264 espaco 140 
                /*
230 espaco 141 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getIndicacao())) {
142 
                        sql.append("AND e.indicacao.sequencial = :sequencialIndicacao ");
143 
                }
144 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getIndicadorComissionado())) {
145 
                        sql.append("AND l.produto.indicadorComissionado = :indicadorComissionado ");
146 
                }
147 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getTipoProduto())) {
148 
                        sql.append("AND l.produto.tipo = :tipoProduto ");
149 
                }
150 
                //TODO: VERIFICAR LANÇAMENTOS COM MAIS PAGAMENTOS QUE LANÇAMENTOS
151 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getSituacaoFinanceiraVenda())) {
152 
                        if (parametros.getSituacaoFinanceiraVenda().equals(br.com.ec.domain.model.tipos.TipoSituacaoFinanceira.NENHUMA.getValor())) {
153 
                                sql.append("AND (SELECT COUNT(c) FROM Conta c WHERE c.venda = e) = 0 ");
154 
//                                      sql.append("AND ((SELECT COUNT(vf) FROM VendaFormaPagamento vf WHERE vf.venda = e) > (SELECT COUNT(cr) FROM ContaAReceber cr WHERE cr.venda = e)) ");
155 
                        }
156 
                        if (parametros.getSituacaoFinanceiraVenda().equals(br.com.ec.domain.model.tipos.TipoSituacaoFinanceira.QUITADO.getValor())) {
157 
                                sql.append("AND (SELECT COUNT(p) FROM Parcela p WHERE p.conta.venda = e AND p.dataPagamento is null AND p.indicadorAtivo = true) = 0 ");
158 
                                sql.append("AND (SELECT COUNT(c) FROM Conta c WHERE c.venda = e AND c.indicadorAtivo = true) > 0 ");
159 
                        }
160 
                        if (parametros.getSituacaoFinanceiraVenda().equals(br.com.ec.domain.model.tipos.TipoSituacaoFinanceira.PENDENCIAS.getValor())) {
161 
                                sql.append("AND ((SELECT COUNT(p) FROM Parcela p WHERE p.conta.venda = e AND p.dataPagamento is null AND p.indicadorAtivo = true) > 0 ");
162 
                                sql.append("OR (SELECT COUNT(c) FROM Conta c WHERE c.venda = e AND c.indicadorAtivo = true) = 0) ");
163 
                        }
164 
                }
165 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getFormaPagamento())) {
166 
                        sql.append("AND (SELECT COUNT(p) FROM VendaFormaPagamento p WHERE p.venda = e AND p.formaPagamento.codigo = :codigoFormaPagamento) > 0 ");
167 
                }
168 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getBandeiraCartao())) {
169 
                        sql.append("AND (SELECT COUNT(b) FROM VendaFormaPagamento b WHERE b.venda = e AND b.bandeiraCartao.codigo = :codigoBandeiraCartao) > 0 ");
170 
                }
171 
                */
172 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getSequencialVenda())) {
296 espaco 173 
                        sql.append("AND e.sequencial = :sequencialVenda ");
261 espaco 174 
                } else if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getParametrosPeriodoDTO().getDataSelecionada())
175 
                                || VerificadorUtil.naoEstaNuloOuVazio(parametros.getParametrosPeriodoDTO().getDataInicial())
176 
                                || VerificadorUtil.naoEstaNuloOuVazio(parametros.getParametrosPeriodoDTO().getDataFinal())) {
296 espaco 177 
                        sql.append("AND e.dataVenda >= :dataInicial ");
178 
                        sql.append("AND e.dataVenda <= :dataFinal ");
230 espaco 179 
                }
180 
                /*
181 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getCodigoCupom())) {
182 
                        sql.append("AND (SELECT COUNT(cl) FROM Lancamento cl WHERE cl.venda = e AND cl.cupom.codigo = :codigoCupom) > 0) ");
183 
                }
184 
                */
185 
        }
186 
 
187 
        private void setarQueryParametrosConsulta(Query query, ParametrosConsultaVendasDTO parametros) {
188 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getSequencialLoja())) {
189 
                        query.setParameter("sequencialLoja", parametros.getSequencialLoja());
190 
                }
253 espaco 191 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getTipoSituacaoVenda())) {
192 
                        query.setParameter("tipoSituacao", parametros.getTipoSituacaoVenda());
193 
                }
264 espaco 194 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getSequencialVendedor())) {
195 
                        query.setParameter("sequencialVendedor", parametros.getSequencialVendedor());
196 
                }
230 espaco 197 
                /*
198 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getIndicacao())) {
199 
                        query.setParameter("sequencialIndicacao", parametros.getIndicacao().getSequencial());
200 
                }
201 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getIndicadorComissionado())) {
202 
                        query.setParameter("indicadorComissionado", parametros.getIndicadorComissionado());
203 
                }
204 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getTipoProduto())) {
205 
                        query.setParameter("tipoProduto", parametros.getTipoProduto());
206 
                }
207 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getFormaPagamento())) {
208 
                        query.setParameter("codigoFormaPagamento", parametros.getFormaPagamento().getCodigo());
209 
                }
210 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getBandeiraCartao())) {
211 
                        query.setParameter("codigoBandeiraCartao", parametros.getBandeiraCartao().getCodigo());
212 
                }
213 
                 */
214 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getSequencialVenda())) {
215 
                        query.setParameter("sequencialVenda", parametros.getSequencialVenda());
261 espaco 216 
                } else if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getParametrosPeriodoDTO().getDataInicial())
217 
                                && VerificadorUtil.naoEstaNuloOuVazio(parametros.getParametrosPeriodoDTO().getDataFinal())) {
218 
                        Date dataInicial = DataUtils.getDataComHorarioMinimo(parametros.getParametrosPeriodoDTO().getDataInicial());
219 
                        Date dataFinal = DataUtils.getDataComHorarioMaximo(parametros.getParametrosPeriodoDTO().getDataFinal());
230 espaco 220 
                        query.setParameter("dataInicial", dataInicial);
221 
                        query.setParameter("dataFinal", dataFinal);
261 espaco 222 
                } else if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getParametrosPeriodoDTO().getDataSelecionada())) {
223 
                        Date dataInicial = DataUtils.getDataComHorarioMinimo(parametros.getParametrosPeriodoDTO().getDataSelecionada());
224 
                        Date dataFinal = DataUtils.getDataComHorarioMaximo(parametros.getParametrosPeriodoDTO().getDataSelecionada());
230 espaco 225 
                        query.setParameter("dataInicial", dataInicial);
226 
                        query.setParameter("dataFinal", dataFinal);
227 
                }
228 
                /*
229 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getCodigoCupom())) {
230 
                        query.setParameter("codigoCupom", parametros.getCodigoCupom());
231 
                }
232 
                */
233 
        }
234 
 
561 blopes 235 
        @Override
236 
        public List<RankingModeloDTO> consultarModelosMaisVendidos(ParametrosConsultaModelosMaisVendidosDTO parametrosConsulta) {
237 
                List<RankingModeloDTO> modelos = new ArrayList<RankingModeloDTO>();
238 
                try {  
239 
                        StringBuilder sql = new StringBuilder();
240 
                        sql.append("SELECT COUNT(l), m.seq_modelo, m.dsc_modelo ");
241 
 
242 
                        // CONSULTANDO ESTOQUE DO MODELO
243 
                        sql.append(",(SELECT SUM(pl.qtd_estoque) FROM sc_sec.sec_produto_loja pl ");
244 
                        sql.append("LEFT JOIN sc_sec.sec_produto pp ON pp.seq_produto = pl.seq_produto ");
245 
                        sql.append("LEFT JOIN sc_sec.sec_modelo mm ON mm.seq_modelo = pp.seq_modelo ");
246 
                        sql.append("WHERE mm.seq_modelo = m.seq_modelo AND pp.tip_produto = 'C') ");
247 
 
248 
                        sql.append("FROM sc_sec.sec_lancamento l ");
249 
                        sql.append("LEFT JOIN sc_sec.sec_venda v ON l.seq_venda = v.seq_venda ");
250 
                        sql.append("LEFT JOIN sc_sec.sec_produto p ON p.seq_produto = l.seq_produto ");
251 
                        sql.append("LEFT JOIN sc_sec.sec_modelo m ON m.seq_modelo = p.seq_modelo ");
252 
                        sql.append("WHERE v.dth_venda <= :dataFinal AND v.dth_venda > :dataInicial ");
253 
                        sql.append("AND p.tip_produto = 'C' ");
254 
                        sql.append("AND m.seq_modelo IS NOT NULL ");
588 blopes 255 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
256 
                                sql.append("AND v.seq_loja = :sequencialLoja ");
257 
                        }
258 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialModelo())) {
259 
                                sql.append("AND m.seq_modelo = :sequencialModelo ");
260 
                        }
561 blopes 261 
                        sql.append("GROUP BY m.seq_modelo, m.dsc_modelo ");
262 
                        sql.append("ORDER BY COUNT(l) DESC ");
263 
 
264 
                        Query query = getEntityManager().createNativeQuery(sql.toString());
265 
                        Date dataInicial = DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial());
266 
                        Date dataFinal = DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal());
267 
                        query.setParameter("dataInicial", dataInicial);
268 
                        query.setParameter("dataFinal", dataFinal);
588 blopes 269 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
270 
                                query.setParameter("sequencialLoja", parametrosConsulta.getSequencialLoja());
271 
                        }
272 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialModelo())) {
273 
                                query.setParameter("sequencialModelo", parametrosConsulta.getSequencialModelo());
274 
                        }
561 blopes 275 
 
276 
                        List<Object[]> resultList = query.getResultList();
277 
 
278 
                        for (Object[] objects : resultList) {
279 
                                RankingModeloDTO rankingModeloDTO = new RankingModeloDTO();
280 
                                rankingModeloDTO.setModelo(new ModeloDTO(Long.parseLong(objects[1].toString()), objects[2].toString(), null));
281 
                                rankingModeloDTO.setQuantidadeVendas(Integer.valueOf(objects[0].toString()));
282 
                                rankingModeloDTO.setQuantidadeEstoqueGeral(Integer.valueOf(objects[3].toString()));
283 
                                modelos.add(rankingModeloDTO);
284 
                        }
285 
                } catch(Exception ex) {
286 
                        ex.printStackTrace();
287 
                        return null;
288 
                }
289 
                return modelos;
290 
                /*
291 
 
292 
                sql.append("SELECT new br.com.ec.domain.dto.RankingModeloDTO(l.produto.modelo, SUM(l.valorVenda), SUM(l.valorCompra), COUNT(l.produto.modelo), ");
293 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
294 
                        sql.append("(");
295 
                        sql.append(adicionarConsultaDoEstoque(parametrosConsulta.getSequencialLoja(), "l.produto.modelo", parametrosConsulta.getTipoProduto(), parametrosConsulta.getEstiloProduto()));
296 
                        sql.append("), ");
297 
                }
298 
                sql.append("(");
299 
                sql.append(adicionarConsultaDoEstoque(null, "l.produto.modelo", parametrosConsulta.getTipoProduto(), parametrosConsulta.getEstiloProduto()));
300 
                sql.append(")) FROM Lancamento l ");
301 
                sql.append("WHERE l.venda.dataVenda >= :dataInicial AND l.venda.dataVenda <= :dataFinal ");
302 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
303 
                        sql.append("AND l.venda.loja.sequencial = :sequencialLoja ");
304 
                }
305 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
306 
                        sql.append("AND l.produto.tipo = :tipoProduto ");
307 
                }
308 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
309 
                        sql.append("AND l.produto.modelo = :modelo ");
310 
                }
311 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getEstiloProduto())) {
312 
                        sql.append("AND l.produto.estilo = :estiloProduto ");
313 
                }
314 
                sql.append("GROUP BY l.produto.modelo ");
315 
                if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.LUCRO.getValor())) {
316 
                        sql.append("ORDER BY SUM(l.valorVenda - l.valorCompra) DESC ");
317 
                } else if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.QUANTIDADE.getValor())) {
318 
                        sql.append("ORDER BY COUNT(l.produto.modelo) DESC ");
319 
                } else if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.VALOR_VENDIDO.getValor())) {
320 
                        sql.append("ORDER BY SUM(l.valorVenda) DESC ");
321 
                }
322 
                try {
323 
                        TypedQuery<RankingModeloDTO> query = getEntityManager().createQuery(sql.toString(), RankingModeloDTO.class)
324 
                                        .setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial()))
325 
                                        .setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal()));
326 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getQuantidadeModelos())) {
327 
                                query.setMaxResults(parametrosConsulta.getQuantidadeModelos());
328 
                        }
329 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
330 
                                query.setParameter("sequencialLoja", parametrosConsulta.getSequencialLoja());
331 
                        }
332 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
333 
                                query.setParameter("tipoProduto", parametrosConsulta.getTipoProduto());
334 
                        }
335 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
336 
                                query.setParameter("modelo", parametrosConsulta.getModelo());
337 
                        }
338 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getEstiloProduto())) {
339 
                                query.setParameter("estiloProduto", parametrosConsulta.getEstiloProduto());
340 
                        }
341 
                        return query.getResultList();
342 
                } catch(Exception ex) {
343 
                        ex.printStackTrace();
344 
                        return null;
345 
                }
346 
                */
347 
        }
348 
 
349 
        @Override
350 
        public List<RankingComprasTransferenciasEstiloDTO> consultarRankingPorEstilo(Long sequencialModelo, ParametrosConsultaPorPeriodoDTO parametrosConsultaPorPeriodoDTO) {
351 
                List<RankingComprasTransferenciasEstiloDTO> rankingPorEstilo = new ArrayList<RankingComprasTransferenciasEstiloDTO>();
352 
                try {  
353 
                        StringBuilder sql = new StringBuilder();
354 
                        sql.append("SELECT p.tip_estilo ");
355 
 
562 blopes 356 
                        sql.append("," + adicionarConsultaVendasRankingPorEstilo("vendas_estilo_a", TipoProduto.CAPA.getValor(), TipoGenero.UNISSEX.getValor()));
357 
                        sql.append("," + adicionarConsultaVendasRankingPorEstilo("vendas_estilo_b", TipoProduto.CAPA.getValor(), TipoGenero.MASCULINO.getValor()));
358 
                        sql.append("," + adicionarConsultaVendasRankingPorEstilo("vendas_estilo_c", TipoProduto.CAPA.getValor(), TipoGenero.FEMININO.getValor()));
561 blopes 359 
 
562 blopes 360 
                        sql.append("," + adicionarConsultaEstoqueRankingPorEstilo("estoque_estilo_a", TipoProduto.CAPA.getValor(), TipoGenero.UNISSEX.getValor()));
361 
                        sql.append("," + adicionarConsultaEstoqueRankingPorEstilo("estoque_estilo_b", TipoProduto.CAPA.getValor(), TipoGenero.MASCULINO.getValor()));
362 
                        sql.append("," + adicionarConsultaEstoqueRankingPorEstilo("estoque_estilo_c", TipoProduto.CAPA.getValor(), TipoGenero.FEMININO.getValor()));
561 blopes 363 
 
566 blopes 364 
                        sql.append("FROM sc_sec.sec_produto_loja AS pl ");
365 
                        sql.append("LEFT JOIN sc_sec.sec_produto p ON p.seq_produto = pl.seq_produto ");
561 blopes 366 
                        sql.append("LEFT JOIN sc_sec.sec_modelo m ON m.seq_modelo = p.seq_modelo ");
566 blopes 367 
                        sql.append("WHERE m.seq_modelo = :sequencialModelo ");
561 blopes 368 
                        sql.append("AND p.tip_produto = '" + TipoProduto.CAPA.getValor() + "' ");
369 
                        sql.append("GROUP BY p.tip_estilo ");
565 blopes 370 
 
371 
                        String orderSql = "ORDER BY (";
372 
                        for (TipoEstiloProduto estiloProduto : TipoEstiloProduto.values()) {
373 
                                orderSql = orderSql + "p.tip_estilo = '" + estiloProduto.getValor() + "', ";
374 
                        }
375 
                        orderSql = orderSql + ") DESC ";
376 
                        sql.append(orderSql.replace(", )", ")"));
562 blopes 377 
//                      sql.append("ORDER BY p.tip_estilo IN :tiposEstilos");
561 blopes 378 
 
379 
                        Query query = getEntityManager().createNativeQuery(sql.toString());
380 
                        Date dataInicial = DataUtils.getDataComHorarioMinimo(parametrosConsultaPorPeriodoDTO.getDataInicial());
381 
                        Date dataFinal = DataUtils.getDataComHorarioMaximo(parametrosConsultaPorPeriodoDTO.getDataFinal());
382 
                        query.setParameter("dataInicial", dataInicial);
383 
                        query.setParameter("dataFinal", dataFinal);
384 
                        query.setParameter("sequencialModelo", sequencialModelo);
562 blopes 385 
//                      query.setParameter("tiposEstilos", TipoEstiloProduto.values());
561 blopes 386 
 
387 
                        List<Object[]> resultList = query.getResultList();
388 
                        for (Object[] objects : resultList) {
389 
                                RankingComprasTransferenciasEstiloDTO rankingEstiloDTO = new RankingComprasTransferenciasEstiloDTO();
566 blopes 390 
                                if (VerificadorUtil.naoEstaNuloOuVazio(objects[0])) {
391 
                                        rankingEstiloDTO.setEstilo(TipoEstiloProduto.parse(objects[0].toString()));
392 
                                        rankingEstiloDTO.setQuantidadeVendasUnissex(Integer.valueOf(retornarValorSeExitir(objects[1])));
393 
                                        rankingEstiloDTO.setQuantidadeVendasMasculino(Integer.valueOf(retornarValorSeExitir(objects[2])));
394 
                                        rankingEstiloDTO.setQuantidadeVendasFeminino(Integer.valueOf(retornarValorSeExitir(objects[3])));
395 
                                        rankingEstiloDTO.setQuantidadeEstoqueUnissex(Integer.valueOf(retornarValorSeExitir(objects[4])));
396 
                                        rankingEstiloDTO.setQuantidadeEstoqueMasculino(Integer.valueOf(retornarValorSeExitir(objects[5])));
397 
                                        rankingEstiloDTO.setQuantidadeEstoqueFeminino(Integer.valueOf(retornarValorSeExitir(objects[6])));
398 
                                        rankingPorEstilo.add(rankingEstiloDTO);
399 
                                }
561 blopes 400 
                        }
401 
                } catch(Exception ex) {
402 
                        ex.printStackTrace();
403 
                        return null;
404 
                }
405 
                return rankingPorEstilo;
406 
        }
407 
 
562 blopes 408 
        private String adicionarConsultaVendasRankingPorEstilo(String alias, String tipoProduto, String tipoGenero) {
561 blopes 409 
                StringBuilder sql = new StringBuilder();
566 blopes 410 
                sql.append("(SELECT COUNT(*) FROM sc_sec.sec_lancamento ll ");
411 
                sql.append("LEFT JOIN sc_sec.sec_venda vv ON ll.seq_venda = vv.seq_venda ");
412 
                sql.append("LEFT JOIN sc_sec.sec_produto pp ON pp.seq_produto = ll.seq_produto ");
413 
                sql.append("LEFT JOIN sc_sec.sec_modelo mm ON mm.seq_modelo = pp.seq_modelo ");
414 
                sql.append("WHERE vv.dth_venda <= :dataFinal AND vv.dth_venda >= :dataInicial ");
415 
                sql.append("AND mm.seq_modelo = :sequencialModelo AND pp.tip_estilo = p.tip_estilo ");
416 
                sql.append("AND pp.tip_produto = '" + tipoProduto + "' AND pp.tip_genero LIKE '" + tipoGenero + "') ");
562 blopes 417 
                sql.append("AS " + alias + " ");
561 blopes 418 
                return sql.toString();
419 
        }
420 
 
562 blopes 421 
        private String adicionarConsultaEstoqueRankingPorEstilo(String alias, String tipoProduto, String tipoGenero) {
561 blopes 422 
                StringBuilder sql = new StringBuilder();
566 blopes 423 
                sql.append("(SELECT SUM(pll.qtd_estoque) FROM sc_sec.sec_produto_loja pll ");
424 
                sql.append("LEFT JOIN sc_sec.sec_produto pp ON pp.seq_produto = pll.seq_produto ");
561 blopes 425 
                sql.append("LEFT JOIN sc_sec.sec_modelo mm ON mm.seq_modelo = pp.seq_modelo ");
426 
                sql.append("WHERE mm.seq_modelo = :sequencialModelo AND pp.tip_estilo = p.tip_estilo ");
427 
                sql.append("AND pp.tip_produto = '" + tipoProduto + "' AND pp.tip_genero LIKE '" + tipoGenero + "') ");
562 blopes 428 
                sql.append("AS " + alias + " ");
561 blopes 429 
                return sql.toString();
430 
        }
431 
 
432 
        @Override
433 
        public List<RankingComprasTransferenciasEstiloPorLojaDTO> consultarRankingPorEstiloPorLoja(Long sequencialModelo,
434 
                        String tipoEstilo, ParametrosConsultaPorPeriodoDTO parametrosConsultaPorPeriodoDTO) {
435 
                List<RankingComprasTransferenciasEstiloPorLojaDTO> rankingPorEstiloPorLoja = new ArrayList<RankingComprasTransferenciasEstiloPorLojaDTO>();
436 
                try {  
437 
                        StringBuilder sql = new StringBuilder();
566 blopes 438 
                        sql.append("SELECT pl.seq_loja, lj.dsc_loja ");
561 blopes 439 
 
562 blopes 440 
                        sql.append("," + adicionarConsultaVendasRankingPorEstiloPorLoja("vendas_estilo_loja_a", TipoProduto.CAPA.getValor(), TipoGenero.UNISSEX.getValor()));
441 
                        sql.append("," + adicionarConsultaVendasRankingPorEstiloPorLoja("vendas_estilo_loja_b", TipoProduto.CAPA.getValor(), TipoGenero.MASCULINO.getValor()));
442 
                        sql.append("," + adicionarConsultaVendasRankingPorEstiloPorLoja("vendas_estilo_loja_c", TipoProduto.CAPA.getValor(), TipoGenero.FEMININO.getValor()));
561 blopes 443 
 
562 blopes 444 
                        sql.append("," + adicionarConsultaEstoqueRankingPorEstiloPorLoja("estoque_estilo_loja_a", TipoProduto.CAPA.getValor(), TipoGenero.UNISSEX.getValor()));
445 
                        sql.append("," + adicionarConsultaEstoqueRankingPorEstiloPorLoja("estoque_estilo_loja_b", TipoProduto.CAPA.getValor(), TipoGenero.MASCULINO.getValor()));
446 
                        sql.append("," + adicionarConsultaEstoqueRankingPorEstiloPorLoja("estoque_estilo_loja_c", TipoProduto.CAPA.getValor(), TipoGenero.FEMININO.getValor()));
561 blopes 447 
 
566 blopes 448 
                        sql.append("FROM sc_sec.sec_produto_loja pl ");
449 
                        sql.append("LEFT JOIN sc_sec.sec_loja lj ON lj.seq_loja = pl.seq_loja ");
450 
                        sql.append("LEFT JOIN sc_sec.sec_produto p ON p.seq_produto = pl.seq_produto ");
561 blopes 451 
                        sql.append("LEFT JOIN sc_sec.sec_modelo m ON m.seq_modelo = p.seq_modelo ");
566 blopes 452 
                        sql.append("WHERE m.seq_modelo = :sequencialModelo ");
561 blopes 453 
                        sql.append("AND p.tip_produto = '" + TipoProduto.CAPA.getValor() + "' ");
454 
                        sql.append("AND p.tip_estilo = :tipoEstilo ");
455 
                        sql.append("AND lj.ind_ativo IS TRUE ");
566 blopes 456 
                        sql.append("GROUP BY lj.num_ordem, pl.seq_loja, lj.dsc_loja ");
561 blopes 457 
                        sql.append("ORDER BY lj.num_ordem ");
458 
 
459 
                        Query query = getEntityManager().createNativeQuery(sql.toString());
460 
                        Date dataInicial = DataUtils.getDataComHorarioMinimo(parametrosConsultaPorPeriodoDTO.getDataInicial());
461 
                        Date dataFinal = DataUtils.getDataComHorarioMaximo(parametrosConsultaPorPeriodoDTO.getDataFinal());
462 
                        query.setParameter("dataInicial", dataInicial);
463 
                        query.setParameter("dataFinal", dataFinal);
464 
                        query.setParameter("sequencialModelo", sequencialModelo);
465 
                        query.setParameter("tipoEstilo", tipoEstilo);
466 
 
467 
                        List<Object[]> resultList = query.getResultList();
468 
                        for (Object[] objects : resultList) {
469 
                                RankingComprasTransferenciasEstiloPorLojaDTO rankingEstiloPorLojaDTO = new RankingComprasTransferenciasEstiloPorLojaDTO();
562 blopes 470 
                                rankingEstiloPorLojaDTO.setLojaDTO(new LojaDTO(Long.parseLong(retornarValorSeExitir(objects[0])), retornarValorSeExitir(objects[1])));
471 
                                rankingEstiloPorLojaDTO.setQuantidadeVendasUnissex(Integer.valueOf(retornarValorSeExitir(objects[2])));
472 
                                rankingEstiloPorLojaDTO.setQuantidadeVendasMasculino(Integer.valueOf(retornarValorSeExitir(objects[3])));
473 
                                rankingEstiloPorLojaDTO.setQuantidadeVendasFeminino(Integer.valueOf(retornarValorSeExitir(objects[4])));
474 
                                rankingEstiloPorLojaDTO.setQuantidadeEstoqueUnissex(Integer.valueOf(retornarValorSeExitir(objects[5])));
475 
                                rankingEstiloPorLojaDTO.setQuantidadeEstoqueMasculino(Integer.valueOf(retornarValorSeExitir(objects[6])));
476 
                                rankingEstiloPorLojaDTO.setQuantidadeEstoqueFeminino(Integer.valueOf(retornarValorSeExitir(objects[7])));
561 blopes 477 
                                rankingPorEstiloPorLoja.add(rankingEstiloPorLojaDTO);
478 
                        }
479 
 
480 
                } catch(Exception ex) {
481 
                        ex.printStackTrace();
482 
                        return null;
483 
                }
484 
                return rankingPorEstiloPorLoja;
485 
        }
486 
 
562 blopes 487 
        private String adicionarConsultaVendasRankingPorEstiloPorLoja(String alias, String tipoProduto, String tipoGenero) {
561 blopes 488 
                StringBuilder sql = new StringBuilder();
489 
                sql.append("(SELECT COUNT(*) FROM sc_sec.sec_lancamento ll ");
490 
                sql.append("LEFT JOIN sc_sec.sec_venda vv ON ll.seq_venda = vv.seq_venda ");
491 
                sql.append("LEFT JOIN sc_sec.sec_produto pp ON pp.seq_produto = ll.seq_produto ");
492 
                sql.append("LEFT JOIN sc_sec.sec_modelo mm ON mm.seq_modelo = pp.seq_modelo ");
493 
                sql.append("WHERE vv.dth_venda <= :dataFinal AND vv.dth_venda >= :dataInicial ");
566 blopes 494 
                sql.append("AND vv.seq_loja = pl.seq_loja ");
561 blopes 495 
                sql.append("AND mm.seq_modelo = :sequencialModelo AND pp.tip_estilo = :tipoEstilo ");
496 
                sql.append("AND pp.tip_produto = '" + tipoProduto + "' AND pp.tip_genero LIKE '" + tipoGenero + "') ");
562 blopes 497 
                sql.append("AS " + alias + " ");
561 blopes 498 
                return sql.toString();
499 
        }
500 
 
562 blopes 501 
        private String adicionarConsultaEstoqueRankingPorEstiloPorLoja(String alias, String tipoProduto, String tipoGenero) {
561 blopes 502 
                StringBuilder sql = new StringBuilder();
566 blopes 503 
                sql.append("(SELECT SUM(pll.qtd_estoque) FROM sc_sec.sec_produto_loja pll ");
504 
                sql.append("LEFT JOIN sc_sec.sec_produto pp ON pp.seq_produto = pll.seq_produto ");
561 blopes 505 
                sql.append("LEFT JOIN sc_sec.sec_modelo mm ON mm.seq_modelo = pp.seq_modelo ");
566 blopes 506 
                sql.append("WHERE pll.seq_loja = pl.seq_loja AND mm.seq_modelo = :sequencialModelo ");
562 blopes 507 
                sql.append("AND pp.tip_estilo = :tipoEstilo ");
561 blopes 508 
                sql.append("AND pp.tip_produto = '" + tipoProduto + "' AND pp.tip_genero LIKE '" + tipoGenero + "') ");
562 blopes 509 
                sql.append("AS " + alias + " ");
561 blopes 510 
                return sql.toString();
511 
        }
562 blopes 512 
 
513 
        private String retornarValorSeExitir(Object objeto) {
514 
                String valor = "0";
515 
                if (VerificadorUtil.naoEstaNulo(objeto)) {
516 
                        valor = objeto.toString();
517 
                }
518 
                return valor;
519 
        }
561 blopes 520 
 
229 espaco 521 
        /*
561 blopes 522 
        private String adicionarConsultaDoEstoque(Long sequencialLoja, String modelo, String tipoProduto, String estiloProduto) {
523 
                sql.append("SELECT SUM(pl.quantidadeEstoque) FROM ProdutoLoja pl ");
524 
                sql.append("WHERE pl.produto.modelo = " + modelo + " ");
525 
                if (VerificadorUtil.naoEstaNuloOuVazio(sequencialLoja)) {
526 
                        sql.append("AND pl.loja.sequencial = :sequencialLoja ");
527 
                }
528 
                if (VerificadorUtil.naoEstaNuloOuVazio(tipoProduto)) {
529 
                        sql.append("AND pl.produto.tipo = :tipoProduto ");
530 
                }
531 
                if (VerificadorUtil.naoEstaNuloOuVazio(estiloProduto)) {
532 
                        sql.append("AND pl.produto.estilo = :estiloProduto ");
533 
                }
534 
                return sql.toString().trim();
535 
        }
536 
         */
537 
 
538 
        /*
229 espaco 539 
        private void setarParametrosStringConsultarVendaPorLojaEePeriodo(StringBuilder sql, Venda venda, Date dataInicial, Date dataFinal) {
540 
                setarStringParametrosConsultar(sql, venda);
541 
                if (VerificadorUtil.naoEstaNuloOuVazio(dataInicial) && VerificadorUtil.naoEstaNuloOuVazio(dataFinal)) {
542 
                        sql.append("AND e.dataVenda >= :dataInicial AND e.dataVenda <= :dataFinal ");
543 
                }
544 
        }
545 
        */
546 
/*
547 
        @Override
548 
        protected void setarStringParametrosConsultar(StringBuilder sql, Venda venda) {
549 
                if (VerificadorUtil.naoEstaNuloOuVazio(venda)) {
550 
                        if (VerificadorUtil.naoEstaNuloOuVazio(venda.getSequencialDaLoja())) {
551 
                                sql.append("AND e.loja.sequencial = :sequencialLoja ");
552 
                        }
553 
                        if (VerificadorUtil.naoEstaNuloOuVazio(venda.getVendedor())) {
554 
                                sql.append("AND e.vendedor.sequencial = :sequencialVendedor ");
555 
                        }
556 
                        if (VerificadorUtil.naoEstaNuloOuVazio(venda.getIndicacao())) {
557 
                                sql.append("AND e.indicacao.sequencial = :sequencialIndicacao ");
558 
                        }
559 
                        if (VerificadorUtil.naoEstaNuloOuVazio(venda.getTipoSituacao())) {
560 
                                sql.append("AND e.tipoSituacao = :tipoSituacao ");
561 
                        }
562 
                        if (VerificadorUtil.naoEstaNuloOuVazio(venda.getDataVenda())) {
563 
                                sql.append("AND e.dataVenda >= :dataInicial ");
564 
                                sql.append("AND e.dataVenda <= :dataFinal ");
565 
                        }
566 
                }
567 
        }
568 
 
569 
        @Override
570 
        protected void setarQueryParametrosConsultar(Query query, Venda venda) {
571 
                if (VerificadorUtil.naoEstaNuloOuVazio(venda)) {
572 
                        if (VerificadorUtil.naoEstaNuloOuVazio(venda.getSequencialDaLoja())) {
573 
                                query.setParameter("sequencialLoja", venda.getSequencialDaLoja());
574 
                        }
575 
                        if (VerificadorUtil.naoEstaNuloOuVazio(venda.getSequencialDoVendedor())) {
576 
                                query.setParameter("sequencialVendedor", venda.getSequencialDoVendedor());
577 
                        }
578 
                        if (VerificadorUtil.naoEstaNuloOuVazio(venda.getIndicacao())) {
579 
                                query.setParameter("sequencialIndicacao", venda.getIndicacao());
580 
                        }
581 
                        if (VerificadorUtil.naoEstaNuloOuVazio(venda.getTipoSituacao())) {
582 
                                query.setParameter("tipoSituacao", venda.getTipoSituacao());
583 
                        }
584 
                        if (VerificadorUtil.naoEstaNuloOuVazio(venda.getDataVenda())) {
585 
                                Date dataInicial = DataUtils.getDataComHorarioMinimo(venda.getDataVenda());
586 
                                Date dataFinal = DataUtils.getDataComHorarioMaximo(venda.getDataVenda());
587 
                                query.setParameter("dataInicial", dataInicial);
588 
                                query.setParameter("dataFinal", dataFinal);
589 
                        }
590 
                }
591 
        }
592 
 
593 
        @Override
594 
        public List<Venda> consultarVendasPorDemanda(ParametrosConsulta<Venda> parametrosConsulta, Integer primeiroRegistro,
595 
                        Integer tamanhoPagina, String sortField, String orderSort, Map<String, Object> filters) {
596 
                StringBuilder sql = new StringBuilder();
597 
                sql.append("SELECT DISTINCT e FROM Venda e ");
598 
                sql.append("LEFT JOIN FETCH e.listaLancamentos l ");
599 
                sql.append("LEFT JOIN FETCH e.listaVendaFormaPagamentos p ");
600 
                sql.append("WHERE 1=1 ");
601 
 
602 
                try {
603 
                        setarStringParametrosConsulta(sql, parametrosConsulta);
604 
                        sql.append("ORDER BY e.dataVenda");
605 
                        TypedQuery<Venda> query = (TypedQuery<Venda>) getEntityManager().createQuery(sql.toString(), Venda.class);
606 
                        setarQueryParametrosConsulta(query, parametrosConsulta);
607 
 
608 
                        return query.setFirstResult(primeiroRegistro).setMaxResults(tamanhoPagina).getResultList();
609 
                } catch(Exception ex) {
610 
                        ex.printStackTrace();
611 
                        return null;
612 
                }
613 
        }
614 
 
615 
        @Override
616 
        public List<Venda> consultarVendaPorParametros(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
617 
                StringBuilder sql = new StringBuilder();
618 
                sql.append("SELECT DISTINCT e FROM Venda e ");
619 
                sql.append("LEFT JOIN FETCH e.listaLancamentos l ");
620 
                sql.append("LEFT JOIN FETCH e.listaVendaFormaPagamentos p ");
621 
                sql.append("WHERE 1=1 ");
622 
 
623 
                try {
624 
                        setarStringParametrosConsulta(sql, parametrosConsultaVendas);
625 
                        sql.append("ORDER BY e.dataVenda");
626 
                        TypedQuery<Venda> query = (TypedQuery<Venda>) getEntityManager().createQuery(sql.toString(), Venda.class);
627 
                        setarQueryParametrosConsulta(query, parametrosConsultaVendas);
628 
                        return query.getResultList();
629 
                } catch(Exception ex) {
630 
                        ex.printStackTrace();
631 
                        return null;
632 
                }
633 
        }
634 
 
635 
        @Override
636 
        public Venda detalharVenda(Venda venda) {
637 
                StringBuilder jpql = new StringBuilder();
638 
                try {
639 
                        jpql.append("SELECT c FROM Venda c ");
640 
                        //jpql.append("LEFT JOIN FETCH c.listaPedidos p ");
641 
                        //jpql.append("LEFT JOIN FETCH c.listaVendas v ");
642 
                        jpql.append("WHERE c = :venda");
643 
                        return getEntityManager().createQuery(jpql.toString(), Venda.class).setParameter("venda", venda).getSingleResult();
644 
                } catch (NoResultException e) {
645 
                        return null;
646 
                }
647 
        }
648 
 
649 
        @Override
650 
        public Venda detalharVendaCompleta(Venda venda) {
651 
                StringBuilder jpql = new StringBuilder();
652 
                try {
653 
                        jpql.append("SELECT c FROM Venda c ");
654 
                        jpql.append("LEFT JOIN FETCH c.listaLancamentos l ");
655 
                        jpql.append("LEFT JOIN FETCH c.listaVendaFormaPagamentos p ");
656 
                        jpql.append("WHERE c = :venda");
657 
                        return getEntityManager().createQuery(jpql.toString(), Venda.class).setParameter("venda", venda).getSingleResult();
658 
                } catch (NoResultException e) {
659 
                        return null;
660 
                }
661 
        }
662 
 
663 
        @Override
664 
        public List<Venda> consultarVendasDoDia(Long sequencialLoja, Date data) {
665 
                StringBuilder sql = new StringBuilder();
666 
                sql.append("SELECT DISTINCT v FROM Venda v ");
667 
                sql.append("LEFT JOIN FETCH v.listaVendaFormaPagamentos p ");
668 
                sql.append("WHERE v.loja.sequencial = :sequencialLoja ");
669 
                sql.append("AND v.dataVenda >= :dataInicial AND v.dataVenda <= :dataFinal ");
670 
                try {
671 
                        sql.append("ORDER BY v.dataVenda");
672 
                        return getEntityManager().createQuery(sql.toString(), Venda.class)
673 
                                                .setParameter("sequencialLoja", sequencialLoja)
674 
                                                .setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(data))
675 
                                                .setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(data))
676 
                                                .getResultList();
677 
                } catch(Exception ex) {
678 
                        ex.printStackTrace();
679 
                        return null;
680 
                }
681 
        }
682 
 
683 
 
684 
        private void setarParametrosQueryConsultarVendaPorLojaEePeriodo(Query query, Venda venda, Date dataInicial, Date dataFinal) {
685 
                setarQueryParametrosConsultar(query, venda);
686 
                if (VerificadorUtil.naoEstaNuloOuVazio(dataInicial) && VerificadorUtil.naoEstaNuloOuVazio(dataFinal)) {
687 
                        query.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(dataInicial));
688 
                        query.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(dataFinal));
689 
                }
690 
        }
691 
 
692 
        @Override
693 
        public Double obterValorTotalBrutoDeVendasPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsulta) {
694 
                StringBuilder sql = new StringBuilder();
695 
                sql.append("SELECT SUM(l.valorVenda) FROM Venda e ");
696 
                sql.append("LEFT JOIN e.listaLancamentos l ");
697 
                sql.append("WHERE l.ativo IS TRUE ");
698 
                try {
699 
                        setarStringParametrosConsulta(sql, parametrosConsulta);
700 
                        TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
701 
                        setarQueryParametrosConsulta(query, parametrosConsulta);
702 
                        Double total = query.getSingleResult();
703 
                        if (VerificadorUtil.estaNulo(total)) {
704 
                                return new Double(0.0);
705 
                        }
706 
                        return total;
707 
                } catch(Exception ex) {
708 
                        ex.printStackTrace();
709 
                        return null;
710 
                }
711 
        }
712 
 
713 
        @Override
714 
        public Double obterValorDeCuponsUtilizadosPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsulta) {
715 
                StringBuilder sql = new StringBuilder();
716 
                sql.append("SELECT SUM(p.valorPagamento) FROM VendaFormaPagamento p ");
717 
                sql.append("LEFT JOIN p.venda e ");
718 
                sql.append("WHERE p.formaPagamento.codigo = 16 ");
719 
 
720 
                parametrosConsulta.setIndicadorComissionado(null);
721 
                parametrosConsulta.setTipoProduto(null);
722 
 
723 
                setarStringParametrosConsulta(sql, parametrosConsulta);
724 
*/             
725 
                /*
726 
                sql.append("AND (SELECT COUNT(l) FROM Lancamento l WHERE l.venda = e AND l.ativo = true) > 0 ");
727 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getLoja())) {
728 
                        sql.append("AND e.loja.sequencial = :sequencialLoja ");
729 
                }
730 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getVendedor())) {
731 
                        sql.append("AND e.vendedor.sequencial = :sequencialVendedor ");
732 
                }
733 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataVendas())
734 
                                || VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataInicial())
735 
                                || VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataFinal())) {
736 
                        sql.append("AND e.dataVenda >= :dataInicial ");
737 
                        sql.append("AND e.dataVenda <= :dataFinal ");
738 
                }
739 
                */
740 
/*     
741 
                try {
742 
                        TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
743 
                        setarQueryParametrosConsulta(query, parametrosConsulta);
744 
*/                     
745 
                        /*
746 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getLoja())) {
747 
                                query.setParameter("sequencialLoja", parametrosConsulta.getLoja().getSequencial());
748 
                        }
749 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getVendedor())) {
750 
                                query.setParameter("sequencialVendedor", parametrosConsulta.getVendedor().getSequencial());
751 
                        }
752 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataInicial())
753 
                                        && VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataFinal())) {
754 
                                Date dataInicial = DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial());
755 
                                Date dataFinal = DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal());
756 
                                query.setParameter("dataInicial", dataInicial);
757 
                                query.setParameter("dataFinal", dataFinal);
758 
                        } else if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataVendas())) {
759 
                                Date dataInicial = DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataVendas());
760 
                                Date dataFinal = DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataVendas());
761 
                                query.setParameter("dataInicial", dataInicial);
762 
                                query.setParameter("dataFinal", dataFinal);
763 
                        }
764 
                        */
765 
/*     
766 
                        Double total = query.getSingleResult();
767 
                        if (VerificadorUtil.estaNulo(total)) {
768 
                                return new Double(0.0);
769 
                        }
770 
                        return total;
771 
                } catch(Exception ex) {
772 
                        ex.printStackTrace();
773 
                        return null;
774 
                }
775 
        }
776 
 
777 
        @Override
778 
        public Double obterValorTotalDeDescontosPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsulta) {
779 
                StringBuilder sql = new StringBuilder();
780 
                sql.append("SELECT SUM(l.valorVarejo - l.valorVenda) FROM Venda e ");
781 
                sql.append("LEFT JOIN e.listaLancamentos l ");
782 
                sql.append("WHERE l.ativo IS TRUE ");
783 
                try {
784 
                        setarStringParametrosConsulta(sql, parametrosConsulta);
785 
                        TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
786 
                        setarQueryParametrosConsulta(query, parametrosConsulta);
787 
                        Double total = query.getSingleResult();
788 
                        if (VerificadorUtil.estaNulo(total)) {
789 
                                return new Double(0.0);
790 
                        }
791 
                        return total;
792 
                } catch(Exception ex) {
793 
                        ex.printStackTrace();
794 
                        return null;
795 
                }
796 
        }
261 espaco 797 
        */
229 espaco 798 
        @Override
296 espaco 799 
        public Double obterValorTotalBrutoDeVendasPorParametrosEeFormasDePagamento(ParametrosConsultaVendasDTO parametrosConsultaVendas, List<FormaPagamentoDTO> formasDePagamento) {
229 espaco 800 
                StringBuilder sql = new StringBuilder();
268 espaco 801 
                sql.append("SELECT SUM(vp.valorPagamento) FROM VendaFormaPagamento vp ");
296 espaco 802 
                sql.append("LEFT JOIN vp.venda e ");
268 espaco 803 
                sql.append("LEFT JOIN vp.formaPagamento f ");
804 
                sql.append("WHERE vp.formaPagamento.codigo != ");
261 espaco 805 
                sql.append(ConstantesSEC.FormasDePagamento.FORMAPAGAMENTO_CUPOM);
806 
                sql.append(" ");
229 espaco 807 
                try {
808 
                        sql = setarParametrosFormasDePagamento(sql, formasDePagamento);
264 espaco 809 
                        sql = setarParametrosLojasSelecionadas(sql, parametrosConsultaVendas.getLojasSelecionadasDTO());
268 espaco 810 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendas.getVendedorSelecionado())) {
296 espaco 811 
                                sql.append("AND e.vendedor.sequencial = :sequencialVendedor ");
268 espaco 812 
                        }
229 espaco 813 
                        setarStringParametrosConsulta(sql, parametrosConsultaVendas);
814 
                        TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
815 
                        setarQueryParametrosConsulta(query, parametrosConsultaVendas);
268 espaco 816 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendas.getVendedorSelecionado())) {
817 
                                query.setParameter("sequencialVendedor", parametrosConsultaVendas.getVendedorSelecionado().getSequencial());
818 
                        }
229 espaco 819 
                        Double total = query.getSingleResult();
820 
                        if (VerificadorUtil.estaNulo(total)) {
821 
                                return new Double(0.0);
822 
                        }
823 
                        return total;
824 
                } catch(Exception ex) {
825 
                        ex.printStackTrace();
826 
                        return null;
827 
                }
828 
        }
264 espaco 829 
 
261 espaco 830 
        private StringBuilder setarParametrosFormasDePagamento(StringBuilder sql, List<FormaPagamentoDTO> formasPagamento) {
831 
                if (VerificadorUtil.naoEstaNuloOuVazio(formasPagamento)) {
268 espaco 832 
                        sql.append("AND vp.formaPagamento.codigo IN (");
261 espaco 833 
                        for (FormaPagamentoDTO formaPagamento : formasPagamento) {
834 
                                if (!formaPagamento.formaPagamentoEhCupom()) {
835 
                                        sql.append(formaPagamento.getCodigo() + ",");
836 
                                }
229 espaco 837 
                        }
838 
                        sql.append(") ");
839 
                }
840 
                return new StringBuilder(sql.toString().replace(",)", ")"));
841 
        }
264 espaco 842 
 
843 
        private StringBuilder setarParametrosLojasSelecionadas(StringBuilder sql, List<LojaDTO> lojasSelecionadas) {
844 
                if (VerificadorUtil.naoEstaNuloOuVazio(lojasSelecionadas)) {
268 espaco 845 
                        sql.append("AND vp.venda.loja.sequencial IN (");
264 espaco 846 
                        for (LojaDTO loja : lojasSelecionadas) {
847 
                                sql.append(loja.getSequencial() + ",");
848 
                        }
849 
                        sql.append(") ");
850 
                }
851 
                return new StringBuilder(sql.toString().replace(",)", ")"));
852 
        }
853 
 
229 espaco 854 
        @Override
296 espaco 855 
        public Double obterValorTotalLiquidoDeVendas(ParametrosConsultaVendasDTO parametrosConsulta) {
229 espaco 856 
                StringBuilder sql = new StringBuilder();
857 
                sql.append("SELECT SUM(e.valor) FROM Parcela e ");
858 
                sql.append("INNER JOIN e.conta c ");
859 
                sql.append("WHERE e.indicadorAtivo IS TRUE ");
860 
                try {
296 espaco 861 
                        setarParametrosStringConsultarValorTotalLiquidoVenda(sql, parametrosConsulta);
229 espaco 862 
                        TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
296 espaco 863 
                        setarParametrosQueryConsultarValorTotalLiquidoVenda(query, parametrosConsulta);
229 espaco 864 
 
865 
                        Double total = query.getSingleResult();
866 
                        if (VerificadorUtil.estaNulo(total)) {
867 
                                return new Double(0.0);
868 
                        }
869 
                        return total;
870 
                } catch(Exception ex) {
871 
                        ex.printStackTrace();
872 
                        return null;
873 
                }
874 
        }
296 espaco 875 
 
876 
        private void setarParametrosStringConsultarValorTotalLiquidoVenda(StringBuilder sql, ParametrosConsultaVendasDTO parametrosConsulta) {
877 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getSequencialLoja())) {
229 espaco 878 
                        sql.append("AND e.conta.venda.loja.sequencial = :sequencialLoja ");
879 
                }
296 espaco 880 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getSequencialVendedor())) {
229 espaco 881 
                        sql.append("AND e.conta.venda.vendedor.sequencial = :sequencialVendedor ");
882 
                }
296 espaco 883 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataInicialDoPeriodo()) && VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataFinalDoPeriodo())) {
884 
                        sql.append("AND e.conta.venda.dataVenda >= :dataInicial AND e.conta.venda.dataVenda <= :dataFinal ");
885 
                }
886 
                /*
229 espaco 887 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getIndicacao())) {
888 
                        sql.append("AND e.conta.venda.indicacao.sequencial = :sequencialIndicacao ");
889 
                }
296 espaco 890 
                 */
229 espaco 891 
        }
892 
 
296 espaco 893 
        private void setarParametrosQueryConsultarValorTotalLiquidoVenda(Query query, ParametrosConsultaVendasDTO parametrosConsulta) {
894 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getSequencialLoja())) {
895 
                        query.setParameter("sequencialLoja", parametrosConsulta.getSequencialLoja());
229 espaco 896 
                }
296 espaco 897 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getSequencialVendedor())) {
898 
                        query.setParameter("sequencialVendedor", parametrosConsulta.getSequencialVendedor());
229 espaco 899 
                }
296 espaco 900 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataInicialDoPeriodo()) && VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataFinalDoPeriodo())) {
901 
                        query.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicialDoPeriodo()));
902 
                        query.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinalDoPeriodo()));
903 
                }
904 
                /*
229 espaco 905 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getIndicacao())) {
906 
                        query.setParameter("sequencialIndicacao", parametrosConsulta.getIndicacao().getSequencial());
907 
                }
296 espaco 908 
                */
229 espaco 909 
        }
910 
 
911 
        @Override
296 espaco 912 
        public Double obterValorProdutosUtilizadosEmVendas(ParametrosConsultaVendasDTO parametrosConsulta) {
229 espaco 913 
                StringBuilder sql = new StringBuilder();
296 espaco 914 
                sql.append("SELECT SUM(l.valorCompra) FROM Venda e ");
229 espaco 915 
                sql.append("LEFT JOIN e.listaLancamentos l ");
916 
                sql.append("WHERE l.ativo IS TRUE ");
917 
                try {
918 
                        setarStringParametrosConsulta(sql, parametrosConsulta);
296 espaco 919 
                        TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
229 espaco 920 
                        setarQueryParametrosConsulta(query, parametrosConsulta);
296 espaco 921 
                        Double total = query.getSingleResult();
922 
                        if (VerificadorUtil.estaNulo(total)) {
923 
                                return new Double(0.0);
924 
                        }
925 
                        return total;
229 espaco 926 
                } catch(Exception ex) {
927 
                        ex.printStackTrace();
928 
                        return null;
929 
                }
930 
        }
931 
 
450 blopes 932 
        @Override
933 
        public List<AuditoriaVendaDTO> consultarAuditoriaVenda(Date dataSelecionada, Long sequencialLojaSelecionada) {
934 
                StringBuilder sql = new StringBuilder();
935 
//              (Long sequencialVenda, Long sequencialLoja, Date dataHoraVenda, Double valorTotal, Double valorTrocaCancelamento)
936 
                sql.append("SELECT new br.com.ec.domain.dto.AuditoriaVendaDTO(");
937 
                sql.append("v.sequencial, v.loja.sequencial, v.dataVenda, SUM(vfp.valorPagamento), ");
938 
                sql.append("(SELECT SUM(vfpcupom.valorPagamento) FROM VendaFormaPagamento vfpcupom WHERE ");
939 
                sql.append("vfpcupom.venda.sequencial = v.sequencial AND vfpcupom.formaPagamento.codigo = 16)");
940 
                sql.append(") FROM Venda v ");
941 
                sql.append("LEFT JOIN v.listaVendaFormaPagamentos vfp ON vfp.formaPagamento.codigo <> 16 ");
942 
                sql.append("WHERE v.loja.sequencial = :sequencialLojaSelecionada ");
943 
                sql.append("AND v.dataVenda >= :dataInicial AND v.dataVenda <= :dataFinal ");
944 
                sql.append("GROUP BY (v.sequencial) ");
945 
                sql.append("ORDER BY (v.dataVenda) ");
946 
                try {
947 
                        TypedQuery<AuditoriaVendaDTO> query = getEntityManager().createQuery(sql.toString(), AuditoriaVendaDTO.class);
948 
                        query.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(dataSelecionada));
949 
                        query.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(dataSelecionada));
950 
                        query.setParameter("sequencialLojaSelecionada", sequencialLojaSelecionada);
951 
                        return query.getResultList();
952 
                } catch(Exception ex) {
953 
                        ex.printStackTrace();
954 
                        return null;
955 
                }
956 
        }
957 
 
561 blopes 958 
 
959 
 
296 espaco 960 
        /*
961 
 
229 espaco 962 
        @Override
296 espaco 963 
        public Integer obterQuantidadeProdutosVendidosPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsulta) {
229 espaco 964 
                StringBuilder sql = new StringBuilder();
965 
                sql.append("SELECT COUNT(l) FROM Venda e ");
966 
                sql.append("LEFT JOIN e.listaLancamentos l ");
296 espaco 967 
                sql.append("WHERE l.ativo IS TRUE ");
229 espaco 968 
                try {
969 
                        setarStringParametrosConsulta(sql, parametrosConsulta);
970 
                        TypedQuery<Long> query = getEntityManager().createQuery(sql.toString(), Long.class);
971 
                        setarQueryParametrosConsulta(query, parametrosConsulta);
972 
                        return query.getSingleResult().intValue();
973 
                } catch(Exception ex) {
974 
                        ex.printStackTrace();
975 
                        return null;
976 
                }
977 
        }
978 
 
979 
        @Override
296 espaco 980 
        public Integer obterQuantidadeProdutosVendidosPorLojaEePeriodoNaoVivo(ParametrosConsultaVendasDTO parametrosConsulta) {
229 espaco 981 
                StringBuilder sql = new StringBuilder();
296 espaco 982 
                sql.append("SELECT COUNT(l) FROM Venda e ");
229 espaco 983 
                sql.append("LEFT JOIN e.listaLancamentos l ");
296 espaco 984 
                sql.append("WHERE l.ativo IS TRUE AND l.produto.tipo not like 'V' ");
229 espaco 985 
                try {
986 
                        setarStringParametrosConsulta(sql, parametrosConsulta);
296 espaco 987 
                        TypedQuery<Long> query = getEntityManager().createQuery(sql.toString(), Long.class);
229 espaco 988 
                        setarQueryParametrosConsulta(query, parametrosConsulta);
296 espaco 989 
                        return query.getSingleResult().intValue();
229 espaco 990 
                } catch(Exception ex) {
991 
                        ex.printStackTrace();
992 
                        return null;
993 
                }
994 
        }
995 
 
996 
        @Override
997 
        public GraficoAcumuladoDTO consultarGrafico(String mes, String ano) {
998 
                StringBuilder sql = new StringBuilder();
999 
                sql.append("SELECT ");
1000 
                Calendar data = DataUtils.obterCalendario(DataUtils.obterData(1, new Integer(mes)-1, new Integer(ano)));
1001 
                int qntMaximaDias = data.getActualMaximum(Calendar.DAY_OF_MONTH);
1002 
                for (int i = 1; i <= qntMaximaDias; i++) {
1003 
                        String dia = String.format("%02d", i);
1004 
                        sql.append("SUM(D.DIA" + dia + ") AS dia" + dia);
1005 
                        if (i < qntMaximaDias) {
1006 
                                sql.append(", ");
1007 
                        } else {
1008 
                                sql.append(" ");
1009 
                        }
1010 
                }
1011 
                sql.append(" FROM ");
1012 
                sql.append("(SELECT ");
1013 
                for (int i = 1; i <= qntMaximaDias; i++) {
1014 
                        String dia = String.format("%02d", i);
1015 
                        sql.append("CASE date(v.dth_venda) WHEN '" + ano + "-" + mes + "-" + dia + "' THEN SUM(l.val_venda) END AS DIA" + dia);
1016 
                        if (i < qntMaximaDias) {
1017 
                                sql.append(", ");
1018 
                        } else {
1019 
                                sql.append(" ");
1020 
                        }
1021 
                }
1022 
                sql.append("FROM sc_sec.sec_lancamento l, sc_sec.sec_venda v ");
1023 
                sql.append("WHERE l.seq_venda = v.seq_venda AND l.ind_ativo is true ");
1024 
                sql.append("GROUP BY date(v.dth_venda) ");
1025 
                sql.append(") AS D ");
1026 
 
1027 
                try {
1028 
                        Query query = getEntityManager().createNativeQuery(sql.toString());
1029 
                        Object[] valores = new Object[31];
1030 
                        Object[] resultado = (Object[]) query.getSingleResult();
1031 
                        for (int i = 0; i < resultado.length; i++) {
1032 
                                valores[i] = resultado[i];
1033 
                        }
1034 
                        GraficoAcumuladoDTO grafico = new GraficoAcumuladoDTO();
1035 
                        grafico.setDIA_01(retornarValorEmString(valores[0]));
1036 
                        grafico.setDIA_02(retornarValorEmString(valores[1]));
1037 
                        grafico.setDIA_03(retornarValorEmString(valores[2]));
1038 
                        grafico.setDIA_04(retornarValorEmString(valores[3]));
1039 
                        grafico.setDIA_05(retornarValorEmString(valores[4]));
1040 
                        grafico.setDIA_06(retornarValorEmString(valores[5]));
1041 
                        grafico.setDIA_07(retornarValorEmString(valores[6]));
1042 
                        grafico.setDIA_08(retornarValorEmString(valores[7]));
1043 
                        grafico.setDIA_09(retornarValorEmString(valores[8]));
1044 
                        grafico.setDIA_10(retornarValorEmString(valores[9]));
1045 
                        grafico.setDIA_11(retornarValorEmString(valores[10]));
1046 
                        grafico.setDIA_12(retornarValorEmString(valores[11]));
1047 
                        grafico.setDIA_13(retornarValorEmString(valores[12]));
1048 
                        grafico.setDIA_14(retornarValorEmString(valores[13]));
1049 
                        grafico.setDIA_15(retornarValorEmString(valores[14]));
1050 
                        grafico.setDIA_16(retornarValorEmString(valores[15]));
1051 
                        grafico.setDIA_17(retornarValorEmString(valores[16]));
1052 
                        grafico.setDIA_18(retornarValorEmString(valores[17]));
1053 
                        grafico.setDIA_19(retornarValorEmString(valores[18]));
1054 
                        grafico.setDIA_20(retornarValorEmString(valores[19]));
1055 
                        grafico.setDIA_21(retornarValorEmString(valores[20]));
1056 
                        grafico.setDIA_22(retornarValorEmString(valores[21]));
1057 
                        grafico.setDIA_23(retornarValorEmString(valores[22]));
1058 
                        grafico.setDIA_24(retornarValorEmString(valores[23]));
1059 
                        grafico.setDIA_25(retornarValorEmString(valores[24]));
1060 
                        grafico.setDIA_26(retornarValorEmString(valores[25]));
1061 
                        grafico.setDIA_27(retornarValorEmString(valores[26]));
1062 
                        grafico.setDIA_28(retornarValorEmString(valores[27]));
1063 
                        grafico.setDIA_29(retornarValorEmString(valores[28]));
1064 
                        grafico.setDIA_30(retornarValorEmString(valores[29]));
1065 
                        grafico.setDIA_31(retornarValorEmString(valores[30]));
1066 
                        return grafico;
1067 
                } catch(Exception ex) {
1068 
                        return null;
1069 
                }
1070 
        }
1071 
 
1072 
        private Double retornarValorEmString(Object objeto) {
1073 
                try {
1074 
                        return new Double(objeto.toString());
1075 
                } catch (Exception e) {
1076 
                        return new Double(0.0);
1077 
                }
1078 
        }
582 blopes 1079 
        */
229 espaco 1080 
 
1081 
        private String adicionarEstoque(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
1082 
                StringBuilder sql = new StringBuilder();
1083 
                sql.append(", (SELECT SUM(pl.quantidadeEstoque) FROM ProdutoLoja pl WHERE pl.produto = l.produto ");
1084 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
1085 
                        sql.append("AND pl.loja.sequencial = :sequencialLoja ");
1086 
                }
1087 
                sql.append(")");
1088 
                return sql.toString();
1089 
        }
582 blopes 1090 
 
1091 
/*
229 espaco 1092 
        /*private String adicionarConsumoMedioDiario(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
1093 
                StringBuilder sql = new StringBuilder();
1094 
                sql.append(", (SELECT COUNT(*) FROM Lancamento lc WHERE lc.produto = l.produto AND lc.ativo = true ");
1095 
                sql.append("WHERE lc.venda.dataVenda >= :dataInicial AND lc.venda.dataVenda <= :dataFinal) ");
1096 
//              String dataAnterior = DataUtil.retornarDataFormatadaEmFormatoTexto("yyyy-MM-dd", DataUtils.acrescentarMeses(DataUtils.getDataAtual(), -2));
1097 
//              sql.append("AND lc.venda.dataVenda >= :dataDoisMesesAnterior) ");
1098 
                return sql.toString();
1099 
        }*/
582 blopes 1100 
 
229 espaco 1101 
        private String adicionarSolicitacaoCompraProduto() {
1102 
                StringBuilder sql = new StringBuilder();
1103 
//              sql.append(", (SELECT COUNT(*) > 0 FROM ProdutoPedidoCompra ppc WHERE ppc.produto = l.produto)");
1104 
//              sql.append(", (SELECT ppc.status, ppc.quantidadeParaComprar FROM ProdutoPedidoCompra ppc WHERE ppc.produto = l.produto)");
1105 
//              sql.append(", (SELECT (ppc) FROM ProdutoPedidoCompra ppc WHERE ppc.produto = l.produto)");
1106 
                sql.append(", (SELECT ppc.status FROM ProdutoPedidoCompra ppc WHERE ppc.produto = l.produto)");
1107 
                sql.append(", (SELECT ppc.quantidadeParaComprar FROM ProdutoPedidoCompra ppc WHERE ppc.produto = l.produto)");
1108 
                return sql.toString();
1109 
        }
1110 
 
1111 
        @Override
1112 
        public List<RankingProdutoDTO> consultarProdutosVendidos(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
1113 
                StringBuilder sql = new StringBuilder();
1114 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getTipoOrdenacao())) {
1115 
                        if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.DATA.getValor())) {
1116 
                                sql.append("SELECT new br.com.ec.domain.dto.RankingProdutoDTO(l.produto, l.venda, l.valorVenda, l.valorVarejo - l.valorVenda");
1117 
                                sql.append(adicionarEstoque(parametrosConsulta));
1118 
                                sql.append(adicionarSolicitacaoCompraProduto());
1119 
                                sql.append(") FROM Lancamento l ");
1120 
                        } else {
1121 
                                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)");
1122 
                                sql.append(adicionarEstoque(parametrosConsulta));
1123 
                                sql.append(adicionarSolicitacaoCompraProduto());
1124 
                                sql.append(") FROM Lancamento l ");
1125 
                        }
1126 
                } else {
1127 
                        sql.append("SELECT new br.com.ec.domain.dto.RankingProdutoDTO(l.produto, l.venda, l.valorVenda, l.valorVarejo - l.valorVenda");
1128 
                        sql.append(adicionarEstoque(parametrosConsulta));
1129 
                        sql.append(adicionarSolicitacaoCompraProduto());
1130 
                        sql.append(") FROM Lancamento l ");
1131 
                }
1132 
                sql.append("WHERE l.venda.dataVenda >= :dataInicial AND l.venda.dataVenda <= :dataFinal ");
1133 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
1134 
                        sql.append("AND l.venda.loja.sequencial = :sequencialLoja ");
1135 
                }
1136 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
1137 
                        sql.append("AND l.produto.tipo = :tipoProduto ");
1138 
                }
1139 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getProduto())) {
1140 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCodigo())) {
1141 
                                sql.append("AND l.produto.codigo = :codigo ");
1142 
                        }
1143 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getDescricao())) {
1144 
                                sql.append("AND ");
1145 
                                sql.append(sqlConsultarSemAcento("l.produto.descricao"));
1146 
                                sql.append(" like upper(:descricao) ");
1147 
                        }
1148 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getEstilo())) {
1149 
                                sql.append("AND l.produto.estilo = :tipoEstilo ");
1150 
                        }
1151 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCor())) {
1152 
                                sql.append("AND l.produto.cor = :tipoCor ");
1153 
                        }
1154 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getGenero())) {
1155 
                                sql.append("AND l.produto.genero = :tipoGenero ");
1156 
                        }
1157 
                }
1158 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getMarca())) {
1159 
                        sql.append("AND l.produto.modelo.marca.sequencial = :sequencialMarcaDoModelo ");
1160 
                }
1161 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
1162 
                        sql.append("AND l.produto.modelo.sequencial = :sequencialModelo ");
1163 
                }
1164 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getFornecedor())) {
1165 
                        sql.append("AND :fornecedor in (SELECT fp.fornecedor FROM FornecedorProduto fp WHERE fp.produto.sequencial = l.produto.sequencial) ");
1166 
                }
1167 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getVendedor())) {
1168 
                        sql.append("AND l.venda.vendedor = :vendedor ");
1169 
                }
1170 
 
1171 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getTipoOrdenacao())) {
1172 
                        if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.DATA.getValor())) {
1173 
                                sql.append("ORDER BY l.venda.dataVenda DESC ");
1174 
                        } else {
1175 
                                sql.append("GROUP BY l.produto ");
1176 
                                if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.LUCRO.getValor())) {
1177 
                                        sql.append("ORDER BY SUM(l.valorVenda - l.valorCompra) DESC ");
1178 
                                } else if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.QUANTIDADE.getValor())) {
1179 
                                        sql.append("ORDER BY COUNT(l.produto) DESC ");
1180 
                                } else if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.VALOR_VENDIDO.getValor())) {
1181 
                                        sql.append("ORDER BY SUM(l.valorVenda) DESC ");
1182 
                                }
1183 
                        }
1184 
                } else {
1185 
                        sql.append("ORDER BY l.venda.dataVenda DESC ");
1186 
                }
1187 
                try {
1188 
                        TypedQuery<RankingProdutoDTO> query = getEntityManager().createQuery(sql.toString(), RankingProdutoDTO.class)
1189 
                                        .setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial()))
582 blopes 1190 
                                        .setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal()));
1191 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getQuantidadeProdutos())) {
1192 
                                query.setMaxResults(parametrosConsulta.getQuantidadeProdutos());
1193 
                        }
229 espaco 1194 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
1195 
                                query.setParameter("sequencialLoja", parametrosConsulta.getLoja().getSequencial());
1196 
                        }
1197 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
1198 
                                query.setParameter("tipoProduto", parametrosConsulta.getTipoProduto());
1199 
                        }
1200 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getProduto())) {
1201 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCodigo())) {
1202 
                                        query.setParameter("codigo", parametrosConsulta.getProduto().getCodigoProdutoPadrao());
1203 
                                }
1204 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getDescricao())) {
1205 
                                        query.setParameter("descricao", "%" + removerAcentuacao(parametrosConsulta.getProduto().getDescricao()) + "%");
1206 
                                }
1207 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getEstilo())) {
1208 
                                        query.setParameter("tipoEstilo", parametrosConsulta.getProduto().getEstilo());
1209 
                                }
1210 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCor())) {
1211 
                                        query.setParameter("tipoCor", parametrosConsulta.getProduto().getCor());
1212 
                                }
1213 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getGenero())) {
1214 
                                        query.setParameter("tipoGenero", parametrosConsulta.getProduto().getGenero());
1215 
                                }
1216 
                        }
1217 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getMarca())) {
1218 
                                query.setParameter("sequencialMarcaDoModelo", parametrosConsulta.getMarca().getSequencial());
1219 
                        }
1220 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
1221 
                                query.setParameter("sequencialModelo", parametrosConsulta.getModelo().getSequencial());
1222 
                        }
1223 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getFornecedor())) {
1224 
                                query.setParameter("fornecedor", parametrosConsulta.getFornecedor());
1225 
                        }
1226 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getVendedor())) {
1227 
                                query.setParameter("vendedor", parametrosConsulta.getVendedor());
1228 
                        }
582 blopes 1229 
 
229 espaco 1230 
                        /*if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSomenteParaComprar())) {
1231 
                                query.setParameter("quantidadeMinimaComprar", parametrosConsulta.getQuantidadeMinimaComprar());
1232 
                        }*/
1233 
                        /*if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getTipoOrdenacao())) {
1234 
                                if (!parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.DATA.getValor())) {
1235 
                                        query.setParameter("dataDoisMesesAnterior", DataUtils.acrescentarMeses(DataUtils.getDataComHorarioMinimo(DataUtils.getDataAtual()), -2));
1236 
                                }
1237 
                        }*/
582 blopes 1238 
 
229 espaco 1239 
                        return query.getResultList();
1240 
                } catch(Exception ex) {
1241 
                        ex.printStackTrace();
1242 
                        return null;
1243 
                }
1244 
        }
1245 
 
583 blopes 1246 
        @Override
1247 
        public List<RankingProdutoDTONovo> consultarProdutosVendidosDTO(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
1248 
                StringBuilder sql = new StringBuilder();
1249 
                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)");
1250 
                sql.append(adicionarEstoque(parametrosConsulta));
1251 
                sql.append(adicionarSolicitacaoCompraProduto());
1252 
                sql.append(") FROM Lancamento l ");
1253 
                sql.append("WHERE l.venda.dataVenda >= :dataInicial AND l.venda.dataVenda <= :dataFinal ");
1254 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
1255 
                        sql.append("AND l.venda.loja.sequencial = :sequencialLoja ");
1256 
                }
1257 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
1258 
                        sql.append("AND l.produto.tipo = :tipoProduto ");
1259 
                }
1260 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getProduto())) {
1261 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCodigo())) {
1262 
                                sql.append("AND l.produto.codigo = :codigo ");
1263 
                        }
1264 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getDescricao())) {
1265 
                                sql.append("AND ");
1266 
                                sql.append(sqlConsultarSemAcento("l.produto.descricao"));
1267 
                                sql.append(" like upper(:descricao) ");
1268 
                        }
1269 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getEstilo())) {
1270 
                                sql.append("AND l.produto.estilo = :tipoEstilo ");
1271 
                        }
1272 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCor())) {
1273 
                                sql.append("AND l.produto.cor = :tipoCor ");
1274 
                        }
1275 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getGenero())) {
1276 
                                sql.append("AND l.produto.genero = :tipoGenero ");
1277 
                        }
1278 
                }
1279 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getMarca())) {
1280 
                        sql.append("AND l.produto.modelo.marca.sequencial = :sequencialMarcaDoModelo ");
1281 
                }
1282 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
1283 
                        sql.append("AND l.produto.modelo.sequencial = :sequencialModelo ");
1284 
                }
1285 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getFornecedor())) {
1286 
                        sql.append("AND :fornecedor in (SELECT fp.fornecedor FROM FornecedorProduto fp WHERE fp.produto.sequencial = l.produto.sequencial) ");
1287 
                }
1288 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getVendedor())) {
1289 
                        sql.append("AND l.venda.vendedor = :vendedor ");
1290 
                }
1291 
 
1292 
                sql.append("GROUP BY l.produto ");
1293 
                sql.append("ORDER BY COUNT(l.produto) DESC ");
1294 
                try {
1295 
                        TypedQuery<RankingProdutoDTONovo> query = getEntityManager().createQuery(sql.toString(), RankingProdutoDTONovo.class)
1296 
                                        .setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial()))
1297 
                                        .setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal()));
1298 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getQuantidadeProdutos())) {
1299 
                                query.setMaxResults(parametrosConsulta.getQuantidadeProdutos());
1300 
                        }
1301 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
1302 
                                query.setParameter("sequencialLoja", parametrosConsulta.getLoja().getSequencial());
1303 
                        }
1304 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
1305 
                                query.setParameter("tipoProduto", parametrosConsulta.getTipoProduto());
1306 
                        }
1307 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getProduto())) {
1308 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCodigo())) {
1309 
                                        query.setParameter("codigo", parametrosConsulta.getProduto().getCodigoProdutoPadrao());
1310 
                                }
1311 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getDescricao())) {
1312 
                                        query.setParameter("descricao", "%" + removerAcentuacao(parametrosConsulta.getProduto().getDescricao()) + "%");
1313 
                                }
1314 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getEstilo())) {
1315 
                                        query.setParameter("tipoEstilo", parametrosConsulta.getProduto().getEstilo());
1316 
                                }
1317 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCor())) {
1318 
                                        query.setParameter("tipoCor", parametrosConsulta.getProduto().getCor());
1319 
                                }
1320 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getGenero())) {
1321 
                                        query.setParameter("tipoGenero", parametrosConsulta.getProduto().getGenero());
1322 
                                }
1323 
                        }
1324 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getMarca())) {
1325 
                                query.setParameter("sequencialMarcaDoModelo", parametrosConsulta.getMarca().getSequencial());
1326 
                        }
1327 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
1328 
                                query.setParameter("sequencialModelo", parametrosConsulta.getModelo().getSequencial());
1329 
                        }
1330 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getFornecedor())) {
1331 
                                query.setParameter("fornecedor", parametrosConsulta.getFornecedor());
1332 
                        }
1333 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getVendedor())) {
1334 
                                query.setParameter("vendedor", parametrosConsulta.getVendedor());
1335 
                        }
1336 
 
1337 
                        /*if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSomenteParaComprar())) {
1338 
                                query.setParameter("quantidadeMinimaComprar", parametrosConsulta.getQuantidadeMinimaComprar());
1339 
                        }*/
1340 
                        /*if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getTipoOrdenacao())) {
1341 
                                if (!parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.DATA.getValor())) {
1342 
                                        query.setParameter("dataDoisMesesAnterior", DataUtils.acrescentarMeses(DataUtils.getDataComHorarioMinimo(DataUtils.getDataAtual()), -2));
1343 
                                }
1344 
                        }*/
1345 
 
1346 
                        return query.getResultList();
1347 
                } catch(Exception ex) {
1348 
                        ex.printStackTrace();
1349 
                        return null;
1350 
                }
1351 
        }
1352 
 
582 blopes 1353 
        /*
229 espaco 1354 
        @Override
1355 
        public List<RankingProdutoDTO> consultarProdutosVendidosResumido(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
1356 
                StringBuilder sql = new StringBuilder();
1357 
                sql.append("SELECT CAST(l.seq_produto AS VARCHAR), COUNT(l.seq_produto) ");
1358 
                sql.append(adicionarEstoqueSqlNativo(parametrosConsulta));
1359 
                sql.append(" FROM sc_sec.sec_lancamento l ");
1360 
                sql.append("LEFT JOIN sc_sec.sec_venda v ON v.seq_venda = l.seq_venda ");
1361 
                sql.append("LEFT JOIN sc_sec.sec_loja lj ON v.seq_loja = lj.seq_loja ");
1362 
                sql.append("LEFT JOIN sc_sec.sec_produto p ON p.seq_produto = l.seq_produto ");
1363 
                sql.append("LEFT JOIN sc_sec.sec_modelo m ON m.seq_modelo = p.seq_modelo ");
1364 
                sql.append("LEFT JOIN sc_sec.sec_marca ma ON ma.seq_marca = m.seq_marca ");
1365 
                sql.append("WHERE v.dth_venda >= :dataInicial AND v.dth_venda <= :dataFinal ");
1366 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
1367 
                        sql.append("AND lj.seq_loja = :sequencialLoja ");
1368 
                }
1369 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
1370 
                        sql.append("AND p.tip_produto = :tipoProduto ");
1371 
                }
1372 
 
1373 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getProduto())) {
1374 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getSequencial())) {
1375 
                                sql.append("AND p.seq_produto = :sequencialProduto ");
1376 
                        }
1377 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCodigo())) {
1378 
                                sql.append("AND p.cod_produto = :codigo ");
1379 
                        }
1380 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getDescricao())) {
1381 
                                sql.append("AND ");
1382 
                                sql.append(sqlConsultarSemAcento("p.dsc_produto"));
1383 
                                sql.append(" like upper(:descricao) ");
1384 
                        }
1385 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getEstilo())) {
1386 
                                sql.append("AND p.tip_estilo = :tipoEstilo ");
1387 
                        }
1388 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCor())) {
1389 
                                sql.append("AND p.tip_cor = :tipoCor ");
1390 
                        }
1391 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getGenero())) {
1392 
                                sql.append("AND p.tip_genero = :tipoGenero ");
1393 
                        }
1394 
                }
1395 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getMarca())) {
1396 
                        sql.append("AND ma.seq_marcal = :sequencialMarcaDoModelo ");
1397 
                }
1398 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
1399 
                        sql.append("AND m.seq_modelo = :sequencialModelo ");
1400 
                }
1401 
 
1402 
                sql.append("GROUP BY l.seq_produto ");
1403 
//              if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.QUANTIDADE.getValor())) {
1404 
//                      sql.append("ORDER BY COUNT(l.seq_produto) DESC ");
1405 
//              }
1406 
                try {
1407 
                        Query query = getEntityManager().createNativeQuery(sql.toString())
1408 
                                        .setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial()))
1409 
                                        .setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal()));
1410 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getPrimeiroRegistro())) {
1411 
                                if (parametrosConsulta.getPrimeiroRegistro() > 0) {
1412 
                                        query.setFirstResult(parametrosConsulta.getPrimeiroRegistro());
1413 
                                }
1414 
                        }
1415 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTamanhoPagina())) {
1416 
                                if (parametrosConsulta.getTamanhoPagina() > 0) {
1417 
                                        query.setMaxResults(parametrosConsulta.getTamanhoPagina());
1418 
                                } else {
1419 
                                        query.setMaxResults(parametrosConsulta.getQuantidadeProdutos());
1420 
                                }
1421 
                        } else {
1422 
                                query.setMaxResults(parametrosConsulta.getQuantidadeProdutos());
1423 
                        }
1424 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
1425 
                                query.setParameter("sequencialLoja", parametrosConsulta.getLoja().getSequencial());
1426 
                        }
1427 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
1428 
                                query.setParameter("tipoProduto", parametrosConsulta.getTipoProduto());
1429 
                        }
1430 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getProduto())) {
1431 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getSequencial())) {
1432 
                                        query.setParameter("sequencialProduto", parametrosConsulta.getProduto().getSequencial());
1433 
                                }
1434 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCodigo())) {
1435 
                                        query.setParameter("codigo", parametrosConsulta.getProduto().getCodigoProdutoPadrao());
1436 
                                }
1437 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getDescricao())) {
1438 
                                        query.setParameter("descricao", "%" + removerAcentuacao(parametrosConsulta.getProduto().getDescricao()) + "%");
1439 
                                }
1440 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getEstilo())) {
1441 
                                        query.setParameter("tipoEstilo", parametrosConsulta.getProduto().getEstilo());
1442 
                                }
1443 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCor())) {
1444 
                                        query.setParameter("tipoCor", parametrosConsulta.getProduto().getCor());
1445 
                                }
1446 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getGenero())) {
1447 
                                        query.setParameter("tipoGenero", parametrosConsulta.getProduto().getGenero());
1448 
                                }
1449 
                        }
1450 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getMarca())) {
1451 
                                query.setParameter("sequencialMarcaDoModelo", parametrosConsulta.getMarca().getSequencial());
1452 
                        }
1453 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
1454 
                                query.setParameter("sequencialModelo", parametrosConsulta.getModelo().getSequencial());
1455 
                        }
1456 
                        List<Object[]> resultList = query.getResultList();
1457 
                        List<RankingProdutoDTO> produtos = new ArrayList<RankingProdutoDTO>();
1458 
                        for (Object[] objects : resultList) {
1459 
                                RankingProdutoDTO rankingProduto = new RankingProdutoDTO();
1460 
                                Produto produto = new Produto();
1461 
                                if (VerificadorUtil.naoEstaNulo(objects[0])) {
1462 
                                        produto.setSequencial(Long.parseLong(objects[0].toString()));
1463 
                                }
1464 
                                rankingProduto.setProduto(produto);
1465 
                                if (VerificadorUtil.naoEstaNulo(objects[1])) {
1466 
                                        rankingProduto.setQuantidadeVendas(Long.parseLong(objects[1].toString()));
1467 
                                }
1468 
                                if (VerificadorUtil.naoEstaNulo(objects[2])) {
1469 
                                        rankingProduto.setQuantidadeEstoque(Long.parseLong(objects[2].toString()));
1470 
                                }
1471 
                                produtos.add(rankingProduto);
1472 
                        }
1473 
                        return produtos;
1474 
                } catch(Exception ex) {
1475 
                        ex.printStackTrace();
1476 
                        return null;
1477 
                }
1478 
        }
1479 
 
1480 
        @Override
1481 
        public List<RankingProdutoDTO> consultarProdutosParaTransferir(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
1482 
                StringBuilder sql = new StringBuilder();
1483 
                sql.append("SELECT CAST(l.seq_produto AS VARCHAR) AS produto, COUNT(l.seq_produto) AS vendas ");
1484 
                sql.append(" FROM sc_sec.sec_lancamento l ");
1485 
                sql.append("LEFT JOIN sc_sec.sec_venda v ON v.seq_venda = l.seq_venda ");
1486 
                sql.append("LEFT JOIN sc_sec.sec_loja lj ON v.seq_loja = lj.seq_loja ");
1487 
                sql.append("LEFT JOIN sc_sec.sec_produto p ON p.seq_produto = l.seq_produto ");
1488 
                sql.append("LEFT JOIN sc_sec.sec_modelo m ON m.seq_modelo = p.seq_modelo ");
1489 
                sql.append("LEFT JOIN sc_sec.sec_marca ma ON ma.seq_marca = m.seq_marca ");
1490 
                sql.append("WHERE ");
1491 
                sql.append(adicionarParametrosSqlNativo(parametrosConsulta));
1492 
                sql.append("GROUP BY l.seq_produto, ma.dsc_marca, m.dsc_modelo ");
1493 
                sql.append("HAVING ");
1494 
                for (Loja loja : parametrosConsulta.getLojasParaConsulta()) {
1495 
                        sql.append(adicionarHavingSqlNativo(parametrosConsulta, loja.getSequencial()));
1496 
                        sql.append(" OR ");
1497 
                }
1498 
                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 (");
1499 
                for (Loja loja : parametrosConsulta.getLojasParaConsulta()) {
1500 
                        sql.append(" ").append(loja.getSequencial()).append(", ");
1501 
                }
1502 
                sql.deleteCharAt(sql.length()-1);
1503 
                sql.deleteCharAt(sql.length()-1);
1504 
                sql.append(" )) = 0 ");
1505 
                sql.append("ORDER BY ma.dsc_marca, m.dsc_modelo ");
1506 
                try {
1507 
                        Query query = getEntityManager().createNativeQuery(sql.toString())
1508 
                                        .setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial()))
1509 
                                        .setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal()));
1510 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getPrimeiroRegistro())) {
1511 
                                if (parametrosConsulta.getPrimeiroRegistro() > 0) {
1512 
                                        query.setFirstResult(parametrosConsulta.getPrimeiroRegistro());
1513 
                                }
1514 
                        }
1515 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTamanhoPagina())) {
1516 
                                if (parametrosConsulta.getTamanhoPagina() > 0) {
1517 
                                        query.setMaxResults(parametrosConsulta.getTamanhoPagina());
1518 
                                } else {
1519 
                                        query.setMaxResults(parametrosConsulta.getQuantidadeProdutos());
1520 
                                }
1521 
                        } else {
1522 
                                query.setMaxResults(parametrosConsulta.getQuantidadeProdutos());
1523 
                        }
1524 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
1525 
                                query.setParameter("sequencialLoja", parametrosConsulta.getLoja().getSequencial());
1526 
                        }
1527 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
1528 
                                query.setParameter("tipoProduto", parametrosConsulta.getTipoProduto());
1529 
                        }
1530 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getProduto())) {
1531 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getSequencial())) {
1532 
                                        query.setParameter("sequencialProduto", parametrosConsulta.getProduto().getSequencial());
1533 
                                }
1534 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCodigo())) {
1535 
                                        query.setParameter("codigo", parametrosConsulta.getProduto().getCodigoProdutoPadrao());
1536 
                                }
1537 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getDescricao())) {
1538 
                                        query.setParameter("descricao", "%" + removerAcentuacao(parametrosConsulta.getProduto().getDescricao()) + "%");
1539 
                                }
1540 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getEstilo())) {
1541 
                                        query.setParameter("tipoEstilo", parametrosConsulta.getProduto().getEstilo());
1542 
                                }
1543 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCor())) {
1544 
                                        query.setParameter("tipoCor", parametrosConsulta.getProduto().getCor());
1545 
                                }
1546 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getGenero())) {
1547 
                                        query.setParameter("tipoGenero", parametrosConsulta.getProduto().getGenero());
1548 
                                }
1549 
                        }
1550 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getMarca())) {
1551 
                                query.setParameter("sequencialMarcaDoModelo", parametrosConsulta.getMarca().getSequencial());
1552 
                        }
1553 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
1554 
                                query.setParameter("sequencialModelo", parametrosConsulta.getModelo().getSequencial());
1555 
                        }
274 espaco 1556 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getIndicadorModeloFavorito())) {
1557 
                                query.setParameter("indicadorModeloFavorito", parametrosConsulta.getIndicadorModeloFavorito());
1558 
                        }
229 espaco 1559 
                        List<Object[]> resultList = query.getResultList();
1560 
                        List<RankingProdutoDTO> produtos = new ArrayList<RankingProdutoDTO>();
1561 
                        for (Object[] objects : resultList) {
1562 
                                RankingProdutoDTO rankingProduto = new RankingProdutoDTO();
1563 
                                Produto produto = new Produto();
1564 
                                if (VerificadorUtil.naoEstaNulo(objects[0])) {
1565 
                                        System.out.println(objects[0].toString());
1566 
                                        produto.setSequencial(Long.parseLong(objects[0].toString()));
1567 
                                }
1568 
                                rankingProduto.setProduto(produto);
1569 
                                produtos.add(rankingProduto);
1570 
                        }
1571 
                        return produtos;
1572 
                } catch(Exception ex) {
1573 
                        ex.printStackTrace();
1574 
                        return null;
1575 
                }
1576 
        }
1577 
 
1578 
        private String adicionarVendasSqlNativo(ParametrosConsultaProdutosVendidosDTO parametrosConsulta, Long sequencialLoja) {
1579 
                StringBuilder sql = new StringBuilder("");
1580 
                sql.append(", (SELECT COUNT(lanc.seq_produto) FROM sc_sec.sec_lancamento lanc ");
1581 
                sql.append("LEFT JOIN sc_sec.sec_venda v ON v.seq_venda = lanc.seq_venda ");
1582 
                sql.append("LEFT JOIN sc_sec.sec_loja lj ON v.seq_loja = lj.seq_loja ");
1583 
                sql.append("WHERE v.dth_venda >= :dataInicial AND v.dth_venda <= :dataFinal ");
1584 
                sql.append("AND lanc.seq_produto = l.seq_produto AND lj.seq_loja = ");
1585 
                sql.append(sequencialLoja);
1586 
                sql.append(" GROUP BY lanc.seq_produto) AS vendas" + sequencialLoja + " ");
1587 
                return sql.toString();
1588 
        }
1589 
 
1590 
        private String adicionarEstoqueSqlNativo(ParametrosConsultaProdutosVendidosDTO parametrosConsulta, Long sequencialLoja) {
1591 
                StringBuilder sql = new StringBuilder();
1592 
                sql.append(", (SELECT SUM(pl.qtd_estoque) FROM sc_sec.sec_produto_loja pl ");
1593 
                sql.append("WHERE pl.seq_produto = l.seq_produto ");
1594 
                sql.append("AND pl.seq_loja = ");
1595 
                sql.append(sequencialLoja);
1596 
                sql.append(") AS estoque" + sequencialLoja + " ");
1597 
                return sql.toString();
1598 
        }
1599 
 
1600 
        private String adicionarHavingSqlNativo(ParametrosConsultaProdutosVendidosDTO parametrosConsulta, Long sequencialLoja) {
1601 
                StringBuilder sql = new StringBuilder();
1602 
                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 = ");
1603 
                sql.append(sequencialLoja);
1604 
                sql.append(") - (");
1605 
                sql.append("SELECT COUNT(lanc.seq_produto) FROM sc_sec.sec_lancamento lanc ");
1606 
                sql.append("LEFT JOIN sc_sec.sec_venda v ON v.seq_venda = lanc.seq_venda ");
1607 
                sql.append("LEFT JOIN sc_sec.sec_loja lj ON v.seq_loja = lj.seq_loja ");
1608 
                sql.append("WHERE v.dth_venda >= :dataInicial AND v.dth_venda <= :dataFinal AND lanc.seq_produto = l.seq_produto ");
1609 
                sql.append("AND lj.seq_loja = ");
1610 
                sql.append(sequencialLoja);
1611 
                sql.append(" GROUP BY lanc.seq_produto) ");
1612 
                sql.append("* 1) * -1 > 0 ");
1613 
                return sql.toString();
1614 
        }
1615 
 
1616 
        private String adicionarEstoqueSqlNativo(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
1617 
                StringBuilder sql = new StringBuilder();
1618 
                sql.append(", (");
1619 
                sql.append("SELECT SUM(pl.qtd_estoque) FROM sc_sec.sec_produto_loja pl ");
1620 
                sql.append("WHERE pl.seq_produto = l.seq_produto ");
1621 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
1622 
                        sql.append("AND pl.seq_loja = :sequencialLoja ");
1623 
                }
1624 
                sql.append(") ");
1625 
                return sql.toString();
1626 
        }
1627 
 
1628 
        private String adicionarParametrosSqlNativo(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
1629 
                StringBuilder sql = new StringBuilder("v.dth_venda >= :dataInicial AND v.dth_venda <= :dataFinal ");
1630 
 
1631 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLojaSelecionada()) &&
1632 
                                VerificadorUtil.naoEstaNulo(parametrosConsulta.getEstoqueMinimo())) {
1633 
                        sql.append("AND (");
1634 
                        sql.append("SELECT SUM(pl.qtd_estoque) FROM sc_sec.sec_produto_loja pl ");
1635 
                        sql.append("WHERE pl.seq_produto = l.seq_produto ");
1636 
                        sql.append("AND pl.seq_loja = ");
1637 
                        sql.append(parametrosConsulta.getLojaSelecionada().getSequencial());
1638 
                        sql.append(") >= ");
1639 
                        sql.append(parametrosConsulta.getEstoqueMinimo());
1640 
                        sql.append(" ");
1641 
                }
1642 
 
1643 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
1644 
                        sql.append("AND lj.seq_loja = :sequencialLoja ");
1645 
                }
1646 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
1647 
                        sql.append("AND p.tip_produto = :tipoProduto ");
1648 
                }
1649 
 
1650 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getProduto())) {
1651 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getSequencial())) {
1652 
                                sql.append("AND p.seq_produto = :sequencialProduto ");
1653 
                        }
1654 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCodigo())) {
1655 
                                sql.append("AND p.cod_produto = :codigo ");
1656 
                        }
1657 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getDescricao())) {
1658 
                                sql.append("AND ");
1659 
                                sql.append(sqlConsultarSemAcento("p.dsc_produto"));
1660 
                                sql.append(" like upper(:descricao) ");
1661 
                        }
1662 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getEstilo())) {
1663 
                                sql.append("AND p.tip_estilo = :tipoEstilo ");
1664 
                        }
1665 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCor())) {
1666 
                                sql.append("AND p.tip_cor = :tipoCor ");
1667 
                        }
1668 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getGenero())) {
1669 
                                sql.append("AND p.tip_genero = :tipoGenero ");
1670 
                        }
1671 
                }
1672 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getMarca())) {
1673 
                        sql.append("AND ma.seq_marcal = :sequencialMarcaDoModelo ");
1674 
                }
1675 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
1676 
                        sql.append("AND m.seq_modelo = :sequencialModelo ");
1677 
                }
274 espaco 1678 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getIndicadorModeloFavorito())) {
1679 
                        sql.append("AND m.ind_favorito = :indicadorModeloFavorito ");
1680 
                }
229 espaco 1681 
                return sql.toString();
1682 
        }
1683 
 
1684 
        @Override
1685 
        public List<RankingProdutoDTO> consultarProdutosMaisVendidos(Date dataInicial, Date dataFinal, Integer quantidadeProdutos, String tipoOrdenacao, Long sequencialLoja, String tipoProduto,
1686 
                        Produto produto, Marca marca) {
1687 
                StringBuilder sql = new StringBuilder();
1688 
                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 ");
1689 
                sql.append("WHERE l.venda.dataVenda >= :dataInicial AND l.venda.dataVenda <= :dataFinal ");
1690 
                if (VerificadorUtil.naoEstaNulo(sequencialLoja)) {
1691 
                        sql.append("AND l.venda.loja.sequencial = :sequencialLoja ");
1692 
                }
1693 
                if (VerificadorUtil.naoEstaNulo(tipoProduto)) {
1694 
                        sql.append("AND l.produto.tipo = :tipoProduto ");
1695 
                }
1696 
                if (VerificadorUtil.naoEstaNulo(produto)) {
1697 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getCodigo())) {
1698 
                                sql.append("AND l.produto.codigo = :codigo ");
1699 
                        }
1700 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getDescricao())) {
1701 
                                sql.append("AND ");
1702 
                                sql.append(sqlConsultarSemAcento("l.produto.descricao"));
1703 
                                sql.append(" like upper(:descricao) ");
1704 
                        }
1705 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getEstilo())) {
1706 
                                sql.append("AND l.produto.estilo = :tipoEstilo ");
1707 
                        }
1708 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getGenero())) {
1709 
                                sql.append("AND l.produto.genero = :tipoGenero ");
1710 
                        }
1711 
                }
1712 
                if (VerificadorUtil.naoEstaNulo(marca)) {
1713 
                        sql.append("AND l.produto.modelo.marca.sequencial = :sequencialMarcaDoModelo ");
1714 
                }
1715 
 
1716 
                sql.append("GROUP BY l.produto ");
1717 
                if (tipoOrdenacao.equals(TipoOrdenacaoMaisVendidos.LUCRO.getValor())) {
1718 
                        sql.append("ORDER BY SUM(l.valorVenda - l.valorCompra) DESC ");
1719 
                } else if (tipoOrdenacao.equals(TipoOrdenacaoMaisVendidos.QUANTIDADE.getValor())) {
1720 
                        sql.append("ORDER BY COUNT(l.produto) DESC ");
1721 
                } else if (tipoOrdenacao.equals(TipoOrdenacaoMaisVendidos.VALOR_VENDIDO.getValor())) {
1722 
                        sql.append("ORDER BY SUM(l.valorVenda) DESC ");
1723 
                }
1724 
                try {
1725 
                        TypedQuery<RankingProdutoDTO> query = getEntityManager().createQuery(sql.toString(), RankingProdutoDTO.class)
1726 
                                        .setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(dataInicial))
1727 
                                        .setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(dataFinal))
1728 
                                        .setMaxResults(quantidadeProdutos);
1729 
                        if (VerificadorUtil.naoEstaNulo(sequencialLoja)) {
1730 
                                query.setParameter("sequencialLoja", sequencialLoja);
1731 
                        }
1732 
                        if (VerificadorUtil.naoEstaNulo(tipoProduto)) {
1733 
                                query.setParameter("tipoProduto", tipoProduto);
1734 
                        }
1735 
                        if (VerificadorUtil.naoEstaNulo(produto)) {
1736 
                                if (VerificadorUtil.naoEstaNuloOuVazio(produto.getCodigo())) {
1737 
                                        query.setParameter("codigo", produto.getCodigoProdutoPadrao());
1738 
                                }
1739 
                                if (VerificadorUtil.naoEstaNuloOuVazio(produto.getDescricao())) {
1740 
                                        query.setParameter("descricao", "%" + removerAcentuacao(produto.getDescricao()) + "%");
1741 
                                }
1742 
                                if (VerificadorUtil.naoEstaNuloOuVazio(produto.getEstilo())) {
1743 
                                        query.setParameter("tipoEstilo", produto.getEstilo());
1744 
                                }
1745 
                                if (VerificadorUtil.naoEstaNuloOuVazio(produto.getGenero())) {
1746 
                                        query.setParameter("tipoGenero", produto.getGenero());
1747 
                                }
1748 
                        }
1749 
                        if (VerificadorUtil.naoEstaNulo(marca)) {
1750 
                                query.setParameter("sequencialMarcaDoModelo", marca.getSequencial());
1751 
                        }
1752 
                        return query.getResultList();
1753 
                } catch(Exception ex) {
1754 
                        ex.printStackTrace();
1755 
                        return null;
1756 
                }
1757 
        }
1758 
 
1759 
        private String adicionarQueryConsultaDoEstoque(Long sequencialLoja, Modelo modelo, String tipoProduto, String estiloProduto) {
1760 
                try {
1761 
                        TypedQuery<Long> query = getEntityManager().createQuery(sql.toString(), Long.class);
1762 
                        if (VerificadorUtil.naoEstaNuloOuVazio(sequencialLoja)) {
1763 
                                query.setParameter("sequencialLoja", sequencialLoja);
1764 
                        }
1765 
                        if (VerificadorUtil.naoEstaNuloOuVazio(tipoProduto)) {
1766 
                                query.setParameter("tipoProduto", tipoProduto);
1767 
                        }
1768 
                        if (VerificadorUtil.naoEstaNuloOuVazio(estiloProduto)) {
1769 
                                query.setParameter("estiloProduto", estiloProduto);
1770 
                        }
1771 
//                              if (VerificadorUtil.naoEstaNuloOuVazio(genero)) {
1772 
//                                      query.setParameter("tipoGenero", genero);
1773 
//                              }
1774 
                        query.setParameter("sequencialModelo", modelo.getSequencial());
1775 
//                              if (VerificadorUtil.naoEstaNuloOuVazio(descricaoProduto)) {
1776 
//                                      query.setParameter("descricaoProduto", "%" + removerAcentuacao(descricaoProduto) + "%");
1777 
//                              }
1778 
                        return sql.toString();
1779 
        }
1780 
*/
1781 
/*
1782 
        @Override
1783 
        public List<VendasDTO> consultarVendas(ParametrosConsultaVendasDTO parametrosConsultaVendasDTO) {
1784 
                StringBuilder sql = new StringBuilder();
1785 
                try {
1786 
                        sql.append("SELECT ");
1787 
                        sql.append("v.seq_venda, ");
1788 
                        sql.append("l.dsc_loja, v.dth_venda, ");
1789 
                        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), ");
1790 
                        sql.append("v.tip_situacao, ");
1791 
                        sql.append("us.dsc_nome, v.dsc_observacao, ");
1792 
                        sql.append("p.cod_produto, m.dsc_modelo, p.dsc_produto, lanc.val_venda ");
1793 
                        sql.append("FROM sc_sec.sec_venda v ");
1794 
                        sql.append("LEFT JOIN sc_sec.sec_loja l ON l.seq_loja = v.seq_loja ");
1795 
                        sql.append("LEFT JOIN sc_sec.sec_vendedor ve ON ve.seq_vendedor = v.seq_vendedor ");
1796 
                        sql.append("LEFT JOIN sc_sec.sec_usuario us ON us.seq_pessoa = ve.seq_pessoa ");
1797 
                        sql.append("LEFT JOIN sc_sec.sec_lancamento lanc ON lanc.seq_venda = v.seq_venda ");
1798 
                        sql.append("LEFT JOIN sc_sec.sec_produto p ON p.seq_produto = lanc.seq_produto ");
1799 
                        sql.append("LEFT JOIN sc_sec.sec_modelo m ON m.seq_modelo = p.seq_modelo ");
1800 
                        sql.append("WHERE 1=1 ");
1801 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getLoja())) {
1802 
                                sql.append("AND l.seq_loja.sequencial = :sequencialLoja ");
1803 
                        }
1804 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getSituacaoVenda())) {
1805 
                                sql.append("AND v.tip_situacao = :tipoSituacao ");
1806 
                        }
1807 
//                      if (VerificadorUtil.naoEstaNuloOuVazio(((ParametrosConsultaVendasDTO)parametros).getVendedor())) {
1808 
//                              sql.append("AND e.vendedor.sequencial = :sequencialVendedor ");
1809 
//                      }
1810 
//                      if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getIndicacao())) {
1811 
//                              sql.append("AND e.indicacao.sequencial = :sequencialIndicacao ");
1812 
//                      }
1813 
*/
1814 
                        //TODO: VERIFICAR LANÇAMENTOS COM MAIS PAGAMENTOS QUE LANÇAMENTOS
1815 
                        /*
1816 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getSituacaoFinanceiraVenda())) {
1817 
                                if (parametrosConsultaVendasDTO.getSituacaoFinanceiraVenda().equals(br.com.ec.domain.model.tipos.TipoSituacaoFinanceira.NENHUMA.getValor())) {
1818 
                                        sql.append("AND (SELECT COUNT(c) FROM Conta c WHERE c.venda = e) = 0 ");
1819 
//                                              sql.append("AND ((SELECT COUNT(vf) FROM VendaFormaPagamento vf WHERE vf.venda = e) > (SELECT COUNT(cr) FROM ContaAReceber cr WHERE cr.venda = e)) ");
1820 
                                }
1821 
                                if (parametrosConsultaVendasDTO.getSituacaoFinanceiraVenda().equals(br.com.ec.domain.model.tipos.TipoSituacaoFinanceira.QUITADO.getValor())) {
1822 
                                        sql.append("AND (SELECT COUNT(p) FROM Parcela p WHERE p.conta.venda = e AND p.dataPagamento is null AND p.indicadorAtivo = true) = 0 ");
1823 
                                        sql.append("AND (SELECT COUNT(c) FROM Conta c WHERE c.venda = e AND c.indicadorAtivo = true) > 0 ");
1824 
                                }
1825 
                                if (parametrosConsultaVendasDTO.getSituacaoFinanceiraVenda().equals(br.com.ec.domain.model.tipos.TipoSituacaoFinanceira.PENDENCIAS.getValor())) {
1826 
                                        sql.append("AND ((SELECT COUNT(p) FROM Parcela p WHERE p.conta.venda = e AND p.dataPagamento is null AND p.indicadorAtivo = true) > 0 ");
1827 
                                        sql.append("OR (SELECT COUNT(c) FROM Conta c WHERE c.venda = e AND c.indicadorAtivo = true) = 0) ");
1828 
                                }
1829 
                        }
1830 
                        */
1831 
/*     
1832 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getDataVendas())
1833 
                                        || VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getDataInicial())
1834 
                                        || VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getDataFinal())) {
1835 
                                sql.append("AND v.dth_venda >= :dataInicial ");
1836 
                                sql.append("AND v.dth_venda <= :dataFinal ");
1837 
                        }
1838 
 
1839 
                        sql.append("ORDER BY v.seq_venda ");
1840 
 
1841 
                        Query query = getEntityManager().createNativeQuery(sql.toString());
1842 
 
1843 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getLoja())) {
1844 
                                query.setParameter("sequencialLoja", parametrosConsultaVendasDTO.getLoja().getSequencial());
1845 
                        }
1846 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getSituacaoVenda())) {
1847 
                                query.setParameter("tipoSituacao", parametrosConsultaVendasDTO.getSituacaoVenda());
1848 
                        }
1849 
//                      if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getVendedor())) {
1850 
//                              query.setParameter("sequencialVendedor", parametrosConsultaVendasDTO.getVendedor().getSequencial());
1851 
//                      }
1852 
//                      if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getIndicacao())) {
1853 
//                              query.setParameter("sequencialIndicacao", ((ParametrosConsultaVendasDTO)parametros).getIndicacao().getSequencial());
1854 
//                      }
1855 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getDataInicial())
1856 
                                        && VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getDataFinal())) {
1857 
                                Date dataInicial = DataUtils.getDataComHorarioMinimo(parametrosConsultaVendasDTO.getDataInicial());
1858 
                                Date dataFinal = DataUtils.getDataComHorarioMaximo(parametrosConsultaVendasDTO.getDataFinal());
1859 
                                query.setParameter("dataInicial", dataInicial);
1860 
                                query.setParameter("dataFinal", dataFinal);
1861 
                        } else if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getDataVendas())) {
1862 
                                Date dataInicial = DataUtils.getDataComHorarioMinimo(parametrosConsultaVendasDTO.getDataVendas());
1863 
                                Date dataFinal = DataUtils.getDataComHorarioMaximo(parametrosConsultaVendasDTO.getDataVendas());
1864 
                                query.setParameter("dataInicial", dataInicial);
1865 
                                query.setParameter("dataFinal", dataFinal);
1866 
                        }
1867 
 
1868 
                        List<Object[]> resultList = query.getResultList();
1869 
 
1870 
                        List<VendasDTO> vendas = new ArrayList<VendasDTO>();
1871 
 
1872 
                        // PREENCHER VENDAS
1873 
                        for (Object[] objects : resultList) {
1874 
                                VendasDTO venda = new VendasDTO();
1875 
                                venda.setSequencial(Long.parseLong(objects[0].toString()));
1876 
                                if (!vendas.contains(venda)) {
1877 
                                        venda.setDescricaoLoja(objects[1].toString());
1878 
//                                      System.out.println(objects[2].toString());
1879 
//                                      venda.setDataVenda(new Date(objects[2].toString()));
1880 
                                        venda.setValorVenda(Double.parseDouble(objects[3].toString()));
1881 
                                        venda.setTipoSituacao(objects[4].toString());
1882 
                                        venda.setNomeUsuario(objects[5].toString());
1883 
                                        venda.setObservacao(objects[6].toString());
1884 
                                        vendas.add(venda);
1885 
                                }
1886 
                        }
1887 
 
1888 
                        for (Object[] objects : resultList) {
1889 
                                VendasDTO venda = new VendasDTO();
1890 
                                venda.setSequencial(Long.parseLong(objects[0].toString()));
1891 
 
1892 
                                VendasLancamentoDTO lancamento = new VendasLancamentoDTO();
1893 
                                lancamento.setCodigoProduto(objects[7].toString());
1894 
                                if (VerificadorUtil.naoEstaNulo(objects[8])) {
1895 
                                        lancamento.setDescricaoModelo(objects[8].toString());
1896 
                                }
1897 
                                lancamento.setDescricaoProduto(objects[9].toString());
1898 
                                lancamento.setValorVenda(Double.parseDouble(objects[10].toString()));
1899 
 
1900 
                                VendasDTO vendaCompleta = vendas.get(vendas.indexOf(venda));
1901 
                                vendaCompleta.getLancamentos().add(lancamento);
1902 
                                vendas.remove(vendas.indexOf(venda));
1903 
                                vendas.add(vendaCompleta);
1904 
                        }
1905 
                        return vendas;
1906 
                } catch (NoResultException e) {
1907 
                        return null;
1908 
                }
1909 
        }
1910 
 
1911 
        @Override
1912 
        public Integer obterQuantidadeProdutosVendidosPorEstiloEeGenero(Date dataInicial, Date dataFinal, Long sequencialLoja, Long sequencialModelo, String tipoProduto, String estiloProduto, String tipoGenero) {
1913 
                StringBuilder sql = new StringBuilder();
1914 
                sql.append("SELECT COUNT(l) FROM Lancamento l ");
1915 
                sql.append("WHERE l.venda.dataVenda >= :dataInicial AND l.venda.dataVenda <= :dataFinal ");
1916 
                if (VerificadorUtil.naoEstaNulo(sequencialLoja)) {
1917 
                        sql.append("AND l.venda.loja.sequencial = :sequencialLoja ");
1918 
                }
1919 
                if (VerificadorUtil.naoEstaNulo(sequencialModelo)) {
1920 
                        sql.append("AND l.produto.modelo.sequencial = :sequencialModelo ");
1921 
                }
1922 
                if (VerificadorUtil.naoEstaNulo(tipoProduto)) {
1923 
                        sql.append("AND l.produto.tipo = :tipoProduto ");
1924 
                }
1925 
                if (VerificadorUtil.naoEstaNuloOuVazio(estiloProduto)) {
1926 
                        sql.append("AND l.produto.estilo = :tipoEstilo ");
1927 
                }
1928 
                if (VerificadorUtil.naoEstaNuloOuVazio(tipoGenero)) {
1929 
                        sql.append("AND l.produto.genero = :tipoGenero ");
1930 
                }
1931 
*/             
1932 
                /*sql.append("GROUP BY l.produto.estilo ");*/
1933 
/*     
1934 
                try {
1935 
                        TypedQuery<Long> query = getEntityManager().createQuery(sql.toString(), Long.class)
1936 
                                        .setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(dataInicial))
1937 
                                        .setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(dataFinal));
1938 
                        if (VerificadorUtil.naoEstaNulo(sequencialLoja)) {
1939 
                                query.setParameter("sequencialLoja", sequencialLoja);
1940 
                        }
1941 
                        if (VerificadorUtil.naoEstaNulo(sequencialModelo)) {
1942 
                                query.setParameter("sequencialModelo", sequencialModelo);
1943 
                        }
1944 
                        if (VerificadorUtil.naoEstaNulo(tipoProduto)) {
1945 
                                query.setParameter("tipoProduto", tipoProduto);
1946 
                        }
1947 
                        if (VerificadorUtil.naoEstaNuloOuVazio(estiloProduto)) {
1948 
                                query.setParameter("tipoEstilo", estiloProduto);
1949 
                        }
1950 
                        if (VerificadorUtil.naoEstaNuloOuVazio(tipoGenero)) {
1951 
                                query.setParameter("tipoGenero", tipoGenero);
1952 
                        }
1953 
                        return query.getSingleResult().intValue();
1954 
                } catch(Exception ex) {
1955 
                        ex.printStackTrace();
1956 
                        return null;
1957 
                }
1958 
        }
1959 
*/     
1960 
        /*
1961 
        @Override
1962 
        public RankingComprasTransferenciasEstiloDTO consultarVendasPorEstilo(ParametrosConsultaParaComprasTransferenciasDTO parametrosConsulta, Modelo modelo) {
1963 
                StringBuilder sql = new StringBuilder();
1964 
                sql.append("SELECT new br.com.ec.domain.dto.RankingComprasTransferenciasEstiloDTO(");
1965 
                sql.append("l.produto.estilo");
1966 
                sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, null) + ")");
1967 
                sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.UNISSEX.getValor()) + ")");
1968 
                sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.MASCULINO.getValor()) + ")");
1969 
                sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.FEMININO.getValor()) + ")");
1970 
                sql.append(", COUNT(0), COUNT(0), COUNT(0), COUNT(0)");
1971 
                sql.append(") FROM Lancamento l ");
1972 
                sql.append("WHERE l.venda.dataVenda >= :dataInicial AND l.venda.dataVenda <= :dataFinal ");
1973 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
1974 
                        sql.append("AND l.venda.loja.sequencial = :sequencialLoja ");
1975 
                }
1976 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
1977 
                        sql.append("AND l.produto.tipo = :tipoProduto ");
1978 
                }
1979 
                sql.append("AND l.produto.modelo = :modelo ");
1980 
                sql.append("AND l.produto.estilo = :estiloProduto ");
1981 
                sql.append("GROUP BY l.produto.estilo ");
1982 
                try {
1983 
                        TypedQuery<RankingComprasTransferenciasEstiloDTO> query = getEntityManager().createQuery(sql.toString(), RankingComprasTransferenciasEstiloDTO.class)
1984 
                                        .setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial()))
1985 
                                        .setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal()));
1986 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
1987 
                                query.setParameter("sequencialLoja", parametrosConsulta.getSequencialLoja());
1988 
                        }
1989 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
1990 
                                query.setParameter("tipoProduto", parametrosConsulta.getTipoProduto());
1991 
                        }
1992 
                        if (VerificadorUtil.naoEstaNulo(modelo)) {
1993 
                                query.setParameter("modelo", modelo);
1994 
                        }
1995 
                        query.setParameter("estiloProduto", parametrosConsulta.getEstilo());
1996 
                        return query.getSingleResult();
1997 
                } catch(NoResultException nr) {
1998 
                        RankingComprasTransferenciasEstiloDTO rankingComprasTransferenciasEstilo = new RankingComprasTransferenciasEstiloDTO();
1999 
                        rankingComprasTransferenciasEstilo.setEstilo(TipoEstiloProduto.parse(parametrosConsulta.getEstilo()));
2000 
                        return rankingComprasTransferenciasEstilo;
2001 
                } catch(Exception ex) {
2002 
                        ex.printStackTrace();
2003 
                        return null;
2004 
                }
2005 
        }
2006 
*/
2007 
/*
2008 
        private String adicionarConsultaQuantidadeVendasPorEstilo(ParametrosConsultaParaComprasTransferenciasDTO parametrosConsulta, String genero, Boolean consultarPorLoja) {
2009 
                StringBuilder sql = new StringBuilder();
2010 
                sql.append("SELECT COUNT(lanc) FROM Lancamento lanc ");
2011 
                sql.append("WHERE lanc.venda.dataVenda >= :dataInicial AND lanc.venda.dataVenda <= :dataFinal ");
2012 
                sql.append("AND lanc.produto.modelo = :modelo ");
2013 
                sql.append("AND lanc.produto.estilo = :estiloProduto ");
2014 
                if (consultarPorLoja) {
2015 
                        sql.append("AND lanc.venda.loja = l ");
2016 
                }
2017 
                sql.append("AND lanc.produto.genero = '" + genero + "' ");
2018 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
2019 
                        sql.append("AND lanc.produto.tipo = :tipoProduto ");
2020 
                }
2021 
                return sql.toString().trim();
2022 
        }
2023 
 
2024 
        @Override
2025 
        public RankingComprasTransferenciasEstiloDTO consultarEstoqueEeVendasPorEstilo(ParametrosConsultaParaComprasTransferenciasDTO parametrosConsulta, Modelo modelo) {
2026 
                StringBuilder sql = new StringBuilder();
2027 
                sql.append("SELECT new br.com.ec.domain.dto.RankingComprasTransferenciasEstiloDTO(");
2028 
                sql.append("pLoja.produto.estilo");
2029 
                sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.UNISSEX.getValor(), false) + ")");
2030 
                sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.MASCULINO.getValor(), false) + ")");
2031 
                sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.FEMININO.getValor(), false) + ")");
2032 
                sql.append(", (" + adicionarConsultaEstoquePorEstilo(parametrosConsulta, TipoGenero.UNISSEX.getValor(), false) + ")");
2033 
                sql.append(", (" + adicionarConsultaEstoquePorEstilo(parametrosConsulta, TipoGenero.MASCULINO.getValor(), false) + ")");
2034 
                sql.append(", (" + adicionarConsultaEstoquePorEstilo(parametrosConsulta, TipoGenero.FEMININO.getValor(), false) + ")");
2035 
                sql.append(", (" + adicionarConsultaPedidosCompraPorEstilo(parametrosConsulta, TipoGenero.UNISSEX.getValor()) + ")");
2036 
                sql.append(", (" + adicionarConsultaPedidosCompraPorEstilo(parametrosConsulta, TipoGenero.MASCULINO.getValor()) + ")");
2037 
                sql.append(", (" + adicionarConsultaPedidosCompraPorEstilo(parametrosConsulta, TipoGenero.FEMININO.getValor()) + ")");
2038 
                // ADICIONAR QUANTIDADE JÁ SOLCITADO PARA COMPRA (VERIFICADO + SOLICITADO)
2039 
                sql.append(") FROM ProdutoLoja pLoja ");
2040 
                sql.append("WHERE pLoja.produto.estilo = :estiloProduto ");
2041 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
2042 
                        sql.append("AND pLoja.loja.sequencialLoja = :sequencialLoja ");
2043 
                }
2044 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
2045 
                        sql.append("AND pLoja.produto.tipo = :tipoProduto ");
2046 
                }
2047 
                sql.append("AND pLoja.produto.modelo = :modelo ");
2048 
                sql.append("GROUP BY pLoja.produto.estilo ");
2049 
                try {
2050 
                        TypedQuery<RankingComprasTransferenciasEstiloDTO> query = getEntityManager().createQuery(sql.toString(), RankingComprasTransferenciasEstiloDTO.class);
2051 
                        query.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial()));
2052 
                        query.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal()));
2053 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
2054 
                                query.setParameter("sequencialLoja", parametrosConsulta.getSequencialLoja());
2055 
                        }
2056 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
2057 
                                query.setParameter("tipoProduto", parametrosConsulta.getTipoProduto());
2058 
                        }
2059 
                        if (VerificadorUtil.naoEstaNulo(modelo)) {
2060 
                                query.setParameter("modelo", modelo);
2061 
                        }
2062 
                        query.setParameter("estiloProduto", parametrosConsulta.getEstilo());
2063 
                        return query.getSingleResult();
2064 
                } catch(NoResultException nr) {
2065 
                        RankingComprasTransferenciasEstiloDTO rankingComprasTransferenciasEstilo = new RankingComprasTransferenciasEstiloDTO();
2066 
                        rankingComprasTransferenciasEstilo.setEstilo(TipoEstiloProduto.parse(parametrosConsulta.getEstilo()));
2067 
                        return rankingComprasTransferenciasEstilo;
2068 
                } catch(Exception ex) {
2069 
                        ex.printStackTrace();
2070 
                        return null;
2071 
                }
2072 
        }
2073 
 
2074 
        private String adicionarConsultaEstoquePorEstilo(ParametrosConsultaParaComprasTransferenciasDTO parametrosConsulta, String genero, Boolean consultarPorLoja) {
2075 
                StringBuilder sql = new StringBuilder();
2076 
                sql.append("SELECT SUM(pl.quantidadeEstoque) FROM ProdutoLoja pl ");
2077 
                sql.append("WHERE pl.produto.modelo = :modelo ");
2078 
                sql.append("AND pl.produto.estilo = :estiloProduto ");
2079 
                if (consultarPorLoja) {
2080 
                        sql.append("AND pl.loja = l ");
2081 
                }
2082 
                sql.append("AND pl.produto.genero = '" + genero + "' ");
2083 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
2084 
                        sql.append("AND pl.produto.tipo = :tipoProduto ");
2085 
                }
2086 
                return sql.toString().trim();
2087 
        }
2088 
 
2089 
        private String adicionarConsultaPedidosCompraPorEstilo(ParametrosConsultaParaComprasTransferenciasDTO parametrosConsulta, String genero) {
2090 
                StringBuilder sql = new StringBuilder();
2091 
                sql.append("SELECT SUM(ppc.quantidadeParaComprar) FROM ProdutoPedidoCompra ppc ");
2092 
                sql.append("WHERE ppc.status IN ('" + TipoStatusPedidoCompra.VERIFICADO.getValor() + "','" + TipoStatusPedidoCompra.SOLICITADO.getValor() + "') ");
2093 
                sql.append("AND ppc.produto.modelo = :modelo ");
2094 
                sql.append("AND ppc.produto.estilo = :estiloProduto ");
2095 
                sql.append("AND ppc.produto.genero = '" + genero + "' ");
2096 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
2097 
                        sql.append("AND ppc.produto.tipo = :tipoProduto ");
2098 
                }
2099 
                return sql.toString().trim();
2100 
        }
2101 
 
2102 
        @Override
2103 
        public List<RankingComprasTransferenciasEstiloPorLoja> consultarEstoqueEeVendasEstiloPorLoja(ParametrosConsultaParaComprasTransferenciasDTO parametrosConsulta, Modelo modelo) {
2104 
                StringBuilder sql = new StringBuilder();
2105 
                sql.append("SELECT new br.com.ec.domain.dto.RankingComprasTransferenciasEstiloPorLoja(");
2106 
                sql.append("l");
2107 
                sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.UNISSEX.getValor(), true) + ")");
2108 
                sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.MASCULINO.getValor(), true) + ")");
2109 
                sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.FEMININO.getValor(), true) + ")");
2110 
                sql.append(", (" + adicionarConsultaEstoquePorEstilo(parametrosConsulta, TipoGenero.UNISSEX.getValor(), true) + ")");
2111 
                sql.append(", (" + adicionarConsultaEstoquePorEstilo(parametrosConsulta, TipoGenero.MASCULINO.getValor(), true) + ")");
2112 
                sql.append(", (" + adicionarConsultaEstoquePorEstilo(parametrosConsulta, TipoGenero.FEMININO.getValor(), true) + ")");
2113 
                sql.append(", " + parametrosConsulta.getQuantidadeMinimaComprar());
2114 
                // ADICIONAR QUANTIDADE JÁ SOLICITADO PARA COMPRA (VERIFICADO + SOLICITADO)
2115 
                sql.append(") FROM Loja l ");
2116 
                sql.append("WHERE l.ativo IS TRUE ");
2117 
                sql.append("GROUP BY l, l.ordenador ");
2118 
                sql.append("ORDER BY l.ordenador ");
2119 
                try {
2120 
                        TypedQuery<RankingComprasTransferenciasEstiloPorLoja> query = getEntityManager().createQuery(sql.toString(), RankingComprasTransferenciasEstiloPorLoja.class);
2121 
                        query.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial()));
2122 
                        query.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal()));
2123 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
2124 
                                query.setParameter("sequencialLoja", parametrosConsulta.getSequencialLoja());
2125 
                        }
2126 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
2127 
                                query.setParameter("tipoProduto", parametrosConsulta.getTipoProduto());
2128 
                        }
2129 
                        if (VerificadorUtil.naoEstaNulo(modelo)) {
2130 
                                query.setParameter("modelo", modelo);
2131 
                        }
2132 
                        query.setParameter("estiloProduto", parametrosConsulta.getEstilo());
2133 
                        return query.getResultList();
2134 
                } catch(Exception ex) {
2135 
                        ex.printStackTrace();
2136 
                        return null;
2137 
                }
2138 
        }
2139 
*/
583 blopes 2140 
 
229 espaco 2141 
}