Subversion Repositories Integrator Subversion

Rev

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