Subversion Repositories Integrator Subversion

Rev

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

Rev Author Line No. Line
259 espaco 1 
package br.com.ec.repository.jpa;
2 
 
282 espaco 3 
import java.util.Date;
4 
import java.util.List;
5 
 
296 espaco 6 
import javax.persistence.Query;
282 espaco 7 
import javax.persistence.TypedQuery;
8 
 
259 espaco 9 
import org.springframework.stereotype.Repository;
10 
 
296 espaco 11 
import br.com.ec.core.consulta.ParametrosConsulta;
282 espaco 12 
import br.com.ec.core.util.VerificadorUtil;
296 espaco 13 
import br.com.ec.domain.dto.FormaPagamentoDTO;
282 espaco 14 
import br.com.ec.domain.dto.ParcelaDTO;
296 espaco 15 
import br.com.ec.domain.dto.consulta.ParametrosConsultaLancamentosDTO;
282 espaco 16 
import br.com.ec.domain.dto.consulta.ParametrosConsultaParcelasDTO;
259 espaco 17 
import br.com.ec.domain.model.Parcela;
18 
import br.com.ec.repository.ParcelaRepository;
19 
import br.com.ec.repository.SistemaAbstractRepository;
20 
 
21 
@Repository
22 
public class ParcelaRepositoryJpaImpl extends SistemaAbstractRepository<Parcela> implements ParcelaRepository {
23 
 
24 
        @Override
25 
        protected String getColunaOrdenadora() {
26 
                return "sequencial";
27 
        }
282 espaco 28 
 
29 
        @Override
30 
        public List<ParcelaDTO> consultarParcelas(ParametrosConsultaParcelasDTO parametrosConsultaParcelasDTO) {
31 
                StringBuilder sql = new StringBuilder();
319 espaco 32 
                sql.append("SELECT new br.com.ec.domain.dto.ParcelaDTO(");
33 
                sql.append(ParcelaDTO.CONSULTA_COMPLETA_DTO);
34 
                sql.append(") FROM Parcela e ");
343 espaco 35 
                sql.append("WHERE e.indicadorAtivo is true ");
282 espaco 36 
                if (VerificadorUtil.naoEstaNulo(parametrosConsultaParcelasDTO.getTipoBusca())) {
319 espaco 37 
                        sql.append("AND e.conta.tipoConta = :tipoConta ");
282 espaco 38 
                }
294 espaco 39 
                if (VerificadorUtil.naoEstaNulo(parametrosConsultaParcelasDTO.getSequencialCategoria())) {
319 espaco 40 
                        sql.append("AND e.conta.categoria.sequencial = :sequencialCategoria ");
294 espaco 41 
                }
282 espaco 42 
                if (parametrosConsultaParcelasDTO.getPagamentoRealizado()) {
43 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsultaParcelasDTO.getDataInicial()) &&
44 
                                        VerificadorUtil.naoEstaNulo(parametrosConsultaParcelasDTO.getDataFinal())) {
319 espaco 45 
                                sql.append("AND e.dataPagamento is not null ");
46 
                                sql.append("AND e.dataPagamento >= :dataInicial AND e.dataPagamento <= :dataFinal ");
282 espaco 47 
                        }
48 
                }
319 espaco 49 
                sql.append("ORDER BY e.dataVencimento ");
282 espaco 50 
                try {
51 
                        TypedQuery<ParcelaDTO> query = getEntityManager().createQuery(sql.toString(), ParcelaDTO.class);
52 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsultaParcelasDTO.getTipoBusca())) {
53 
                                query.setParameter("tipoConta", parametrosConsultaParcelasDTO.getTipoBusca());
54 
                        }
294 espaco 55 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsultaParcelasDTO.getSequencialCategoria())) {
56 
                                query.setParameter("sequencialCategoria", parametrosConsultaParcelasDTO.getSequencialCategoria());
57 
                        }
282 espaco 58 
                        if (parametrosConsultaParcelasDTO.getPagamentoRealizado()) {
59 
                                if (VerificadorUtil.naoEstaNulo(parametrosConsultaParcelasDTO.getDataInicial()) &&
60 
                                                VerificadorUtil.naoEstaNulo(parametrosConsultaParcelasDTO.getDataFinal())) {
61 
                                        query.setParameter("dataInicial", parametrosConsultaParcelasDTO.getDataInicial());
62 
                                        query.setParameter("dataFinal", parametrosConsultaParcelasDTO.getDataFinal());
63 
                                }
64 
                        }
65 
                        return query.getResultList();
66 
                } catch(Exception ex) {
67 
                        ex.printStackTrace();
68 
                        return null;
69 
                }
70 
        }
71 
 
72 
        @Override
382 espaco 73 
        public List<ParcelaDTO> consultarParcelas(Long sequencialContaBancaria, Date dataRecebimento, List<FormaPagamentoDTO> formasDePagamento) {
74 
                StringBuilder sql = new StringBuilder();
75 
                sql.append("SELECT new br.com.ec.domain.dto.ParcelaDTO(");
76 
                sql.append(ParcelaDTO.CONSULTA_SEM_CATEGORIA_DTO);
77 
                sql.append(") FROM Parcela e ");
78 
                sql.append("WHERE e.contaBancaria.sequencial = :sequencialContaBancaria ");
79 
                sql.append("AND e.dataVencimento = :dataVencimento ");
80 
                sql.append("AND (e.dataPagamento is null OR e.dataPagamento = :dataVencimento) ");
81 
                sql.append(setarParametrosFormasDePagamento("e", formasDePagamento));
82 
                sql.append("AND e.indicadorAtivo is true ");
83 
                sql.append("ORDER BY e.dataVencimento ");
84 
                try {
85 
                        return getEntityManager().createQuery(sql.toString(), ParcelaDTO.class)
86 
                                        .setParameter("sequencialContaBancaria", sequencialContaBancaria)
87 
                                        .setParameter("dataVencimento", dataRecebimento)
88 
                                        .getResultList();
89 
                } catch(Exception ex) {
90 
                        ex.printStackTrace();
91 
                        return null;
92 
                }
93 
        }
94 
 
95 
        @Override
296 espaco 96 
        public List<ParcelaDTO> consultarParcelasAReceber(Long sequencialContaBancaria, Date dataRecebimento, List<FormaPagamentoDTO> formasDePagamento) {
282 espaco 97 
                StringBuilder sql = new StringBuilder();
319 espaco 98 
                sql.append("SELECT new br.com.ec.domain.dto.ParcelaDTO(");
99 
                sql.append(ParcelaDTO.CONSULTA_SEM_CATEGORIA_DTO);
100 
                sql.append(") FROM Parcela e ");
101 
                sql.append("WHERE e.contaBancaria.sequencial = :sequencialContaBancaria ");
102 
                sql.append("AND e.dataVencimento = :dataVencimento ");
103 
                sql.append(setarParametrosFormasDePagamento("e", formasDePagamento));
104 
                sql.append("AND e.dataPagamento is null ");
343 espaco 105 
                sql.append("AND e.indicadorAtivo is true ");
319 espaco 106 
                sql.append("ORDER BY e.dataVencimento ");
282 espaco 107 
                try {
108 
                        return getEntityManager().createQuery(sql.toString(), ParcelaDTO.class)
109 
                                        .setParameter("sequencialContaBancaria", sequencialContaBancaria)
110 
                                        .setParameter("dataVencimento", dataRecebimento)
111 
                                        .getResultList();
112 
                } catch(Exception ex) {
113 
                        ex.printStackTrace();
114 
                        return null;
115 
                }
116 
        }
117 
 
118 
        @Override
296 espaco 119 
        public List<ParcelaDTO> consultarParcelasRecebidas(Long sequencialContaBancaria, Date dataRecebimento, List<FormaPagamentoDTO> formasDePagamento) {
282 espaco 120 
                StringBuilder sql = new StringBuilder();
319 espaco 121 
                sql.append("SELECT new br.com.ec.domain.dto.ParcelaDTO(");
122 
                sql.append(ParcelaDTO.CONSULTA_SEM_CATEGORIA_DTO);
123 
                sql.append(") FROM Parcela e ");
124 
                sql.append("WHERE e.contaBancaria.sequencial = :sequencialContaBancaria ");
125 
                sql.append("AND e.dataPagamento = :dataPagamento ");
343 espaco 126 
                sql.append("AND e.indicadorAtivo is true ");
319 espaco 127 
                sql.append(setarParametrosFormasDePagamento("e", formasDePagamento));
128 
                sql.append("ORDER BY e.dataVencimento ");
282 espaco 129 
                try {
130 
                        return getEntityManager().createQuery(sql.toString(), ParcelaDTO.class)
131 
                                        .setParameter("sequencialContaBancaria", sequencialContaBancaria)
294 espaco 132 
                                        .setParameter("dataPagamento", dataRecebimento)
282 espaco 133 
                                        .getResultList();
134 
                } catch(Exception ex) {
135 
                        ex.printStackTrace();
136 
                        return null;
137 
                }
138 
        }
139 
 
296 espaco 140 
        private String setarParametrosFormasDePagamento(String nomeTabela, List<FormaPagamentoDTO> formasPagamento) {
141 
                StringBuilder sql = new StringBuilder();
142 
                if (VerificadorUtil.isListaComElementos(formasPagamento)) {
143 
                        sql.append("AND ");
144 
                        sql.append(nomeTabela);
145 
                        sql.append(".formaPagamento.codigo IN (");
146 
                        for (FormaPagamentoDTO formaPagamento : formasPagamento) {
147 
                                sql.append(formaPagamento.getCodigo() + ",");
148 
                        }
149 
                        sql.append(") ");
150 
                }
151 
                return sql.toString().replace(",)", ")");
152 
        }
153 
 
154 
        @Override
155 
        public void alterarDataPagamento(Long sequencialParcela, Date dataPagamento) {
156 
                StringBuilder sql = new StringBuilder();
157 
                sql.append("UPDATE Parcela parcela SET parcela.dataPagamento = :dataPagamento ");
158 
                sql.append("WHERE parcela.sequencial = :sequencialParcela ");
159 
                try {
160 
                        getEntityManager().createQuery(sql.toString())
161 
                                .setParameter("dataPagamento", dataPagamento)
162 
                                .setParameter("sequencialParcela", sequencialParcela)
163 
                                .executeUpdate();
164 
                        getEntityManager().flush();
165 
                } catch(Exception ex) {
166 
                        ex.printStackTrace();
167 
                }
168 
        }
169 
 
170 
        @Override
171 
        public Double obterValorPassandoParametrosConsulta(ParametrosConsulta<Parcela> parametrosConsulta) {
172 
                StringBuilder sql = new StringBuilder();
173 
                sql.append("SELECT DISTINCT SUM(e.valor) FROM Parcela e ");
174 
                sql.append("WHERE e.indicadorAtivo is true ");
175 
                try {
176 
                        setarStringParametrosConsulta(sql, parametrosConsulta);
177 
                        TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
178 
                        setarQueryParametrosConsulta(query, parametrosConsulta);
179 
                        return query.getSingleResult();
180 
                } catch(Exception ex) {
181 
                        ex.printStackTrace();
182 
                        return null;
183 
                }
184 
        }
185 
 
186 
        @Override
297 espaco 187 
        public List<ParcelaDTO> consultarParcelasPassandoParametrosConsulta(ParametrosConsulta<Parcela> parametrosConsulta) {
188 
                StringBuilder sql = new StringBuilder();
319 espaco 189 
                sql.append("SELECT new br.com.ec.domain.dto.ParcelaDTO(");
190 
                sql.append(ParcelaDTO.CONSULTA_COMPLETA_DTO);
191 
                sql.append(") FROM Parcela e ");
297 espaco 192 
//              sql.append("SELECT DISTINCT SUM(e.valor) FROM Parcela e ");
193 
                sql.append("WHERE e.indicadorAtivo is true ");
194 
                try {
195 
                        setarStringParametrosConsulta(sql, parametrosConsulta);
196 
                        TypedQuery<ParcelaDTO> query = getEntityManager().createQuery(sql.toString(), ParcelaDTO.class);
197 
                        setarQueryParametrosConsulta(query, parametrosConsulta);
198 
                        return query.getResultList();
199 
                } catch(Exception ex) {
200 
                        ex.printStackTrace();
201 
                        return null;
202 
                }
203 
        }
204 
 
205 
        @Override
296 espaco 206 
        protected void setarStringParametrosConsulta(StringBuilder sql, ParametrosConsulta<Parcela> parametrosConsulta) {
207 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta)) {
208 
                        if (VerificadorUtil.naoEstaNuloOuVazio(((ParametrosConsultaLancamentosDTO)parametrosConsulta).getVigencia())) {
209 
                                if (((ParametrosConsultaLancamentosDTO)parametrosConsulta).getVigencia().getSequencial().equals(new Long(-1))) {
210 
                                        sql.append("AND e.conta.vigencia IS NULL ");
211 
                                } else {
212 
                                        sql.append("AND e.conta.vigencia.sequencial = :sequencialVigencia ");
213 
                                }
214 
                        }
215 
 
216 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaLancamentosDTO) parametrosConsulta).getCentroDeCustos())) {
217 
                                if (((ParametrosConsultaLancamentosDTO)parametrosConsulta).getCentroDeCustos().getSequencial().equals(new Long(-1))) {
218 
                                        sql.append("AND e.conta.loja IS NULL ");
219 
                                } else {
220 
                                        sql.append("AND e.conta.loja.sequencial = :sequencialCentroDeCustos ");
221 
                                }
222 
                        }
223 
 
224 
                        if (VerificadorUtil.naoEstaNuloOuVazio(((ParametrosConsultaLancamentosDTO)parametrosConsulta).getIndicadorDre())) {
225 
                                sql.append("AND e.conta.categoria.indicadorDRE.codigo = :codigoIndicadorDre ");
226 
                        } else if (((ParametrosConsultaLancamentosDTO)parametrosConsulta).getPagamentoRealizado()) {
227 
                                if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaLancamentosDTO)parametrosConsulta).getDataInicialDoPeriodo()) &&
228 
                                                VerificadorUtil.naoEstaNulo(((ParametrosConsultaLancamentosDTO)parametrosConsulta).getDataFinalDoPeriodo())) {
229 
                                        sql.append("AND e.dataPagamento is not null ");
230 
                                        sql.append("AND e.dataPagamento >= :dataInicial AND e.dataPagamento <= :dataFinal ");
231 
                                }
232 
                        } else {
233 
                                sql.append("AND e.dataPagamento is null ");
234 
                                if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaLancamentosDTO)parametrosConsulta).getDataVencimento())) {
235 
                                        sql.append("AND e.dataVencimento = :dataVencimento ");
236 
                                }
237 
                                /*
238 
                                if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaLancamentosDTO)parametrosConsulta).getTipoFormaDePagamento())) {
239 
                                        if (((ParametrosConsultaLancamentosDTO)parametrosConsulta).getTipoFormaDePagamento().equals(TipoCartao.DEBITO.getValor())) {
240 
                                                sql.append("AND e.conta.formaDePagamento.formaPagamento.codigo = 2 ");
241 
                                        } else if (((ParametrosConsultaLancamentosDTO)parametrosConsulta).getTipoFormaDePagamento().equals(TipoCartao.CREDITO.getValor())) {
242 
                                                sql.append("AND e.conta.formaDePagamento.formaPagamento.codigo in (3, 4, 5, 7, 8, 9, 10, 11, 12, 13) ");
243 
                                        }
244 
                                }
245 
                                */
246 
                        }
247 
                        /*
248 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaLancamentosDTO)parametrosConsulta).getContaBancaria())) {
249 
                                sql.append("AND e.contaBancaria.sequencial = :sequencialContaBancaria ");
250 
                        }
251 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaLancamentosDTO)parametrosConsulta).getTipoBusca())) {
252 
                                if (((ParametrosConsultaLancamentosDTO)parametrosConsulta).getTipoBusca().equals("R")) {
253 
                                        sql.append("AND e.conta.tipoConta = 'R' ");
254 
                                }
255 
                                if (((ParametrosConsultaLancamentosDTO)parametrosConsulta).getTipoBusca().equals("P")) {
256 
                                        sql.append("AND e.conta.tipoConta = 'P' ");
257 
                                }
258 
                        }
259 
 
260 
 
261 
 
262 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaLancamentosDTO)parametrosConsulta).getCategoria())) {
263 
                                sql.append("AND e.conta.categoria.sequencial = :sequencialCategoria ");
264 
                        }
265 
 
266 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaLancamentosDTO)parametrosConsulta).getFavorecido())) {
267 
                                sql.append("AND e.conta.pessoa.sequencial = :sequencialPessoa ");
268 
                        }
269 
 
270 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaLancamentosDTO)parametrosConsulta).getFavorecido())) {
271 
                                sql.append("AND e.conta.pessoa.sequencial = :sequencialPessoa ");
272 
                        }
273 
                        if (VerificadorUtil.naoEstaNuloOuVazio(((ParametrosConsultaLancamentosDTO)parametrosConsulta).getObservacao())) {
274 
                                sql.append("AND upper(e.observacao) like upper(:observacao) ");
275 
                        }
276 
 
277 
                        if (VerificadorUtil.naoEstaNuloOuVazio(((ParametrosConsultaLancamentosDTO)parametrosConsulta).getOficial())) {
278 
                                if (((ParametrosConsultaLancamentosDTO)parametrosConsulta).getOficial()) {
279 
                                        sql.append("AND e.indicadorOficial IS TRUE ");
280 
                                } else {
281 
                                        sql.append("AND e.indicadorOficial IS FALSE ");
282 
                                }
283 
                        }
284 
                         */
285 
                }
286 
        }
287 
 
288 
        @Override
289 
        protected void setarQueryParametrosConsulta(Query query, ParametrosConsulta<Parcela> parametrosConsulta) {
290 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta)) {
291 
                        if (VerificadorUtil.naoEstaNuloOuVazio(((ParametrosConsultaLancamentosDTO)parametrosConsulta).getVigencia())) {
292 
                                if (!((ParametrosConsultaLancamentosDTO)parametrosConsulta).getVigencia().getSequencial().equals(new Long(-1))) {
293 
                                        query.setParameter("sequencialVigencia", ((ParametrosConsultaLancamentosDTO) parametrosConsulta).getVigencia().getSequencial());
294 
                                }
295 
                        }
296 
 
297 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaLancamentosDTO) parametrosConsulta).getCentroDeCustos())) {
298 
                                if (!((ParametrosConsultaLancamentosDTO)parametrosConsulta).getCentroDeCustos().getSequencial().equals(new Long(-1))) {
299 
                                        query.setParameter("sequencialCentroDeCustos", ((ParametrosConsultaLancamentosDTO) parametrosConsulta).getCentroDeCustos().getSequencial());
300 
                                }
301 
                        }
302 
 
303 
                        if (VerificadorUtil.naoEstaNuloOuVazio(((ParametrosConsultaLancamentosDTO)parametrosConsulta).getIndicadorDre())) {
304 
                                query.setParameter("codigoIndicadorDre", ((ParametrosConsultaLancamentosDTO) parametrosConsulta).getIndicadorDre().getCodigo());
305 
                        }
306 
 
307 
                        if (((ParametrosConsultaLancamentosDTO)parametrosConsulta).getPagamentoRealizado()) {
308 
                                if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaLancamentosDTO)parametrosConsulta).getDataInicialDoPeriodo()) &&
309 
                                                VerificadorUtil.naoEstaNulo(((ParametrosConsultaLancamentosDTO)parametrosConsulta).getDataFinalDoPeriodo())) {
310 
                                        query.setParameter("dataInicial", ((ParametrosConsultaLancamentosDTO)parametrosConsulta).getDataInicialDoPeriodo());
311 
                                        query.setParameter("dataFinal", ((ParametrosConsultaLancamentosDTO)parametrosConsulta).getDataFinalDoPeriodo());
312 
                                }
313 
                        } else if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaLancamentosDTO)parametrosConsulta).getDataVencimento())) {
314 
                                query.setParameter("dataVencimento", ((ParametrosConsultaLancamentosDTO)parametrosConsulta).getDataVencimento());
315 
                        }
316 
                }
317 
                /*
318 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta)) {
319 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaLancamentosDTO)parametrosConsulta).getContaBancaria())) {
320 
                                query.setParameter("sequencialContaBancaria", ((ParametrosConsultaLancamentosDTO)parametrosConsulta).getContaBancaria().getSequencial());
321 
                        }
322 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaLancamentosDTO)parametrosConsulta).getCategoria())) {
323 
                                query.setParameter("sequencialCategoria", ((ParametrosConsultaLancamentosDTO) parametrosConsulta).getCategoria().getSequencial());
324 
                        }
325 
 
326 
                        if (VerificadorUtil.naoEstaNulo(((ParametrosConsultaLancamentosDTO)parametrosConsulta).getFavorecido())) {
327 
                                query.setParameter("sequencialPessoa", ((ParametrosConsultaLancamentosDTO) parametrosConsulta).getFavorecido().getSequencial());
328 
                        }
329 
 
330 
                        if (VerificadorUtil.naoEstaNuloOuVazio(((ParametrosConsultaLancamentosDTO)parametrosConsulta).getObservacao())) {
331 
                                query.setParameter("observacao", "%" + ((ParametrosConsultaLancamentosDTO) parametrosConsulta).getObservacao() + "%");
332 
                        }
333 
                }
334 
                */
335 
        }
336 
 
337 
        @Override
338 
        protected void setarStringParametrosConsultar(StringBuilder sql, Parcela parcela) {
339 
                /*
340 
                if (VerificadorUtil.naoEstaNulo(parcela)) {
341 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parcela.getConta())) {
342 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parcela.getConta().getSequencial())) {
343 
                                        sql.append("AND e.conta.sequencial = :sequencialConta ");
344 
                                }
345 
                        }
346 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parcela.getIndicadorAtivo())) {
347 
                                sql.append("AND e.indicadorAtivo = :indicadorAtivo ");
348 
                        }
349 
                }
350 
                */
351 
        }
352 
 
353 
        @Override
354 
        protected void setarQueryParametrosConsultar(Query query, Parcela parcela) {
355 
                /*
356 
                if (VerificadorUtil.naoEstaNulo(parcela)) {
357 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parcela.getConta())) {
358 
                                if (VerificadorUtil.naoEstaNuloOuVazio(parcela.getConta().getSequencial())) {
359 
                                        query.setParameter("sequencialConta", parcela.getConta().getSequencial());
360 
                                }
361 
                        }
362 
                        if (VerificadorUtil.naoEstaNuloOuVazio(parcela.getIndicadorAtivo())) {
363 
                                query.setParameter("indicadorAtivo", parcela.getIndicadorAtivo());
364 
                        }
365 
                }
366 
                */
367 
        }
368 
 
259 espaco 369 
        /*
370 
        @Override
371 
        public List<Parcela> consultarParcelas(ParametrosConsultaLancamentosDTO parametrosConsulta) {
372 
                StringBuilder sql = new StringBuilder();
373 
                sql.append("SELECT p FROM Parcela p ");
374 
                sql.append("WHERE ((p.dataPagamento IS NOT NULL AND p.dataPagamento >= :dataInicial AND p.dataPagamento <= :dataFinal) ");
375 
                sql.append("OR (p.dataPagamento IS NULL AND p.dataVencimento <= :dataFinal)) ");
376 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoBusca())) {
377 
                        sql.append("AND p.conta.tipoConta = :tipoConta ");
378 
                }
379 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getCentroDeCustos())) {
380 
                        if (parametrosConsulta.getCentroDeCustos().getSequencial().equals(new Long(-1))) {
381 
                                sql.append("AND p.conta.loja IS NULL ");
382 
                        } else {
383 
                                sql.append("AND p.conta.loja.sequencial = :sequencialCentroDeCustos ");
384 
                        }
385 
                }
386 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getCategoria())) {
387 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getCategoria().getSequencial())) {
388 
                                sql.append("AND p.conta.categoria.sequencial = :sequencialCategoria ");
389 
                        } else {
390 
                                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getCategoriaPai().getSequencial())) {
391 
                                        sql.append("AND p.conta.categoria.sequencial = :sequencialCategoriaPai ");
392 
                                } else {
393 
                                        sql.append("AND p.conta.categoria IS NULL ");
394 
                                }
395 
                        }
396 
                }
397 
                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getOficial())) {
398 
                        if (parametrosConsulta.getOficial()) {
399 
                                sql.append("AND p.indicadorOficial IS TRUE ");
400 
                        } else {
401 
                                sql.append("AND p.indicadorOficial IS FALSE ");
402 
                        }
403 
                }
404 
                sql.append("ORDER BY p.dataVencimento ");
405 
                try {
406 
                        TypedQuery<Parcela> query = getEntityManager().createQuery(sql.toString(), Parcela.class)
407 
                                .setParameter("dataInicial", parametrosConsulta.getDataInicial())
408 
                                .setParameter("dataFinal", parametrosConsulta.getDataFinal());
409 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoBusca())) {
410 
                                query.setParameter("tipoConta", parametrosConsulta.getTipoBusca());
411 
                        }
412 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getCentroDeCustos())) {
413 
                                if (!parametrosConsulta.getCentroDeCustos().getSequencial().equals(new Long(-1))) {
414 
                                        query.setParameter("sequencialCentroDeCustos", parametrosConsulta.getCentroDeCustos().getSequencial());
415 
                                }
416 
                        }
417 
                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getCategoria())) {
418 
                                if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getCategoria().getSequencial())) {
419 
                                        query.setParameter("sequencialCategoria", parametrosConsulta.getCategoria().getSequencial());
420 
                                } else {
421 
                                        if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getCategoriaPai().getSequencial())) {
422 
                                                query.setParameter("sequencialCategoriaPai", parametrosConsulta.getCategoriaPai().getSequencial());
423 
                                        }
424 
                                }
425 
                        }
426 
                        return query.getResultList();
427 
                } catch(Exception ex) {
428 
                        ex.printStackTrace();
429 
                        return null;
430 
                }
431 
        }
432 
 
433 
        @Override
434 
        public List<Parcela> consultarParcelasAVencer(Conta conta) {
435 
                StringBuilder sql = new StringBuilder();
436 
                sql.append("SELECT p FROM Parcela p ");
437 
                sql.append("WHERE p.conta.sequencial = :sequencialConta ");
438 
                sql.append("AND p.dataPagamento is null ");
439 
                sql.append("ORDER BY p.sequencial ");
440 
                try {
441 
                        return getEntityManager().createQuery(sql.toString(), Parcela.class)
442 
                                        .setParameter("sequencialConta", conta.getSequencial())
443 
                                        .getResultList();
444 
                } catch(Exception ex) {
445 
                        ex.printStackTrace();
446 
                        return null;
447 
                }
448 
        }
449 
 
450 
        @Override
451 
        public List<Parcela> consultarParcelasRecebidas(Date dataRecebimento, TipoCartao tipoCartao) {
452 
                StringBuilder sql = new StringBuilder();
453 
                sql.append("SELECT p FROM Parcela p ");
454 
                sql.append("WHERE p.dataVencimento = :dataVencimento ");
455 
                sql.append("AND p.observacao like UPPER(:observacao) ");
456 
                sql.append("AND p.dataPagamento is not null ");
457 
                sql.append("ORDER BY p.dataVencimento ");
458 
                try {
459 
                        return getEntityManager().createQuery(sql.toString(), Parcela.class)
460 
                                        .setParameter("dataVencimento", dataRecebimento)
461 
                                        .setParameter("observacao", StringUtil.setarUpperCase("%" + tipoCartao.getDescricao() + "%"))
462 
                                        .getResultList();
463 
                } catch(Exception ex) {
464 
                        ex.printStackTrace();
465 
                        return null;
466 
                }
467 
        }
468 
 
469 
        @Override
470 
        public List<Parcela> consultarPassandoParametrosConsulta(ParametrosConsulta<Parcela> parametrosConsulta,
471 
                        Integer primeiroRegistro, Integer tamanhoPagina, String sortField, String sortOrder,
472 
                        Map<String, Object> filters) {
473 
                StringBuilder sql = new StringBuilder();
474 
                sql.append("SELECT DISTINCT e FROM Parcela e ");
475 
                sql.append("WHERE e.indicadorAtivo is true ");
476 
                try {
477 
                        setarStringParametrosConsulta(sql, parametrosConsulta);
478 
                        sql.append("ORDER BY " + ((ParametrosConsultaLancamentosDTO)parametrosConsulta).getOrdenacao());
479 
                        TypedQuery<Parcela> query = getEntityManager().createQuery(sql.toString(), Parcela.class);
480 
                        setarQueryParametrosConsulta(query, parametrosConsulta);
481 
                        return query.setFirstResult(primeiroRegistro).setMaxResults(tamanhoPagina).getResultList();
482 
                } catch(Exception ex) {
483 
                        ex.printStackTrace();
484 
                        return null;
485 
                }
486 
        }
487 
 
488 
        @Override
489 
        public List<Parcela> consultarParcelasDaVenda(Long sequencialVenda) {
490 
                StringBuilder sql = new StringBuilder();
491 
                sql.append("SELECT p FROM Parcela p ");
492 
                sql.append("WHERE p.conta.venda.sequencial = :sequencialVenda ");
493 
                sql.append("ORDER BY p.dataVencimento ");
494 
                try {
495 
                        return getEntityManager().createQuery(sql.toString(), Parcela.class).setParameter("sequencialVenda", sequencialVenda).getResultList();
496 
                } catch(Exception ex) {
497 
                        ex.printStackTrace();
498 
                        return null;
499 
                }
500 
        }
501 
 
502 
        @Override
503 
        public Boolean verificarPossuiParcelaAberta(Venda venda) {
504 
                StringBuilder sql = new StringBuilder();
505 
                sql.append("SELECT COUNT(p) FROM Parcela p WHERE p.dataPagamento is null AND p.indicadorAtivo = true ");
506 
                sql.append("AND p.conta.venda.sequencial = :sequencialVenda ");
507 
                TypedQuery<Long> query = getEntityManager().createQuery(sql.toString(), Long.class);
508 
                query.setParameter("sequencialVenda", venda.getSequencial());
509 
                return query.getSingleResult().intValue()>0;
510 
        }
511 
 
512 
        @Override
513 
        public Boolean verificarPossuiParcelaAbertaParaPagamento(Conta conta) {
514 
                StringBuilder sql = new StringBuilder();
515 
                sql.append("SELECT COUNT(p) FROM Parcela p WHERE p.dataPagamento is null AND p.indicadorAtivo = true ");
516 
                sql.append("AND p.conta.sequencial = :sequencialConta ");
517 
                TypedQuery<Long> query = getEntityManager().createQuery(sql.toString(), Long.class);
518 
                query.setParameter("sequencialConta", conta.getSequencial());
519 
                return query.getSingleResult().intValue()>0;
520 
        }
521 
 
522 
        @Override
523 
        public List<Parcela> consultarParcelasDaConta(Conta conta) {
524 
                StringBuilder sql = new StringBuilder();
525 
                sql.append("SELECT p FROM Parcela p WHERE p.indicadorAtivo = true ");
526 
                sql.append("AND p.conta.sequencial = :sequencialConta ");
527 
                return getEntityManager().createQuery(sql.toString(), Parcela.class).setParameter("sequencialConta", conta.getSequencial()).getResultList();
528 
        }
529 
 
530 
        @Override
531 
        public Boolean verificarPossuiParcela(Venda venda) {
532 
                StringBuilder sql = new StringBuilder();
533 
                sql.append("SELECT COUNT(p) FROM Parcela p WHERE p.indicadorAtivo = true ");
534 
                sql.append("AND p.conta.venda.sequencial = :sequencialVenda ");
535 
                TypedQuery<Long> query = getEntityManager().createQuery(sql.toString(), Long.class);
536 
                query.setParameter("sequencialVenda", venda.getSequencial());
537 
                return query.getSingleResult().intValue()>0;
538 
        }
539 
 
540 
 
541 
        */
542 
}