Subversion Repositories Integrator Subversion

Rev

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