Subversion Repositories Integrator Subversion

Rev

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