Subversion Repositories Integrator Subversion

Rev

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

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