Subversion Repositories Integrator Subversion

Rev

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