Subversion Repositories Integrator Subversion

Rev

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

Rev Author Line No. Line
357 espaco 1 
package br.com.ec.repository.jpa;
2 
 
468 blopes 3 
import java.util.List;
4 
 
543 blopes 5 
import javax.persistence.NoResultException;
462 blopes 6 
import javax.persistence.TypedQuery;
7 
 
357 espaco 8 
import org.springframework.stereotype.Repository;
9 
 
543 blopes 10 
import br.com.ec.core.exception.NegocioException;
524 blopes 11 
import br.com.ec.core.util.VerificadorUtil;
468 blopes 12 
import br.com.ec.domain.dto.CompraProdutoDTO;
462 blopes 13 
import br.com.ec.domain.dto.ProdutoDTO;
357 espaco 14 
import br.com.ec.domain.model.Produto;
462 blopes 15 
import br.com.ec.domain.util.CodigoBarraEAN;
357 espaco 16 
import br.com.ec.repository.ProdutoRepository;
17 
import br.com.ec.repository.SistemaAbstractRepository;
18 
 
19 
@Repository
20 
public class ProdutoRepositoryJpaImpl extends SistemaAbstractRepository<Produto> implements ProdutoRepository {
21 
 
22 
        @Override
23 
        protected String getColunaOrdenadora() {
24 
                return "modelo.descricao, estilo, cor, descricao";
25 
        }
26 
 
27 
        @Override
28 
        protected boolean adicionarDistinct() {
29 
                return false;
30 
        }
31 
 
524 blopes 32 
        @Override
33 
        public Produto consultarProdutoPorCodigo(String codigoProduto) {
34 
                StringBuilder sql = new StringBuilder();
35 
                sql.append("SELECT e FROM Produto e ");
36 
                sql.append("WHERE e.codigo = :codigo");
37 
                try {
38 
                        return getEntityManager().createQuery(sql.toString(), Produto.class).setParameter("codigo", codigoProduto).getSingleResult();
543 blopes 39 
                } catch(NoResultException ex) {
40 
                        throw new NegocioException("NÃO EXISTE PRODUTO COM ESTE CÓDIGO");
524 blopes 41 
                } catch(Exception ex) {
42 
                        ex.printStackTrace();
43 
                        return null;
44 
                }
45 
        }
46 
 
47 
        @Override
48 
        public ProdutoDTO consultarProdutoDTOPorCodigoOuEAN(String codigoOuEAN) {
49 
                StringBuilder jpql = new StringBuilder();
50 
                jpql.append("SELECT new br.com.ec.domain.dto.ProdutoDTO(");
51 
                jpql.append(ProdutoDTO.CONSULTA_DTO_SIMPLES_COM_MODELO);
52 
                jpql.append(") FROM Produto e ");
53 
                jpql.append("WHERE 1=1 AND ");
54 
                if (CodigoBarraEAN.validarCodigoBarras(codigoOuEAN)) {
55 
                        jpql.append("e.codigoEAN = :codigoOuEAN");
56 
                } else {
57 
                        codigoOuEAN = ProdutoDTO.retornarCodigoProdutoPadrao(codigoOuEAN);
58 
                        jpql.append("e.codigo = :codigoOuEAN");
59 
                }
60 
                try {
61 
                        TypedQuery<ProdutoDTO> query = (TypedQuery<ProdutoDTO>) getEntityManager().createQuery(jpql.toString(), ProdutoDTO.class)
62 
                                .setParameter("codigoOuEAN", codigoOuEAN);
63 
                        return query.getSingleResult();
543 blopes 64 
                } catch(NoResultException ex) {
65 
                        throw new NegocioException("NÃO EXISTE PRODUTO COM ESTE CÓDIGO");
524 blopes 66 
                } catch(Exception ex) {
67 
                        ex.printStackTrace();
68 
                        return null;
69 
                }
70 
        }
71 
 
72 
        @Override
73 
        public List<CompraProdutoDTO> consultarComprasDoProduto(Long sequencialProduto) {
74 
                StringBuilder jpql = new StringBuilder();
75 
                jpql.append("SELECT new br.com.ec.domain.dto.CompraProdutoDTO(");
76 
                jpql.append(CompraProdutoDTO.CONSULTA_DTO_COMPLETA);
77 
                jpql.append(") FROM CompraProduto e ");
78 
                jpql.append("WHERE 1=1 AND ");
79 
                jpql.append("e.produto.sequencial = :sequencialProduto ");
80 
                try {
81 
                        jpql.append("ORDER BY e.compra.dataCompra DESC");
82 
                        return getEntityManager().createQuery(jpql.toString(), CompraProdutoDTO.class)
83 
                                        .setParameter("sequencialProduto", sequencialProduto)
84 
                                        .getResultList();
85 
                } catch(Exception ex) {
86 
                        ex.printStackTrace();
87 
                        return null;
88 
                }
89 
        }
90 
 
575 blopes 91 
        @Override
92 
        public List<ProdutoDTO> consultarProdutosDoFornecedor(Long sequencialFornecedor) {
93 
                StringBuilder jpql = new StringBuilder();
94 
                jpql.append("SELECT new br.com.ec.domain.dto.ProdutoDTO(");
95 
                jpql.append(ProdutoDTO.CONSULTA_DTO_SIMPLES_COM_MODELO);
96 
                jpql.append(") FROM Produto e ");
97 
                jpql.append("LEFT JOIN ");
98 
                jpql.append("WHERE 1=1 ");
99 
                jpql.append("AND e.produto.sequencial = :sequencialProduto ");
100 
                jpql.append("AND EXISTS(SELECT fp FROM FornecedorProduto fp WHERE fp.fornecedor.sequencial = :sequencialFornecedor AND fp.produto.sequencial = e.sequencial) ");
101 
                try {
102 
                        jpql.append("ORDER BY e.descricao DESC");
103 
                        return getEntityManager().createQuery(jpql.toString(), ProdutoDTO.class)
104 
                                        .setParameter("sequencialFornecedor", sequencialFornecedor)
105 
                                        .getResultList();
106 
                } catch(Exception ex) {
107 
                        ex.printStackTrace();
108 
                        return null;
109 
                }
110 
        }
111 
 
357 espaco 112 
        /*
113 
        @Override
114 
        public List<Produto> consultarProdutoPorParametros(ParametrosConsultaProdutoDTO parametrosConsultaProduto) {
115 
                StringBuilder sql = new StringBuilder();
116 
                sql.append("SELECT DISTINCT e FROM Produto e ");
117 
                sql.append("WHERE 1=1 ");
118 
                try {
119 
                        setarStringParametrosConsulta(sql, parametrosConsultaProduto);
120 
                        sql.append("ORDER BY e.descricao");
121 
                        TypedQuery<Produto> query = (TypedQuery<Produto>) getEntityManager().createQuery(sql.toString(), Produto.class);
122 
                        setarQueryParametrosConsulta(query, parametrosConsultaProduto);
123 
                        return query.getResultList();
124 
                } catch(Exception ex) {
125 
                        ex.printStackTrace();
126 
                        return null;
127 
                }
128 
        }
129 
 
130 
        @Override
131 
        public List<Produto> consultarCompativeis(Produto produto) {
132 
                StringBuilder sql = new StringBuilder();
133 
                sql.append("SELECT DISTINCT e FROM Produto e ");
134 
                sql.append("WHERE e.sequencial = :sequencialProduto ");
135 
                sql.append("OR e IN (SELECT pr.produtoRelacionado FROM ProdutoRelacionado pr WHERE pr.produto.sequencial = :sequencialProduto) ");
136 
                sql.append("OR e IN (SELECT prr.produto FROM ProdutoRelacionado prr WHERE prr.produtoRelacionado.sequencial = :sequencialProduto) ");
137 
                try {
138 
                        sql.append("ORDER BY e.descricao");
139 
                        TypedQuery<Produto> query = (TypedQuery<Produto>) getEntityManager().createQuery(sql.toString(), Produto.class);
140 
                        query.setParameter("sequencialProduto", produto.getSequencial());
141 
                        return query.getResultList();
142 
                } catch(Exception ex) {
143 
                        ex.printStackTrace();
144 
                        return null;
145 
                }
146 
        }
147 
 
148 
        @Override
149 
        public Produto detalharProduto(Produto produto) {
150 
                StringBuilder jpql = new StringBuilder();
151 
                jpql.append("SELECT p FROM Produto p ");
152 
                jpql.append("LEFT JOIN FETCH p.pedidosCompra c ");
153 
                jpql.append("LEFT JOIN FETCH p.fornecedores f ");
154 
                jpql.append("LEFT JOIN FETCH p.relacionados r ");
155 
                jpql.append("LEFT JOIN FETCH p.relacionadosReverse v ");
156 
                jpql.append("WHERE p = :produto");
157 
                return getEntityManager().createQuery(jpql.toString(), Produto.class).setParameter("produto", produto).getSingleResult();
158 
        }
159 
 
160 
        @Override
161 
        protected void setarStringParametrosConsultar(StringBuilder sql, Produto produto) {
162 
                if (VerificadorUtil.naoEstaNulo(produto)) {
163 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getCodigo())) {
164 
                                sql.append("AND e.codigo = :codigo ");
165 
                        }
166 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getCodigoRapido())) {
167 
                                sql.append("AND e.codigoRapido = :codigoRapido ");
168 
                        }
169 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getCodigoEAN())) {
170 
                                sql.append("AND e.codigoEAN = :codigoEAN ");
171 
                        }
172 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getDescricao())) {
173 
                                sql.append("AND ");
174 
                                sql.append(sqlConsultarSemAcento("e.descricao"));
175 
                                sql.append(" like upper(:descricao) ");
176 
                        }
177 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getTipo())) {
178 
                                sql.append("AND e.tipo = :tipoProduto ");
179 
                        }
180 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getEstilo())) {
181 
                                sql.append("AND e.estilo = :estilo ");
182 
                        }
183 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getCor())) {
184 
                                sql.append("AND e.cor = :cor ");
185 
                        }
186 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getGenero())) {
187 
                                sql.append("AND e.genero = :tipoGenero ");
188 
                        }
189 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getIndicadorOnline())) {
190 
                                if (produto.getIndicadorOnline()) {
191 
                                        sql.append("AND e.dataOnline IS NOT NULL ");
192 
                                } else {
193 
                                        sql.append("AND e.dataOnline IS NULL ");
194 
                                }
195 
                        }
196 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getIndicadorOnlineShoplog())) {
197 
                                if (produto.getIndicadorOnlineShoplog()) {
198 
                                        sql.append("AND e.dataOnlineShoplog IS NOT NULL ");
199 
                                } else {
200 
                                        sql.append("AND e.dataOnlineShoplog IS NULL ");
201 
                                }
202 
                        }
203 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getIndicadorOnlineMercadoLivre())) {
204 
                                if (produto.getIndicadorOnlineMercadoLivre()) {
205 
                                        sql.append("AND e.dataOnlineMercadoLivre IS NOT NULL ");
206 
                                } else {
207 
                                        sql.append("AND e.dataOnlineMercadoLivre IS NULL ");
208 
                                }
209 
                        }
210 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getAtivo())) {
211 
                                sql.append("AND e.indicadorAtivo = :indicadorAtivo ");
212 
                        }
213 
                        if (VerificadorUtil.naoEstaNulo(produto.getSequencialDoModelo())) {
214 
                                sql.append("AND e.modelo.sequencial = :sequencialModelo ");
215 
                        }
216 
                        if (VerificadorUtil.naoEstaNulo(produto.getMarcaDoModelo())) {
217 
                                sql.append("AND e.modelo.marca.sequencial = :sequencialMarcaDoModelo ");
218 
                        }
219 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getSujeitoST())) {
220 
                                sql.append("AND e.sujeitoST = :sujeitoST ");
221 
                        }
222 
                }
223 
        }
224 
 
225 
        @Override
226 
        protected void setarQueryParametrosConsultar(Query query, Produto produto) {
227 
                if (VerificadorUtil.naoEstaNulo(produto)) {
228 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getCodigo())) {
229 
                                query.setParameter("codigo", produto.getCodigoProdutoPadrao());
230 
                        }
231 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getCodigoRapido())) {
232 
                                query.setParameter("codigoRapido", produto.getCodigoRapido());
233 
                        }
234 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getCodigoEAN())) {
235 
                                query.setParameter("codigoEAN", produto.getCodigoEAN());
236 
                        }
237 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getDescricao())) {
238 
                                query.setParameter("descricao", "%" + removerAcentuacao(produto.getDescricao()) + "%");
239 
                        }
240 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getTipo())) {
241 
                                query.setParameter("tipoProduto", produto.getTipo());
242 
                        }
243 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getEstilo())) {
244 
                                query.setParameter("estilo", produto.getEstilo());
245 
                        }
246 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getCor())) {
247 
                                query.setParameter("cor", produto.getCor());
248 
                        }
249 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getGenero())) {
250 
                                query.setParameter("tipoGenero", produto.getGenero());
251 
                        }
252 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getAtivo())) {
253 
                                query.setParameter("indicadorAtivo", produto.getAtivo());
254 
                        }
255 
                        if (VerificadorUtil.naoEstaNulo(produto.getSequencialDoModelo())) {
256 
                                query.setParameter("sequencialModelo", produto.getSequencialDoModelo());
257 
                        }
258 
                        if (VerificadorUtil.naoEstaNulo(produto.getMarcaDoModelo())) {
259 
                                query.setParameter("sequencialMarcaDoModelo", produto.getMarcaDoModelo().getSequencial());
260 
                        }
261 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getSujeitoST())) {
262 
                                query.setParameter("sujeitoST", produto.getSujeitoST());
263 
                        }
264 
                }
265 
        }
266 
 
267 
        @Override
268 
        protected void setarStringParametrosConsulta(StringBuilder sql, ParametrosConsulta<Produto> parametros) {
269 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getFiltro())) {
270 
                        sql.append("AND (e.codigo = :filtro OR e.codigo = :filtroECCEAN OR e.codigoEAN = :filtroCEAN) ");
271 
                }
272 
                if (VerificadorUtil.naoEstaNulo(parametros.getEntidade())) {
273 
                        verificarRestricoes(sql, parametros);
274 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getEntidade().getCodigo())) {
275 
                                sql.append("AND e.codigo = :codigo ");
276 
                        }
277 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getEntidade().getCodigoRapido())) {
278 
                                sql.append("AND e.codigoRapido = :codigoRapido ");
279 
                        }
280 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getEntidade().getCodigoEAN())) {
281 
                                if (CodigoBarraEAN.validarCodigoBarras(parametros.getEntidade().getCodigoEAN())) {
282 
                                        sql.append("AND (e.codigoEAN = :codigoEAN OR e.codigo = :codigoBarras) ");
283 
                                } else {
284 
                                        sql.append("AND e.codigoEAN = :codigoEAN ");
285 
                                }
286 
                        }
287 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getEntidade().getDescricao())) {
288 
                                sql.append("AND ");
289 
                                sql.append(sqlConsultarSemAcento("e.descricao"));
290 
                                sql.append(" like upper(:descricao) ");
291 
                        }
292 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getEntidade().getTipo())) {
293 
                                sql.append("AND e.tipo = :tipoProduto ");
294 
                        }
295 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getEntidade().getEstilo())) {
296 
                                sql.append("AND e.estilo = :estilo ");
297 
                        }
298 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getEntidade().getCor())) {
299 
                                sql.append("AND e.cor = :cor ");
300 
                        }
301 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getEntidade().getGenero())) {
302 
                                sql.append("AND e.genero = :tipoGenero ");
303 
                        }
304 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getEntidade().getIndicadorComissionado())) {
305 
                                sql.append("AND e.indicadorComissionado = :indicadorComissionado ");
306 
                        }
307 
                        if (VerificadorUtil.naoEstaNuloOuVazio(((ParametrosConsultaProdutoDTO)parametros).getConsultarAtivo())) {
308 
                                sql.append("AND e.ativo = :ativo ");
309 
                        }
310 
                        if (VerificadorUtil.naoEstaNuloOuVazio(((ParametrosConsultaProdutoDTO)parametros).getConsultarOnline())) {
311 
                                if (((ParametrosConsultaProdutoDTO)parametros).getConsultarOnline().equals(1)) {
312 
                                        sql.append("AND e.dataOnline IS NOT NULL ");
313 
                                } else if (((ParametrosConsultaProdutoDTO)parametros).getConsultarOnline().equals(2)) {
314 
                                        sql.append("AND e.dataOnline IS NULL ");
315 
                                }
316 
                        }
317 
                        if (VerificadorUtil.naoEstaNuloOuVazio(((ParametrosConsultaProdutoDTO)parametros).getConsultarOnlineShoplog())) {
318 
                                if (((ParametrosConsultaProdutoDTO)parametros).getConsultarOnlineShoplog().equals(1)) {
319 
                                        sql.append("AND e.dataOnlineShoplog IS NOT NULL ");
320 
                                } else if (((ParametrosConsultaProdutoDTO)parametros).getConsultarOnlineShoplog().equals(2)) {
321 
                                        sql.append("AND e.dataOnlineShoplog IS NULL ");
322 
                                }
323 
                        }
324 
                        if (VerificadorUtil.naoEstaNuloOuVazio(((ParametrosConsultaProdutoDTO)parametros).getConsultarOnlineMercadoLivre())) {
325 
                                if (((ParametrosConsultaProdutoDTO)parametros).getConsultarOnlineMercadoLivre().equals(1)) {
326 
                                        sql.append("AND e.dataOnlineMercadoLivre IS NOT NULL ");
327 
                                } else if (((ParametrosConsultaProdutoDTO)parametros).getConsultarOnlineMercadoLivre().equals(2)) {
328 
                                        sql.append("AND e.dataOnlineMercadoLivre IS NULL ");
329 
                                }
330 
                        }
331 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaProdutoDTO)parametros).getModelo())) {
332 
                                sql.append("AND e.modelo.sequencial = :sequencialModelo ");
333 
                        }
334 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaProdutoDTO)parametros).getMarca())) {
335 
                                sql.append("AND e.modelo.marca.sequencial = :sequencialMarcaDoModelo ");
336 
                        }
337 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaProdutoDTO)parametros).getFornecedor())) {
338 
                                sql.append("AND EXISTS(SELECT fp FROM FornecedorProduto fp WHERE fp.fornecedor.sequencial = :sequencialFornecedor AND fp.produto.sequencial = e.sequencial) ");
339 
                        }
340 
                        if (VerificadorUtil.naoEstaNuloOuVazio(((ParametrosConsultaProdutoDTO)parametros).getIndicadorModeloFavorito())) {
341 
                                sql.append("AND e.modelo.indicadorFavorito = :indicadorFavorito ");
342 
                        }
343 
                        if (VerificadorUtil.naoEstaNuloOuVazio(((ParametrosConsultaProdutoDTO)parametros).getSujeitoST())) {
344 
                                sql.append("AND e.sujeitoST = :sujeitoST ");
345 
                        }
346 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaProdutoDTO)parametros).getTributacao())) {
347 
                                sql.append("AND e.tributacao = :tributacao ");
348 
                        }
349 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaProdutoDTO)parametros).getLojaSelecionadaParaContagem())) {
350 
                                sql.append("AND e.modelo is not null ");
351 
                                sql.append("AND EXISTS(SELECT pl FROM ProdutoLoja pl WHERE ");
352 
                                if (VerificadorUtil.naoEstaNuloOuVazio(((ParametrosConsultaProdutoDTO)parametros).getLocalizacaoLojaSelecionada())) {
353 
                                        sql.append("pl.localizacao like upper(:localizacao) AND ");
354 
                                }
355 
                                if (!((ParametrosConsultaProdutoDTO)parametros).getContagemObrigatoria()) {
356 
                                        verificarSeNaoHaTransferenciasDoProduto(sql);
357 
                                        // PRODUTOS SEM PREPARACAO DE CONTAGEM
358 
                                        // OU (
359 
                                                // PRODUTOS PREPARADOS POR OUTROS
360 
                                                // AND (
361 
                                                        // COM INDICAÇÃO DE CONTAGEM SOLICITADA
362 
                                                        // OU
363 
                                                        // COM PREPARAÇÃO POSTERIOR AO DA CONTAGEM
364 
                                                        // OU
365 
                                                        // COM CONTAGENS FINALIZADAS POR MAIS DE 60 DIAS
366 
                                                // )
367 
                                        // )
368 
                                        sql.append("AND (");
369 
                                                sql.append("pl.usuarioUltimaContagemPreparacao.sequencial IS NULL ");
370 
                                                sql.append("OR (");
371 
                                                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaProdutoDTO)parametros).getUsuarioParaContagem())) {
372 
                                                                sql.append("pl.usuarioUltimaContagemPreparacao != :usuarioParaContagem ");
373 
                                                        } else {
374 
                                                                sql.append("pl.usuarioUltimaContagemPreparacao != null ");
375 
                                                        }
376 
                                                        sql.append(") ");
377 
                                                        // CONTAR PRODUTOS COM DATA DE CONTAGEM ACIMA DE 60 DIAS
378 
//                                                      sql.append("OR ");
379 
//                                                      sql.append("(date_part('day', now() - pl.dataContagem) >= ").append(ConstantesSEC.StatusContagem.CONTAGEM_VERMELHO_60_DIAS).append(") ");
380 
                                                sql.append(") ");
381 
//                                      sql.append("AND (pl.dataContagem IS NULL OR pl.dataContagemPreparacao > pl.dataContagem) ");
382 
                                        sql.append("AND (pl.produto.modelo.marca.dataContagemSolicitada > pl.dataContagem) ");
383 
                                        sql.append("AND (");
384 
                                                sql.append("(pl.quantidadeEstoque != 0 AND ");
385 
                                                sql.append("(pl.indicadorContagemSolicitada IS TRUE OR pl.produto.modelo.marca.indicadorContagemSolicitada IS TRUE) ");
386 
                                        sql.append(") ");
387 
                                        if (ConstantesSEC.FORMATO_CONTAGEM.equals(ConstantesSEC.ContagemFormato.FORMATO_CONTAGEM_POR_PERIODO_1)) {
388 
                                                sql.append("AND (date_part('day', now() - pl.dataContagem) >= ").append(ConstantesSEC.StatusContagem.CONTAGEM_VERMELHO_60_DIAS);
389 
                                                sql.append(" OR pl.dataContagem IS NULL)) ");
390 
                                        } else if (ConstantesSEC.FORMATO_CONTAGEM.equals(ConstantesSEC.ContagemFormato.FORMATO_CONTAGEM_POR_MARCA_2)) {}
391 
                                        sql.append("AND (");
392 
                                }
393 
                                sql.append("pl.produto.sequencial = e.sequencial AND pl.loja.sequencial = ");
394 
                                sql.append(((ParametrosConsultaProdutoDTO)parametros).getLojaSelecionadaParaContagem().getSequencial());
395 
                                sql.append("))) ");
396 
                        }
397 
                        /*
398 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaProdutoDTO)parametros).getLojaSelecionadaParaContagem())) {
399 
                                sql.append("AND e.modelo is not null ");
400 
                                sql.append("AND EXISTS(SELECT pl FROM ProdutoLoja pl WHERE ");
401 
                                if (VerificadorUtil.naoEstaNuloOuVazio(((ParametrosConsultaProdutoDTO)parametros).getLocalizacaoLojaSelecionada())) {
402 
                                        sql.append("pl.localizacao like upper(:localizacao) AND ");
403 
                                }
404 
                                if (!((ParametrosConsultaProdutoDTO)parametros).getContagemObrigatoria()) {
405 
                                        verificarSeNaoHaTransferenciasDoProduto(sql);
406 
 
407 
                                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaProdutoDTO)parametros).getUsuarioParaContagem())) {
408 
                                                sql.append("AND (");
409 
                                                sql.append("(pl.usuarioUltimaContagemPreparacao != :usuarioParaContagem ");
410 
                                                sql.append("AND pl.indicadorContagemSolicitada IS TRUE) ");
411 
                                                sql.append("OR (pl.usuarioUltimaContagemPreparacao != :usuarioParaContagem ");
412 
                                                sql.append("AND (pl.dataContagem IS NULL ");
413 
                                                sql.append("OR pl.dataContagem < pl.dataContagemPreparacao)) ");
414 
                                                sql.append("OR pl.usuarioUltimaContagemPreparacao.sequencial IS NULL ");
415 
                                                sql.append(") ");
416 
                                        }
417 
 
418 
                                        sql.append("AND (pl.indicadorContagemSolicitada IS TRUE ");
419 
                                        sql.append("OR (pl.quantidadeEstoque != 0 AND ");
420 
                                        if (ConstantesSEC.FORMATO_CONTAGEM.equals(ConstantesSEC.ContagemFormato.FORMATO_CONTAGEM_POR_PERIODO_1)) {
421 
                                                sql.append("(date_part('day', now() - pl.dataContagem) >= ").append(ConstantesSEC.StatusContagem.CONTAGEM_VERMELHO_60_DIAS);
422 
                                                sql.append(" OR pl.dataContagem IS NULL)) ");
423 
                                        } else if (ConstantesSEC.FORMATO_CONTAGEM.equals(ConstantesSEC.ContagemFormato.FORMATO_CONTAGEM_POR_MARCA_2)) {
424 
                                                sql.append("pl.produto.modelo.marca.indicadorContagemSolicitada IS TRUE AND ");
425 
                                        }
426 
                                        sql.append("(pl.dataContagem IS NULL OR pl.dataContagemPreparacao IS NULL OR pl.dataContagem < pl.dataContagemPreparacao)) ");
427 
                                        sql.append(") AND (");
428 
                                }
429 
                                sql.append("pl.produto.sequencial = e.sequencial AND pl.loja.sequencial = ");
430 
                                sql.append(((ParametrosConsultaProdutoDTO)parametros).getLojaSelecionadaParaContagem().getSequencial());
431 
                                sql.append("))) ");
432 
                        }
433 
                        */
434 
/*     
435 
                }
436 
        }
437 
 
438 
        private void verificarSeNaoHaTransferenciasDoProduto(StringBuilder sql) {
439 
                sql.append("NOT EXISTS(SELECT (tp) FROM TransferenciaProduto tp ");
440 
                sql.append("WHERE tp.produto.sequencial = pl.produto.sequencial ");
441 
                sql.append("AND tp.transferencia.dataFinalizacao IS NULL ");
442 
                sql.append("AND (tp.transferencia.lojaEntrada.sequencial = pl.loja.sequencial ");
443 
                sql.append("OR tp.transferencia.lojaSaida.sequencial = pl.loja.sequencial)) ");
444 
        }
445 
 
446 
        @Override
447 
        protected void setarQueryParametrosConsulta(Query query, ParametrosConsulta<Produto> parametros) {
448 
                if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getFiltro())) {
449 
                        query.setParameter("filtro", String.format("%06d", new Long(parametros.getFiltro().trim())));
450 
                        if (CodigoBarraEAN.validarCodigoBarras(parametros.getFiltro())) {
451 
                                String codigoRetornado = CodigoBarraEAN.retornarCodigoDoCodigoBarras(parametros.getFiltro());
452 
                                query.setParameter("filtroECCEAN", String.format("%06d", new Long(codigoRetornado.trim())));
453 
                        } else {
454 
                                query.setParameter("filtroECCEAN", String.format("%06d", new Long(parametros.getFiltro().trim())));    
455 
                        }
456 
                        query.setParameter("filtroCEAN", parametros.getFiltro().trim());
457 
                }
458 
                if (VerificadorUtil.naoEstaNulo(parametros.getEntidade())) {
459 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getEntidade().getCodigo())) {
460 
                                query.setParameter("codigo", parametros.getEntidade().getCodigoProdutoPadrao());
461 
                        }
462 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getEntidade().getCodigoRapido())) {
463 
                                query.setParameter("codigoRapido", parametros.getEntidade().getCodigoRapido());
464 
                        }
465 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getEntidade().getCodigoEAN())) {
466 
                                if (CodigoBarraEAN.validarCodigoBarras(parametros.getEntidade().getCodigoEAN())) {
467 
                                        query.setParameter("codigoBarras", CodigoBarraEAN.retornarCodigoDoCodigoBarras(parametros.getEntidade().getCodigoEAN()));
468 
                                }
469 
                                query.setParameter("codigoEAN", parametros.getEntidade().getCodigoEAN());
470 
                        }
471 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getEntidade().getDescricao())) {
472 
                                query.setParameter("descricao", "%" + removerAcentuacao(parametros.getEntidade().getDescricao()) + "%");
473 
                        }
474 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getEntidade().getTipo())) {
475 
                                query.setParameter("tipoProduto", parametros.getEntidade().getTipo());
476 
                        }
477 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getEntidade().getEstilo())) {
478 
                                query.setParameter("estilo", parametros.getEntidade().getEstilo());
479 
                        }
480 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getEntidade().getCor())) {
481 
                                query.setParameter("cor", parametros.getEntidade().getCor());
482 
                        }
483 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getEntidade().getGenero())) {
484 
                                query.setParameter("tipoGenero", parametros.getEntidade().getGenero());
485 
                        }
486 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getEntidade().getIndicadorComissionado())) {
487 
                                query.setParameter("indicadorComissionado", parametros.getEntidade().getIndicadorComissionado());
488 
                        }
489 
                        if (VerificadorUtil.naoEstaNuloOuVazio(((ParametrosConsultaProdutoDTO)parametros).getConsultarAtivo())) {
490 
                                query.setParameter("ativo", ((ParametrosConsultaProdutoDTO)parametros).getConsultarAtivo() == 1 );
491 
                        }
492 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaProdutoDTO)parametros).getModelo())) {
493 
                                query.setParameter("sequencialModelo", ((ParametrosConsultaProdutoDTO)parametros).getModelo().getSequencial());
494 
                        }
495 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaProdutoDTO)parametros).getMarca())) {
496 
                                query.setParameter("sequencialMarcaDoModelo", ((ParametrosConsultaProdutoDTO)parametros).getMarca().getSequencial());
497 
                        }
498 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaProdutoDTO)parametros).getFornecedor())) {
499 
                                query.setParameter("sequencialFornecedor", ((ParametrosConsultaProdutoDTO)parametros).getFornecedor().getSequencial());
500 
                        }
501 
                        if (VerificadorUtil.naoEstaNuloOuVazio(((ParametrosConsultaProdutoDTO)parametros).getIndicadorModeloFavorito())) {
502 
                                query.setParameter("indicadorFavorito", ((ParametrosConsultaProdutoDTO)parametros).getIndicadorModeloFavorito());
503 
                        }
504 
                        if (VerificadorUtil.naoEstaNuloOuVazio(((ParametrosConsultaProdutoDTO)parametros).getSujeitoST())) {
505 
                                query.setParameter("sujeitoST", ((ParametrosConsultaProdutoDTO)parametros).getSujeitoST());
506 
                        }
507 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaProdutoDTO)parametros).getTributacao())) {
508 
                                query.setParameter("tributacao", ((ParametrosConsultaProdutoDTO)parametros).getTributacao());
509 
                        }
510 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaProdutoDTO)parametros).getLojaSelecionadaParaContagem())) {
511 
                                if (VerificadorUtil.naoEstaNuloOuVazio(((ParametrosConsultaProdutoDTO)parametros).getLocalizacaoLojaSelecionada())) {
512 
                                        query.setParameter("localizacao", "%" + ((ParametrosConsultaProdutoDTO)parametros).getLocalizacaoLojaSelecionada() + "%");
513 
                                }
514 
                        }
515 
                        if (((ParametrosConsultaProdutoDTO)parametros).getIndicadorProdutosSemVendas()) {
516 
                                query.setParameter("dataInicialSemVendas", DataUtils.getDataComHorarioMinimo(((ParametrosConsultaProdutoDTO)parametros).getDataInicialSemVendas()));
517 
                                query.setParameter("dataFinalSemVendas", DataUtils.getDataComHorarioMaximo(((ParametrosConsultaProdutoDTO)parametros).getDataFinalSemVendas()));
518 
                        }
519 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaProdutoDTO)parametros).getUsuarioParaContagem())) {
520 
                                query.setParameter("usuarioParaContagem", ((ParametrosConsultaProdutoDTO)parametros).getUsuarioParaContagem());
521 
                        }
522 
                }
523 
        }
524 
 
525 
        private void verificarRestricoes(StringBuilder sql, ParametrosConsulta<Produto> parametrosConsulta) {
526 
                clonarProdutoParaAlteracaoParaConsulta(parametrosConsulta);
527 
                prepararVerificacoesRestricoes(parametrosConsulta);
528 
 
529 
                if (((ParametrosConsultaProdutoDTO)parametrosConsulta).getTipoRelatorioProduto().equals(TipoRelatorio.GERAL.getValor())) {
530 
                        sql.append("AND e.modelo.ativo is true ");
531 
                }
532 
 
533 
                if (((ParametrosConsultaProdutoDTO)parametrosConsulta).getTipoRelatorioProduto().equals(TipoRelatorio.PRODUTOS_COM_ESTOQUE.getValor())) {
534 
                        adicionarSqlProdutoComEstoque(sql, parametrosConsulta);
535 
                }
536 
 
537 
                if (((ParametrosConsultaProdutoDTO)parametrosConsulta).getTipoRelatorioProduto().equals(TipoRelatorio.PELICULAS_SEM_ESTOQUE.getValor())) {
538 
                        sql.append("AND e.modelo.ativo is true ");
539 
                        ((ParametrosConsultaProdutoDTO)parametrosConsulta).getProduto().setTipo(TipoProduto.PELICULA.getValor());
540 
                        setarParametrosSemEstoquePorPonto(sql, parametrosConsulta);
541 
                }
542 
 
543 
                if (((ParametrosConsultaProdutoDTO)parametrosConsulta).getTipoRelatorioProduto().equals(TipoRelatorio.PRODUTOS_SEM_ESTOQUE.getValor())) {
544 
                        sql.append("AND e.modelo.ativo is true ");
545 
                        setarParametrosSemEstoquePorPonto(sql, parametrosConsulta);
546 
                }
547 
 
548 
                if (((ParametrosConsultaProdutoDTO)parametrosConsulta).getTipoRelatorioProduto().equals(TipoRelatorio.RETIRAR_SITE.getValor())) {
549 
                        // RETIRAR DO SITE: SEM ESTOQUE NA MATRIZ, JATIÚCA OU MACEIÓ, EXCETO TPU SOFT
550 
                        ((ParametrosConsultaProdutoDTO)parametrosConsulta).setLojaSelecionada(ConstantesSEC.SEQUENCIAL_MATRIZ_ESTOQUE_9);
551 
                        setarParametrosSemEstoquePorPonto(sql, parametrosConsulta);
552 
                        sql.append("AND e.descricao NOT LIKE '%TPU SOFT%' ");
553 
                        sql.append("AND (NOT EXISTS(SELECT p FROM ProdutoLoja p WHERE p.quantidadeEstoque > 0 ");
554 
                        sql.append("AND p.produto.sequencial = e.sequencial ");
555 
                        sql.append("AND p.loja.sequencial IN (");
556 
                        sql.append(ConstantesSEC.SEQUENCIAL_MATRIZ_ESTOQUE_9);
557 
                        sql.append(", ");
558 
                        sql.append(ConstantesSEC.SEQUENCIAL_QUIOSQUE_BIG_JATIUCA_6);
559 
                        sql.append(", ");
560 
                        sql.append(ConstantesSEC.SEQUENCIAL_LOJA_MACEIO_8);
561 
                        sql.append("))) ");
562 
//                      sql.append(((ParametrosConsultaProdutoDTO)parametrosConsulta).getLojaSelecionada());
563 
//                      sql.append(") AND (SELECT SUM(p.quantidadeEstoque) AS estoque FROM ProdutoLoja p WHERE p.produto.sequencial = e.sequencial) < 2) ");
564 
                        ((ParametrosConsultaProdutoDTO)parametrosConsulta).setConsultarOnline(1);;
565 
                        ((ParametrosConsultaProdutoDTO)parametrosConsulta).setConsultarAtivo(null);
566 
                }
567 
 
568 
                if (((ParametrosConsultaProdutoDTO)parametrosConsulta).getTipoRelatorioProduto().equals(TipoRelatorio.RETIRAR_SHOPLOG.getValor())) {
569 
                        ((ParametrosConsultaProdutoDTO)parametrosConsulta).setLojaSelecionada(ConstantesSEC.SEQUENCIAL_LOJA_PATIO_14);
570 
                        setarParametrosSemEstoquePorPonto(sql, parametrosConsulta);
571 
                        ((ParametrosConsultaProdutoDTO)parametrosConsulta).setConsultarOnlineShoplog(1);
572 
                        ((ParametrosConsultaProdutoDTO)parametrosConsulta).setConsultarAtivo(null);
573 
                }
574 
*/             
575 
                /*
576 
                if (((ParametrosConsultaProdutoDTO)parametrosConsulta).getTipoRelatorioProduto().equals(TipoRelatorio.RETIRAR_FACEBOOK.getValor())) {
577 
                        ((ParametrosConsultaProdutoDTO)parametrosConsulta).setLojaSelecionada(null);
578 
                        setarParametrosSemEstoquePorPonto(sql, parametrosConsulta);
579 
                        ((ParametrosConsultaProdutoDTO)parametrosConsulta).getProduto().setIndicadorFacebook(true);
580 
                        ((ParametrosConsultaProdutoDTO)parametrosConsulta).setConsultarAtivo(null);
581 
                }
582 
                */
583 
/*             
584 
                if (((ParametrosConsultaProdutoDTO)parametrosConsulta).getTipoRelatorioProduto().equals(TipoRelatorio.ESTOQUE_INVALIDO.getValor())) {
585 
                        sql.append("AND EXISTS(SELECT p FROM ProdutoLoja p WHERE p.quantidadeEstoque < 0 ");
586 
                        sql.append("AND p.produto.sequencial = e.sequencial");
587 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaProdutoDTO)parametrosConsulta).getLojaSelecionada())) {
588 
                                sql.append(" AND p.loja.sequencial = ");
589 
                                sql.append(((ParametrosConsultaProdutoDTO)parametrosConsulta).getLojaSelecionada());
590 
                        }
591 
                        sql.append(") ");
592 
                }
593 
 
594 
                if (((ParametrosConsultaProdutoDTO)parametrosConsulta).getTipoRelatorioProduto().equals(TipoRelatorio.ESTOQUE_NAO_FAVORITO.getValor())) {
595 
                        sql.append("AND EXISTS(SELECT p FROM ProdutoLoja p WHERE p.quantidadeEstoque > 0 ");
596 
                        sql.append("AND p.produto.modelo.indicadorFavorito IS FALSE ");
597 
                        sql.append("AND p.produto.sequencial = e.sequencial ");
598 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaProdutoDTO)parametrosConsulta).getLojaSelecionada())) {
599 
                                sql.append("AND p.loja.sequencial = ");
600 
                                sql.append(((ParametrosConsultaProdutoDTO)parametrosConsulta).getLojaSelecionada());
601 
                        }
602 
                        sql.append(") ");
603 
                }
604 
 
605 
                if (((ParametrosConsultaProdutoDTO)parametrosConsulta).getTipoRelatorioProduto().equals(TipoRelatorio.CONTAGENS_PENDENTES.getValor())) {
606 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaProdutoDTO)parametrosConsulta).getLojaSelecionada())) {
607 
                                ((ParametrosConsultaProdutoDTO)parametrosConsulta).setLojaSelecionadaParaContagem(new Loja(((ParametrosConsultaProdutoDTO)parametrosConsulta).getLojaSelecionada()));
608 
                        }
609 
                        ((ParametrosConsultaProdutoDTO)parametrosConsulta).setConsultarAtivo(1);
610 
                }
611 
 
612 
                if (((ParametrosConsultaProdutoDTO)parametrosConsulta).getTipoRelatorioProduto().equals(TipoRelatorio.PROMOCOES.getValor())) {
613 
                        sql.append("AND e.valorVarejoPromocional is not null ");
614 
                        sql.append("AND e.valorVarejoPromocional > 0 ");
615 
                }
616 
 
617 
                if (((ParametrosConsultaProdutoDTO)parametrosConsulta).getIndicadorProdutosSemVendas()) {
618 
                        sql.append("AND NOT EXISTS(SELECT l FROM Lancamento l WHERE l.produto.sequencial = e.sequencial ");
619 
                        sql.append("AND l.venda.dataVenda >= :dataInicialSemVendas AND l.venda.dataVenda <= :dataFinalSemVendas ");
620 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaProdutoDTO)parametrosConsulta).getLojaSelecionada())) {
621 
                                sql.append(" AND l.venda.loja.sequencial = ");
622 
                                sql.append(((ParametrosConsultaProdutoDTO)parametrosConsulta).getLojaSelecionada());
623 
                        }
624 
                        sql.append(") ");
625 
                }
626 
        }
627 
 
628 
        private void adicionarSqlProdutoComEstoque(StringBuilder sql, ParametrosConsulta<Produto> parametrosConsulta) {
629 
                sql.append("AND EXISTS(SELECT p FROM ProdutoLoja p WHERE p.quantidadeEstoque > 0 ");
630 
                sql.append("AND p.produto.sequencial = e.sequencial");
631 
                if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaProdutoDTO)parametrosConsulta).getLojaSelecionada())) {
632 
                        sql.append(" AND p.loja.sequencial = ");
633 
                        sql.append(((ParametrosConsultaProdutoDTO)parametrosConsulta).getLojaSelecionada());
634 
                }
635 
                sql.append(") ");
636 
        }
637 
 
638 
        private void clonarProdutoParaAlteracaoParaConsulta(ParametrosConsulta<Produto> parametrosConsulta) {
639 
                try {
640 
                        ((ParametrosConsultaProdutoDTO)parametrosConsulta).setProduto(((ParametrosConsultaProdutoDTO)parametrosConsulta).getProduto().clone());
641 
                } catch (CloneNotSupportedException e) {
642 
                        e.printStackTrace();
643 
                }
644 
        }
645 
 
646 
        private void prepararVerificacoesRestricoes(ParametrosConsulta<Produto> parametrosConsulta) {
647 
                ((ParametrosConsultaProdutoDTO)parametrosConsulta).getProduto().setIndicadorOnline(null);
648 
                ((ParametrosConsultaProdutoDTO)parametrosConsulta).getProduto().setIndicadorOnlineShoplog(null);
649 
                ((ParametrosConsultaProdutoDTO)parametrosConsulta).getProduto().setIndicadorOnlineMercadoLivre(null);
650 
                ((ParametrosConsultaProdutoDTO)parametrosConsulta).getProduto().setDataOnline(null);
651 
        }
652 
 
653 
        private void setarParametrosSemEstoquePorPonto(StringBuilder sql, ParametrosConsulta<Produto> parametrosConsulta) {
654 
                sql.append("AND NOT EXISTS(SELECT p FROM ProdutoLoja p WHERE p.quantidadeEstoque > 0 ");
655 
                sql.append("AND p.produto.sequencial = e.sequencial");
656 
                if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaProdutoDTO)parametrosConsulta).getLojaSelecionada())) {
657 
                        sql.append(" AND p.loja.sequencial = ");
658 
                        sql.append(((ParametrosConsultaProdutoDTO)parametrosConsulta).getLojaSelecionada());
659 
                }
660 
                sql.append(") ");
661 
        }
524 blopes 662 
 
357 espaco 663 
        @Override
664 
        public Produto consultarProdutoPorCodigoEAN(String codigoEAN) {
665 
                StringBuilder sql = new StringBuilder();
666 
                sql.append("SELECT e FROM Produto e ");
667 
                sql.append("WHERE e.codigoEAN = :codigoEAN");
668 
                if (CodigoBarraEAN.validarCodigoBarras(codigoEAN)) {
669 
                        sql.append(" OR e.codigo = :codigoBarras");
670 
                }
671 
                try {
672 
                        Query query = getEntityManager().createQuery(sql.toString(), Produto.class).setParameter("codigoEAN", codigoEAN);
673 
                        if (CodigoBarraEAN.validarCodigoBarras(codigoEAN)) {
674 
                                query.setParameter("codigoBarras", CodigoBarraEAN.retornarCodigoDoCodigoBarras(codigoEAN));
675 
                        }
676 
                        return (Produto) query.getSingleResult();
677 
                } catch(Exception ex) {
678 
                        ex.printStackTrace();
679 
                        return null;
680 
                }
681 
        }
462 blopes 682 
 
357 espaco 683 
        @Override
684 
        public Produto consultarProdutoPorCodigoRapido(String codigoRapido) {
685 
                StringBuilder sql = new StringBuilder();
686 
                sql.append("SELECT e FROM Produto e ");
687 
                sql.append("WHERE e.codigoRapido = :codigoRapido");
688 
                try {
689 
                        return getEntityManager().createQuery(sql.toString(), Produto.class).setParameter("codigoRapido", codigoRapido).getSingleResult();
690 
                } catch(Exception ex) {
691 
                        ex.printStackTrace();
692 
                        return null;
693 
                }
694 
        }
695 
 
696 
        @Override
697 
        public Long consultarUltimoCodigo() {
698 
                StringBuilder sql = new StringBuilder();
699 
                sql.append("SELECT MAX(CAST(coalesce(p.cod_produto, '0') AS integer)) ");
700 
                sql.append("FROM sc_sec.sec_produto p ");
701 
                sql.append("WHERE p.cod_produto not like '000000'");
702 
                try {
703 
                        return new Long(getEntityManager().createNativeQuery(sql.toString()).getSingleResult().toString());
704 
                } catch(Exception ex) {
705 
                        ex.printStackTrace();
706 
                        return null;
707 
                }
708 
        }
709 
 
710 
        @Override
711 
        public Integer quantidadeTotalEstoque(Loja loja) {
712 
                StringBuilder sql = new StringBuilder();
713 
                sql.append("SELECT SUM(e.quantidadeEstoque) FROM ProdutoLoja e WHERE e.produto.codigo != '000000'");
714 
                if (VerificadorUtil.naoEstaNulo(loja)) {
715 
                        sql.append(" AND e.loja.sequencial = :sequencialLoja");
716 
                }
717 
                try {
718 
                        Long quantidadeTotal = new Long(0);
719 
                        TypedQuery<Long> query =  getEntityManager().createQuery(sql.toString(), Long.class);
720 
                        if (VerificadorUtil.naoEstaNulo(loja)) {
721 
                                query.setParameter("sequencialLoja", loja.getSequencial());
722 
                        }
723 
                        quantidadeTotal = query.getSingleResult();
724 
                        if (VerificadorUtil.naoEstaNulo(quantidadeTotal)) {
725 
                                return quantidadeTotal.intValue();
726 
                        }
727 
                        return 0;
728 
                } catch(Exception ex) {
729 
                        ex.printStackTrace();
730 
                        return 0;
731 
                }
732 
        }
733 
 
734 
 
524 blopes 735 
 
357 espaco 736 
        @Override
737 
        public Integer quantidadeEstoque(ParametrosConsultaProdutoDTO parametrosConsulta) {
738 
                StringBuilder sql = new StringBuilder("SELECT SUM(pl.quantidadeEstoque) FROM ProdutoLoja pl WHERE pl.produto.codigo != '000000'");
739 
                try {
740 
                        setarStringParametrosConsulta(sql, parametrosConsulta);
741 
                        String sqlAlterado = sql.toString().replace(" e.", " pl.produto.").replace("(e.", "(pl.produto.");
742 
                        TypedQuery<Long> query = getEntityManager().createQuery(sqlAlterado, Long.class);
743 
                        setarQueryParametrosConsulta(query, parametrosConsulta);
744 
                        Long quantidade = query.getSingleResult();
745 
                        if (VerificadorUtil.naoEstaNulo(quantidade)) {
746 
                                return quantidade.intValue();
747 
                        }
748 
                        return 0;
749 
                } catch(Exception ex) {
750 
                        ex.printStackTrace();
751 
                        return 0;
752 
                }
753 
        }
754 
 
755 
        @Override
756 
        public Integer quantidadeEstoque(ParametrosConsultaProdutoDTO parametrosConsulta, Long sequencialLoja) {
757 
                StringBuilder sql = new StringBuilder("SELECT SUM(pl.quantidadeEstoque) FROM ProdutoLoja pl WHERE pl.produto.codigo != '000000'");
758 
                try {
759 
                        setarStringParametrosConsulta(sql, parametrosConsulta);
760 
                        sql.append("AND pl.loja.sequencial = :sequencialLoja ");
761 
                        String sqlAlterado = sql.toString().replace(" e.", " pl.produto.").replace("(e.", "(pl.produto.");
762 
                        TypedQuery<Long> query = getEntityManager().createQuery(sqlAlterado, Long.class);
763 
                        setarQueryParametrosConsulta(query, parametrosConsulta);
764 
                        query.setParameter("sequencialLoja", sequencialLoja);
765 
                        Long quantidade = query.getSingleResult();
766 
                        if (VerificadorUtil.naoEstaNulo(quantidade)) {
767 
                                return quantidade.intValue();
768 
                        }
769 
                        return 0;
770 
                } catch(Exception ex) {
771 
                        ex.printStackTrace();
772 
                        return 0;
773 
                }
774 
        }
775 
*/     
776 
        /*
777 
        @Override
778 
        public Integer quantidadeContagens(Long sequencialLoja) {
779 
                StringBuilder sql = new StringBuilder("SELECT COUNT(pl) FROM ProdutoLoja pl WHERE pl.loja.sequencial = :sequencialLoja");
780 
                try {
781 
                        sql.append(" AND (");
782 
                        sql.append("SELECT COUNT(*) FROM TransferenciaProduto tp ");
783 
                        sql.append("WHERE tp.produto = pl.produto AND tp.transferencia.dataFinalizacao is null ");
784 
                        sql.append("AND (tp.transferencia.lojaSaida.sequencial = :sequencialLoja OR tp.transferencia.lojaEntrada.sequencial = :sequencialLoja)");
785 
                        sql.append(")=0 ");
786 
                        sql.append(" AND (");
787 
                        sql.append("(pl.indicadorContagemSolicitada IS TRUE)");
788 
                        sql.append(" OR ");
789 
                        sql.append("(pl.quantidadeEstoque != 0");
790 
                        sql.append(" AND (date_part('day', now() - pl.dataContagem) >= ").append(ConstantesSEC.StatusContagem.CONTAGEM_VERMELHO_60_DIAS);
791 
                        sql.append(" OR pl.dataContagem is null)))");
792 
 
793 
                        TypedQuery<Long> query = getEntityManager().createQuery(sql.toString(), Long.class);
794 
                        query.setParameter("sequencialLoja", sequencialLoja);
795 
                        Long quantidade = query.getSingleResult();
796 
                        if (VerificadorUtil.naoEstaNulo(quantidade)) {
797 
                                return quantidade.intValue();
798 
                        }
799 
                        return 0;
800 
                } catch(Exception ex) {
801 
                        ex.printStackTrace();
802 
                }
803 
                return 0;
804 
        }
805 
        */
806 
/*             
807 
 
808 
        @Override
809 
        public Date dataUltimaVenda(Produto produto) {
810 
                StringBuilder sql = new StringBuilder();
811 
                sql.append("SELECT MAX(e.dataVenda) FROM Venda e ");
812 
                sql.append("LEFT JOIN e.listaLancamentos l ");
813 
                sql.append("WHERE l.ativo IS TRUE ");
814 
                sql.append("AND l.produto.sequencial = :sequencialProduto ");
815 
                try {
816 
                        TypedQuery<Date> query = getEntityManager().createQuery(sql.toString(), Date.class);
817 
                        query.setParameter("sequencialProduto", produto.getSequencial());
818 
                        return query.getSingleResult();
819 
                } catch(Exception ex) {
820 
                        ex.printStackTrace();
821 
                }
822 
                return null;
823 
        }
824 
 
825 
        @Override
826 
        public Integer quantidadeProdutosAdicionadosSite(Date dataInicial, Date dataFinal) {
827 
                StringBuilder sql = new StringBuilder();
828 
                sql.append("SELECT COUNT(p) FROM Produto p ");
829 
                sql.append("WHERE p.dataOnline >= :dataInicial AND p.dataOnline <= :dataFinal ");
830 
                try {
831 
                        TypedQuery<Long> query = getEntityManager().createQuery(sql.toString(), Long.class);
832 
                        query.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(dataInicial));
833 
                        query.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(dataFinal));
834 
                        return query.getSingleResult().intValue();
835 
                } catch(Exception ex) {
836 
                        ex.printStackTrace();
837 
                }
838 
                return null;
839 
        }
840 
 
841 
        @Override
842 
        public Integer quantidadeProdutosOnline() {
843 
                StringBuilder sql = new StringBuilder();
844 
                sql.append("SELECT COUNT(p) FROM Produto p ");
845 
                sql.append("WHERE p.dataOnline IS NOT NULL ");
846 
                try {
847 
                        return getEntityManager().createQuery(sql.toString(), Long.class).getSingleResult().intValue();
848 
                } catch(Exception ex) {
849 
                        ex.printStackTrace();
850 
                }
851 
                return null;
852 
        }
853 
 
854 
        @Override
855 
        public Integer quantidadeProdutosFavoritosOffline(Loja loja) {
856 
                StringBuilder sql = new StringBuilder();
857 
                sql.append("SELECT COUNT(e) FROM Produto e ");
858 
                sql.append("WHERE e.dataOnline IS NULL AND e.modelo.indicadorFavorito IS TRUE ");
859 
                sql.append("AND EXISTS(SELECT p FROM ProdutoLoja p WHERE p.quantidadeEstoque > 0 ");
860 
                sql.append("AND p.produto.sequencial = e.sequencial ");
861 
                if (VerificadorUtil.naoEstaNulo(loja)) {
862 
                        sql.append("AND p.loja.sequencial = :sequencialLoja");
863 
                }
864 
                sql.append(") ");
865 
                try {
866 
                        TypedQuery<Long> query = getEntityManager().createQuery(sql.toString(), Long.class);
867 
                        if (VerificadorUtil.naoEstaNulo(loja)) {
868 
                                query.setParameter("sequencialLoja", loja.getSequencial());
869 
                        }
870 
                        return query.getSingleResult().intValue();
871 
                } catch(Exception ex) {
872 
                        ex.printStackTrace();
873 
                }
874 
                return null;
875 
        }
876 
 
877 
        @Override
878 
        public List<ProdutoHistoricoDTO> consultarHistoricoDeEntradas(Produto produto, Loja loja, Date dataInicial, Date dataFinal) {
879 
                List<ProdutoHistoricoDTO> historico = new ArrayList<ProdutoHistoricoDTO>();
880 
                historico.addAll(consultarHistoricoProduto(produto, dataInicial, dataFinal, TipoLancamentoHistorico.COMPRAS.getValor(), loja));
881 
                historico.addAll(consultarHistoricoProduto(produto, dataInicial, dataFinal, TipoLancamentoHistorico.CONTAGENS_ENTRADA.getValor(), loja));
882 
                return historico;
883 
        }
884 
 
885 
        @Override
886 
        public List<ProdutoHistoricoDTO> consultarHistoricoDeSaidas(Produto produto, Loja loja, Date dataInicial, Date dataFinal) {
887 
                List<ProdutoHistoricoDTO> historico = new ArrayList<ProdutoHistoricoDTO>();
888 
                historico.addAll(consultarHistoricoProduto(produto, dataInicial, dataFinal, TipoLancamentoHistorico.VENDAS.getValor(), loja));
889 
                historico.addAll(consultarHistoricoProduto(produto, dataInicial, dataFinal, TipoLancamentoHistorico.AVARIAS.getValor(), loja));
890 
                historico.addAll(consultarHistoricoProduto(produto, dataInicial, dataFinal, TipoLancamentoHistorico.TROCAS.getValor(), loja));
891 
                historico.addAll(consultarHistoricoProduto(produto, dataInicial, dataFinal, TipoLancamentoHistorico.CONTAGENS_SAIDA.getValor(), loja));
892 
                return historico;
893 
        }
894 
 
895 
        @Override
896 
        public List<ProdutoHistoricoDTO> consultarHistorico(Produto produto, Date dataInicial, Date dataFinal) {
897 
                List<ProdutoHistoricoDTO> historico = new ArrayList<ProdutoHistoricoDTO>();
898 
                historico.addAll(consultarHistoricoProduto(produto, dataInicial, dataFinal, TipoLancamentoHistorico.COMPRAS.getValor(), null));
899 
                historico.addAll(consultarHistoricoProduto(produto, dataInicial, dataFinal, TipoLancamentoHistorico.VENDAS.getValor(), null));
900 
                historico.addAll(consultarHistoricoProduto(produto, dataInicial, dataFinal, TipoLancamentoHistorico.AVARIAS.getValor(), null));
901 
                historico.addAll(consultarHistoricoProduto(produto, dataInicial, dataFinal, TipoLancamentoHistorico.TROCAS.getValor(), null));
902 
                historico.addAll(consultarHistoricoProduto(produto, dataInicial, dataFinal, TipoLancamentoHistorico.DEVOLUCOES.getValor(), null));
903 
                historico.addAll(consultarHistoricoProduto(produto, dataInicial, dataFinal, TipoLancamentoHistorico.CONTAGENS_ENTRADA.getValor(), null));
904 
                historico.addAll(consultarHistoricoProduto(produto, dataInicial, dataFinal, TipoLancamentoHistorico.CONTAGENS_SAIDA.getValor(), null));
905 
                return historico;
906 
        }
907 
 
908 
        private List<ProdutoHistoricoDTO> consultarHistoricoProduto(Produto produto, Date dataInicial, Date dataFinal, String tipoLancamento, Loja loja) {
909 
                StringBuilder sql = new StringBuilder();
910 
                sql.append("SELECT ");
911 
                sql.append("new br.com.ec.domain.dto.ProdutoHistoricoDTO(e.produto, ");
912 
                sql.append("'" + (DataUtils.obterCalendario(dataInicial).get(Calendar.MONTH)+1) + "', ");
913 
                sql.append("'" + DataUtils.obterCalendario(dataInicial).get(Calendar.YEAR) + "', ");
914 
 
915 
                if (tipoLancamento.equals(TipoLancamentoHistorico.VENDAS.getValor())) {
916 
                        sql.append("SUM(e.valorVenda), COUNT(e.produto), ");
917 
                        sql.append("'" + tipoLancamento + "') ");
918 
                        sql.append("FROM Lancamento e ");
919 
                        sql.append("WHERE e.venda.dataVenda >= :dataInicial AND e.venda.dataVenda <= :dataFinal ");
920 
                        if (VerificadorUtil.naoEstaNulo(loja)) {
921 
                                sql.append("AND e.venda.loja <= :loja ");
922 
                        }
923 
                }
924 
 
925 
                if (tipoLancamento.equals(TipoLancamentoHistorico.COMPRAS.getValor())) {
926 
                        sql.append("MAX(e.valorCompra), SUM(e.quantidade), ");
927 
                        sql.append("'" + tipoLancamento + "') ");
928 
                        sql.append("FROM CompraProduto e ");
929 
                        sql.append("WHERE e.compra.dataCompra >= :dataInicial AND e.compra.dataCompra <= :dataFinal ");
930 
                        if (VerificadorUtil.naoEstaNulo(loja)) {
931 
                                sql.append("AND e.compra.loja <= :loja ");
932 
                        }
933 
                }
934 
 
935 
                if (tipoLancamento.equals(TipoLancamentoHistorico.AVARIAS.getValor())) {
936 
                        sql.append(sqlAuditoria(tipoLancamento, TipoEstoqueAuditoria.AVARIA.getValor(), loja));
937 
                }
938 
 
939 
                if (tipoLancamento.equals(TipoLancamentoHistorico.TROCAS.getValor())) {
940 
                        sql.append(sqlAuditoria(tipoLancamento, TipoEstoqueAuditoria.TROCA.getValor(), loja));
941 
                }
942 
 
943 
                if (tipoLancamento.equals(TipoLancamentoHistorico.DEVOLUCOES.getValor())) {
944 
                        sql.append(sqlAuditoria(tipoLancamento, TipoEstoqueAuditoria.DEVOLUCAO.getValor(), loja));
945 
                }
946 
 
947 
                if (tipoLancamento.equals(TipoLancamentoHistorico.CONTAGENS_ENTRADA.getValor())) {
948 
                        sql.append(sqlAuditoria(tipoLancamento, TipoEstoqueAuditoria.CONTAGEM.getValor(), loja));
949 
                        sql.append("AND e.quantidadeEstoqueAnterior < e.quantidadeEstoqueNovo ");
950 
                }
951 
 
952 
                if (tipoLancamento.equals(TipoLancamentoHistorico.CONTAGENS_SAIDA.getValor())) {
953 
                        sql.append(sqlAuditoria(tipoLancamento, TipoEstoqueAuditoria.CONTAGEM.getValor(), loja));
954 
                        sql.append("AND e.quantidadeEstoqueAnterior > e.quantidadeEstoqueNovo ");
955 
                }
956 
 
957 
                if (VerificadorUtil.naoEstaNulo(produto)) {
958 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produto.getSequencial())) {
959 
                                sql.append("AND e.produto.sequencial = :sequencialProduto ");
960 
                        }
961 
                }
962 
                sql.append("GROUP BY e.produto ");
963 
                try {
964 
                        TypedQuery<ProdutoHistoricoDTO> query = getEntityManager().createQuery(sql.toString(), ProdutoHistoricoDTO.class);
965 
                        if (VerificadorUtil.naoEstaNulo(loja)) {
966 
                                query.setParameter("dataInicial", dataInicial);
967 
                                query.setParameter("dataFinal", dataFinal);
968 
                        } else {
969 
                                query.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(dataInicial));
970 
                                query.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(dataFinal));
971 
                        }
972 
                        if (VerificadorUtil.naoEstaNulo(produto)) {
973 
                                if (VerificadorUtil.naoEstaNuloOuVazio(produto.getSequencial())) {
974 
                                        query.setParameter("sequencialProduto", produto.getSequencial());
975 
                                }
976 
                                if (VerificadorUtil.naoEstaNulo(loja)) {
977 
                                        query.setParameter("loja", loja);
978 
                                }
979 
                        }
980 
                        return query.getResultList();
981 
                } catch(Exception ex) {
982 
                        ex.printStackTrace();
983 
                        return null;
984 
                }
985 
        }
986 
 
987 
        private String sqlAuditoria(String tipoLancamento, String tipoEstoqueAuditoria, Loja loja) {
988 
                StringBuilder sql = new StringBuilder();
989 
                sql.append("0.0, COUNT(e.produto), ");
990 
                sql.append("'" + tipoLancamento + "') ");
991 
                sql.append("FROM EstoqueAuditoria e ");
992 
                sql.append("WHERE e.dataAtualizacao >= :dataInicial AND e.dataAtualizacao <= :dataFinal ");
993 
                sql.append("AND e.tipoEstoqueAuditoria like '" + tipoEstoqueAuditoria + "' ");
994 
                if (VerificadorUtil.naoEstaNulo(loja)) {
995 
                        sql.append("AND e.loja = :loja ");
996 
                }
997 
                return sql.toString();
998 
        }
999 
 
1000 
        @Override
1001 
        public List<ProdutoHistoricoDetalhesDTO> detalharHistorico(ProdutoHistoricoDTO produtoHistorico, Date dataInicial, Date dataFinal) {
1002 
                StringBuilder sql = new StringBuilder();
1003 
                sql.append("SELECT ");
1004 
                sql.append("new br.com.ec.domain.dto.ProdutoHistoricoDetalhesDTO(");
1005 
 
1006 
                if (produtoHistorico.getTipoLancamento().equals(TipoLancamentoHistorico.VENDAS.getValor())) {
1007 
                        sql.append("e.venda.sequencial, (SELECT v.nome FROM Vendedor v WHERE v.sequencial = e.venda.vendedor.sequencial), ");
1008 
                        sql.append("e.venda.loja, e.venda.dataVenda, e.valorVenda, ");
1009 
                        sql.append("'" + produtoHistorico.getTipoLancamento() + "', e.observacao) ");
1010 
                        sql.append("FROM Lancamento e ");
1011 
                        sql.append("WHERE e.venda.dataVenda >= :dataInicial AND e.venda.dataVenda <= :dataFinal ");
1012 
                        if (VerificadorUtil.naoEstaNulo(produtoHistorico.getProduto())) {
1013 
                                if (VerificadorUtil.naoEstaNuloOuVazio(produtoHistorico.getProduto().getSequencial())) {
1014 
                                        sql.append("AND e.produto.sequencial = :sequencialProduto ");
1015 
                                }
1016 
                        }
1017 
                        sql.append("ORDER BY e.venda.dataVenda DESC");
1018 
                }
1019 
 
1020 
                if (produtoHistorico.getTipoLancamento().equals(TipoLancamentoHistorico.COMPRAS.getValor())) {
1021 
                        sql.append("e.compra.sequencial, e.compra.dataCompra, e.valorCompra, e.quantidade, ");
1022 
                        sql.append("(SELECT f FROM Fornecedor f WHERE f = e.compra.fornecedor), ");
1023 
                        sql.append("'" + produtoHistorico.getTipoLancamento() + "', e.compra.observacao) ");
1024 
                        sql.append("FROM CompraProduto e ");
1025 
                        sql.append("WHERE e.compra.dataCompra >= :dataInicial AND e.compra.dataCompra <= :dataFinal ");
1026 
                        if (VerificadorUtil.naoEstaNulo(produtoHistorico.getProduto())) {
1027 
                                if (VerificadorUtil.naoEstaNuloOuVazio(produtoHistorico.getProduto().getSequencial())) {
1028 
                                        sql.append("AND e.produto.sequencial = :sequencialProduto ");
1029 
                                }
1030 
                        }
1031 
                        sql.append("ORDER BY e.compra.dataCompra DESC");
1032 
                }
1033 
 
1034 
                if (produtoHistorico.getTipoLancamento().equals(TipoLancamentoHistorico.AVARIAS.getValor())) {
1035 
                        sql.append(sqlAuditoriaDetalhe(produtoHistorico, TipoEstoqueAuditoria.AVARIA.getValor()));
1036 
                        sql.append("ORDER BY e.dataAtualizacao DESC");
1037 
                }
1038 
 
1039 
                if (produtoHistorico.getTipoLancamento().equals(TipoLancamentoHistorico.TROCAS.getValor())) {
1040 
                        sql.append(sqlAuditoriaDetalhe(produtoHistorico, TipoEstoqueAuditoria.TROCA.getValor()));
1041 
                        sql.append("ORDER BY e.dataAtualizacao DESC");
1042 
                }
1043 
 
1044 
                if (produtoHistorico.getTipoLancamento().equals(TipoLancamentoHistorico.DEVOLUCOES.getValor())) {
1045 
                        sql.append(sqlAuditoriaDetalhe(produtoHistorico, TipoEstoqueAuditoria.DEVOLUCAO.getValor()));
1046 
                        sql.append("ORDER BY e.dataAtualizacao DESC");
1047 
                }
1048 
 
1049 
                if (produtoHistorico.getTipoLancamento().equals(TipoLancamentoHistorico.CONTAGENS_ENTRADA.getValor())) {
1050 
                        sql.append(sqlAuditoriaDetalhe(produtoHistorico, TipoEstoqueAuditoria.CONTAGEM.getValor()));
1051 
                        sql.append("AND e.quantidadeEstoqueAnterior < e.quantidadeEstoqueNovo ");
1052 
                        sql.append("ORDER BY e.dataAtualizacao DESC");
1053 
                }
1054 
 
1055 
                if (produtoHistorico.getTipoLancamento().equals(TipoLancamentoHistorico.CONTAGENS_SAIDA.getValor())) {
1056 
                        sql.append(sqlAuditoriaDetalhe(produtoHistorico, TipoEstoqueAuditoria.CONTAGEM.getValor()));
1057 
                        sql.append("AND e.quantidadeEstoqueAnterior > e.quantidadeEstoqueNovo ");
1058 
                        sql.append("ORDER BY e.dataAtualizacao DESC");
1059 
                }
1060 
 
1061 
                try {
1062 
                        TypedQuery<ProdutoHistoricoDetalhesDTO> query = getEntityManager().createQuery(sql.toString(), ProdutoHistoricoDetalhesDTO.class)
1063 
                                        .setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(dataInicial))
1064 
                                        .setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(dataFinal));
1065 
                        if (VerificadorUtil.naoEstaNulo(produtoHistorico.getProduto())) {
1066 
                                if (VerificadorUtil.naoEstaNuloOuVazio(produtoHistorico.getProduto().getSequencial())) {
1067 
                                        query.setParameter("sequencialProduto", produtoHistorico.getProduto().getSequencial());
1068 
                                }
1069 
                        }
1070 
                        return query.getResultList();
1071 
                } catch(Exception ex) {
1072 
                        ex.printStackTrace();
1073 
                        return null;
1074 
                }
1075 
        }
1076 
 
1077 
        private String sqlAuditoriaDetalhe(ProdutoHistoricoDTO produtoHistorico, String tipoEstoqueAuditoria) {
1078 
                StringBuilder sql = new StringBuilder();
1079 
                sql.append("e.sequencial, (SELECT u.nome FROM Usuario u WHERE u.sequencial = e.usuario.sequencial), e.loja, e.dataAtualizacao, 0.0, ");
1080 
                sql.append("'" + produtoHistorico.getTipoLancamento() + "'");
1081 
                if (tipoEstoqueAuditoria.equals(TipoEstoqueAuditoria.CONTAGEM.getValor())) {
1082 
                        sql.append(", e.quantidadeEstoqueNovo - e.quantidadeEstoqueAnterior");
1083 
                }
1084 
                sql.append(", e.observacao) ");
1085 
                sql.append("FROM EstoqueAuditoria e ");
1086 
                sql.append("WHERE e.dataAtualizacao >= :dataInicial AND e.dataAtualizacao <= :dataFinal ");
1087 
                sql.append("AND e.tipoEstoqueAuditoria like '" + tipoEstoqueAuditoria + "' ");
1088 
                if (VerificadorUtil.naoEstaNulo(produtoHistorico.getProduto())) {
1089 
                        if (VerificadorUtil.naoEstaNuloOuVazio(produtoHistorico.getProduto().getSequencial())) {
1090 
                                sql.append("AND e.produto.sequencial = :sequencialProduto ");
1091 
                        }
1092 
                }
1093 
                return sql.toString();
1094 
        }
1095 
        */
1096 
 
1097 
}