Subversion Repositories Integrator Subversion

Rev

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