Subversion Repositories Integrator Subversion

Rev

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