Subversion Repositories Integrator Subversion

Rev

Rev 646 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
610 blopes 1
package br.com.ec.controller;
2
 
732 blopes 3
import java.io.IOException;
610 blopes 4
import java.io.Serializable;
5
import java.util.ArrayList;
6
import java.util.Date;
7
import java.util.List;
8
 
732 blopes 9
import javax.annotation.PostConstruct;
610 blopes 10
import javax.inject.Inject;
11
import javax.inject.Named;
12
 
13
import org.primefaces.model.file.UploadedFile;
14
import org.springframework.context.annotation.Scope;
15
 
16
import br.com.ec.controller.consultademanda.AvaliacaoConsultaPorDemanda;
17
import br.com.ec.core.consulta.ParametrosConsulta;
18
import br.com.ec.core.generic.GenericService;
19
import br.com.ec.core.util.VerificadorUtil;
20
import br.com.ec.domain.dto.AvaliacaoDTO;
732 blopes 21
import br.com.ec.domain.dto.ParcelaDTO;
610 blopes 22
import br.com.ec.domain.dto.ValeTransporteDTO;
23
import br.com.ec.domain.dto.ValeTransporteFuncionarioDTO;
24
import br.com.ec.domain.dto.ValeTransporteFuncionarioExtraidoDTO;
732 blopes 25
import br.com.ec.domain.dto.VigenciaDTO;
610 blopes 26
import br.com.ec.domain.model.Avaliacao;
732 blopes 27
import br.com.ec.domain.model.tipos.TipoSituacoesVigencia;
28
import br.com.ec.domain.service.AvaliacaoService;
610 blopes 29
import br.com.ec.domain.service.ParcelaService;
30
import br.com.ec.domain.service.ValeTransporteService;
732 blopes 31
import br.com.ec.domain.service.VigenciaService;
610 blopes 32
import br.com.ec.web.exception.VerificadorLancamentoException;
33
import br.com.ec.web.exception.VerificadorLancamentoException.CommandBean;
34
import br.com.ec.web.generic.AbstractBean;
35
import br.com.ec.web.message.LancadorMensagem;
36
import br.com.ec.web.util.TipoOperacao;
37
 
38
@Named
39
@Scope("view")
40
public class ValeTransporteBean extends AbstractBean<Avaliacao> implements Serializable {
41
 
42
        private static final long serialVersionUID = 1L;
43
 
44
        private ValeTransporteDTO valeTransporteDTO;
732 blopes 45
        private VigenciaDTO vigenciaSelecionada;
610 blopes 46
 
732 blopes 47
        private ValeTransporteService valeTransporteService;
48
 
49
        private VigenciaService vigenciaService;
50
        private AvaliacaoService avaliacaoService;
51
 
610 blopes 52
        private UploadedFile arquivoParaImportacao;
53
        private Date dataPagamento = new Date();
54
 
55
        private ParcelaService parcelaService;
56
 
57
        private AvaliacaoConsultaPorDemanda lazy;
58
        private ParametrosConsulta<Avaliacao> parametrosConsultaAvaliacao;
59
 
60
        @Inject
732 blopes 61
        public ValeTransporteBean(AvaliacaoConsultaPorDemanda lazy, ValeTransporteService valeTransporteService,
62
                        VigenciaService vigenciaService, AvaliacaoService avaliacaoService, ParcelaService parcelaService) {
610 blopes 63
                this.lazy = lazy;
64
                this.valeTransporteService = valeTransporteService;
732 blopes 65
                this.vigenciaService= vigenciaService;
66
                this.avaliacaoService = avaliacaoService;
610 blopes 67
                this.parcelaService = parcelaService;
68
        }
69
 
70
        @Override
71
        public void preCarregamento() {
72
                parametrosConsultaAvaliacao = new ParametrosConsulta<Avaliacao>();
73
                parametrosConsultaAvaliacao.setEntidade(new Avaliacao());
74
                prepararConsultaDemanda();
75
                limparEntidade();
76
        }
732 blopes 77
 
78
        @PostConstruct
79
        private void posCarregamento() {
80
                if (VerificadorUtil.naoEstaNulo(getParametro("vigencia"))) {
81
                        setVigenciaSelecionada(vigenciaService.consultarVigencia(new Long(getParametro("vigencia").toString())));
82
                        if (VerificadorUtil.naoEstaNulo(getVigenciaSelecionada())) {
83
                                detalharValeTransporte();
84
                        }
85
                }
86
        }
610 blopes 87
 
732 blopes 88
        private void detalharValeTransporte() {
89
                AvaliacaoDTO avaliacaoDTO = avaliacaoService.consultarAvaliacao(getVigenciaSelecionada().getSequencial());
90
                if (VerificadorUtil.naoEstaNulo(avaliacaoDTO)) {
91
                        setValeTransporteDTO(valeTransporteService.detalharValeTransporte(avaliacaoDTO));
92
                }
93
        }
94
 
610 blopes 95
        @Override
96
        public void limparEntidade() {
97
                setEntidade(new Avaliacao());
98
        }
99
 
100
        @Override
101
        public GenericService<Avaliacao> getService() {
102
                return valeTransporteService;
103
        }
104
 
105
        @Override
106
        public Avaliacao getEntidade() {
107
                return entidade;
108
        }
109
 
110
        @Override
111
        public void preConsultar() {
112
                setTipoOperacao(TipoOperacao.CONSULTAR);
113
        }
114
 
115
        @Override
116
        public void preAlterar(Avaliacao avaliacao) {
117
                super.preAlterar(avaliacao);
118
                setValeTransporteDTO(valeTransporteService.detalharValeTransporte(new AvaliacaoDTO(avaliacao.getSequencial(), avaliacao.getSequencialDaVigencia(), avaliacao.getDescricaoDaVigencia())));
119
        }
120
 
121
        @Override
122
        public Avaliacao getId() {
123
                return getEntidade();
124
        }
125
 
126
        public AvaliacaoConsultaPorDemanda getLazy() {
127
                return lazy;
128
        }
129
        public void setLazy(AvaliacaoConsultaPorDemanda lazy) {
130
                this.lazy = lazy;
131
        }
132
        public void prepararConsultaDemanda() {
133
                lazy.setarParametrosConsulta(getParametrosConsultaAvaliacao());
134
        }
135
 
136
        public ParametrosConsulta<Avaliacao> getParametrosConsultaAvaliacao() {
137
                return parametrosConsultaAvaliacao;
138
        }
139
        public void setParametrosConsultaAvaliacao(ParametrosConsulta<Avaliacao> parametrosConsultaAvaliacao) {
140
                this.parametrosConsultaAvaliacao = parametrosConsultaAvaliacao;
141
        }
142
 
143
        public ValeTransporteDTO getValeTransporteDTO() {
144
                return valeTransporteDTO;
145
        }
146
        public void setValeTransporteDTO(ValeTransporteDTO valeTransporteDTO) {
147
                this.valeTransporteDTO = valeTransporteDTO;
148
        }
149
 
732 blopes 150
        public VigenciaDTO getVigenciaSelecionada() {
151
                return vigenciaSelecionada;
152
        }
153
        public void setVigenciaSelecionada(VigenciaDTO vigenciaSelecionada) {
154
                this.vigenciaSelecionada = vigenciaSelecionada;
155
        }
156
 
610 blopes 157
        public UploadedFile getArquivoParaImportacao() {
158
                return arquivoParaImportacao;
159
        }
160
        public void setArquivoParaImportacao(UploadedFile arquivoParaImportacao) {
161
                this.arquivoParaImportacao = arquivoParaImportacao;
162
        }
163
 
164
        public Date getDataPagamento() {
165
                return dataPagamento;
166
        }
167
        public void setDataPagamento(Date dataPagamento) {
168
                this.dataPagamento = dataPagamento;
169
        }
170
 
171
        public List<ValeTransporteFuncionarioExtraidoDTO> funcionariosExtraidosForaDaAvaliacao() {
732 blopes 172
                Double valorTotalForaDaAvaliacao = new Double(0.0);
610 blopes 173
                List<ValeTransporteFuncionarioExtraidoDTO> extraidosForaDaAvaliacao = new ArrayList<ValeTransporteFuncionarioExtraidoDTO>();
174
                if (VerificadorUtil.naoEstaNuloOuVazio(getValeTransporteDTO().getFuncionariosExtraidos())) {
175
                        for (ValeTransporteFuncionarioExtraidoDTO extraido : getValeTransporteDTO().getFuncionariosExtraidos()) {
176
                                if (!extraido.getAdicionado()) {
732 blopes 177
                                        valorTotalForaDaAvaliacao += extraido.getValorVencimentos();
610 blopes 178
                                        extraidosForaDaAvaliacao.add(extraido);
179
                                }
180
                        }
181
                }
182
                return extraidosForaDaAvaliacao;
183
        }
184
 
732 blopes 185
        public Double valorTotalImportadoSemAusentes() {
186
                Double valorTotalForaDaAvaliacao = new Double(0.0);
187
                List<ValeTransporteFuncionarioExtraidoDTO> extraidosForaDaAvaliacao = new ArrayList<ValeTransporteFuncionarioExtraidoDTO>();
188
                if (VerificadorUtil.naoEstaNuloOuVazio(getValeTransporteDTO().getFuncionariosExtraidos())) {
189
                        for (ValeTransporteFuncionarioExtraidoDTO extraido : getValeTransporteDTO().getFuncionariosExtraidos()) {
190
                                if (!extraido.getAdicionado()) {
191
                                        valorTotalForaDaAvaliacao += extraido.getValorVencimentos();
192
                                        extraidosForaDaAvaliacao.add(extraido);
193
                                }
194
                        }
195
                        return getValeTransporteDTO().getValorTotalImportado() - valorTotalForaDaAvaliacao;
196
                }
197
                return valorTotalForaDaAvaliacao;
198
        }
199
 
610 blopes 200
        /**************************************************/
201
 
732 blopes 202
        public void redirecionarGestaoMensal() {
610 blopes 203
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
204
                        public void execute() {
732 blopes 205
                                try {
206
                                        LancadorMensagem.redirecionarTela("/sistema/gestao_mensal/gestao_mensal.xhtml");
207
                                } catch (IOException e) {
208
                                        e.printStackTrace();
209
                                }
610 blopes 210
                        }
211
                });
212
        }
213
 
732 blopes 214
        public void uploadArquivoFlash() {
215
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
610 blopes 216
                        public void execute() {
732 blopes 217
                                setValeTransporteDTO(valeTransporteService.importarValeTransporte(getArquivoParaImportacao().getContent(), getValeTransporteDTO()));
218
                                LancadorMensagem.lancarSucesso("ARQUIVO FLASH IMPORTADO COM SUCESSO!");
610 blopes 219
                        }
220
                });
732 blopes 221
        }
610 blopes 222
 
223
        public void atualizarValoresImportados() {
224
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
225
                        public void execute() {
226
                                for (ValeTransporteFuncionarioDTO valeTransporteFuncionario : getValeTransporteDTO().getFuncionarios()) {
227
                                        if (VerificadorUtil.naoEstaNulo(valeTransporteFuncionario.getValorValeTransporteImportado()) &&
228
                                                        !VerificadorUtil.isListaNulaOuVazia(valeTransporteFuncionario.getParcelas())) {
229
                                                valeTransporteFuncionario.getParcelas().get(0).setValor(valeTransporteFuncionario.getValorValeTransporteImportado());
230
                                                valeTransporteService.atualizarValorParcela(valeTransporteFuncionario.getParcelas().get(0));
231
                                        }
232
                                }
233
                                LancadorMensagem.lancarSucesso("VALORES ATUALIZADOS COM SUCESSO");
234
                        }
235
                });
236
        }
237
 
732 blopes 238
        public void atualizarCentrosDeCustos() {
610 blopes 239
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
240
                        public void execute() {
241
                                for (ValeTransporteFuncionarioDTO valeTransporteFuncionario : getValeTransporteDTO().getFuncionarios()) {
242
                                        if (!VerificadorUtil.isListaNulaOuVazia(valeTransporteFuncionario.getParcelas())) {
732 blopes 243
                                                if (VerificadorUtil.naoEstaNulo(valeTransporteFuncionario.getParcelas().get(0))) {
244
                                                        ParcelaDTO parcela = valeTransporteFuncionario.getParcelas().get(0);
245
                                                        Long sequencialConta = parcela.getContaDTO().getSequencial();
246
                                                        valeTransporteService.atualizarCentroDeCustos(sequencialConta, valeTransporteFuncionario.getAvaliacaoFuncionarioDTO().getSequencialDaLoja());
646 blopes 247
                                                }
610 blopes 248
                                        }
249
                                }
732 blopes 250
                                detalharValeTransporte();
610 blopes 251
                                setArquivoParaImportacao(null);
732 blopes 252
                                LancadorMensagem.lancarSucesso("CENTROS DE CUSTOS ATUALIZADOS COM SUCESSO");
253
                        }
254
                });
255
        }
256
 
257
        public void efetuarPagamentos() {
258
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
259
                        public void execute() {
260
                                for (ValeTransporteFuncionarioDTO valeTransporteFuncionario : getValeTransporteDTO().getFuncionarios()) {
261
                                        if (!VerificadorUtil.isListaNulaOuVazia(valeTransporteFuncionario.getParcelas())) {
262
                                                parcelaService.efetuarPagamentoRecebimento(valeTransporteFuncionario.getParcelas().get(0), getDataPagamento());
263
                                                vigenciaService.alterarSituacaoFolha(getVigenciaSelecionada().getSequencial(), TipoSituacoesVigencia.EM_ANDAMENTO_A.getValor());
264
                                        }
265
                                }
266
                                detalharValeTransporte();
267
                                setArquivoParaImportacao(null);
610 blopes 268
                                LancadorMensagem.lancarSucesso("PAGAMENTOS EFETUADOS COM SUCESSO");
269
                        }
270
                });
271
        }
272
 
732 blopes 273
        public void finalizarValeTransporte() {
274
                new VerificadorLancamentoException().tratarIhRelancarExcecaoSemLimparEntidade(new CommandBean() {
275
                        public void execute() {
276
                                vigenciaService.alterarSituacaoValeTransporte(getVigenciaSelecionada().getSequencial(), TipoSituacoesVigencia.FINALIZADO_F.getValor());
277
                                setArquivoParaImportacao(null);
278
                                redirecionarGestaoMensal();
279
                                LancadorMensagem.lancarSucesso("VALE TRANSPORTE FINALIZADA COM SUCESSO");
280
                        }
281
                });
282
        }
283
 
610 blopes 284
}