View Javadoc

1   /*
2    * Created on 15/02/2005
3    */
4   package ecar.dao;
5   
6   import java.util.ArrayList;
7   import java.util.Calendar;
8   import java.util.Date;
9   import java.util.Iterator;
10  import java.util.List;
11  import java.util.Set;
12  
13  import javax.servlet.http.HttpServletRequest;
14  
15  import comum.database.Dao;
16  import comum.util.Data;
17  import comum.util.FileUpload;
18  import comum.util.Pagina;
19  import comum.util.Util;
20  
21  import ecar.bean.AcessoRelatorio;
22  import ecar.exception.ECARException;
23  import ecar.pojo.AcompRefItemLimitesArli;
24  import ecar.pojo.AcompReferenciaAref;
25  import ecar.pojo.AcompReferenciaItemAri;
26  import ecar.pojo.AcompRelatorioArel;
27  import ecar.pojo.Cor;
28  import ecar.pojo.ItemEstUsutpfuacIettutfa;
29  import ecar.pojo.ItemEstruturaIett;
30  import ecar.pojo.SituacaoSit;
31  import ecar.pojo.TipoAcompFuncAcompTafc;
32  import ecar.pojo.TipoFuncAcompTpfa;
33  import ecar.pojo.UsuarioUsu;
34  import ecar.util.Dominios;
35  
36  /**
37   * @author evandro
38   * @author felipe
39   */
40  public class AcompRelatorioDao extends Dao {
41  
42    public static int OPERACAO_PERMITIDA = 1;
43    public static int OPERACAO_NEGADA_USUARIO_SEM_PERMISSAO = 2;
44    public static int OPERACAO_NEGADA_ACOMPANHAMENTO_REFERENCIA_LIBERADO = 3;
45    public static int OPERACAO_NEGADA_POSICAO_LIBERADA = 4;
46    public static int OPERACAO_NEGADA_FUNCAO_SUPERIOR_LIBERADA = 5;
47    public static int OPERACAO_NEGADA_POSICAO_EM_EDICAO = 6;
48    public static int OPERACAO_NEGADA_DATA_ULTRAPASSADA = 7;
49  
50    public AcompRelatorioDao(HttpServletRequest request) {
51      super();
52      this.request = request;
53    }
54  
55    /**
56     * Verifica se a data limite para emissão de um parecer venceu ( ou seja, é
57     * maior que a data atual)
58     * @param funcao
59     * @param acompReferenciaItem
60     * @return
61     * @throws ECARException
62     */
63    public boolean isDataLimiteParecerVencida(TipoFuncAcompTpfa funcao, AcompReferenciaItemAri acompReferenciaItem) throws ECARException {
64      // Date dataLimite = new
65      // AcompReferenciaItemDao(request).getAcompRefItemLimitesByAcompReferenciaItemTipoFuncAcomp(funcao,
66      // acompReferenciaItem).getDataLimiteArli();
67  
68      AcompRefItemLimitesArli arli = new AcompReferenciaItemDao(request).getAcompRefItemLimitesByAcompReferenciaItemTipoFuncAcomp(funcao, acompReferenciaItem);
69  
70      if (arli != null && arli.getDataLimiteArli() != null) {
71        Date dataLimite = arli.getDataLimiteArli();
72  
73        // alterado devido ao BUG 3670
74        Calendar calendarDataAtual = Calendar.getInstance();
75  
76        calendarDataAtual.clear(Calendar.HOUR);
77        calendarDataAtual.clear(Calendar.HOUR_OF_DAY);
78        calendarDataAtual.clear(Calendar.MINUTE);
79        calendarDataAtual.clear(Calendar.SECOND);
80        calendarDataAtual.clear(Calendar.MILLISECOND);
81        calendarDataAtual.clear(Calendar.AM_PM);
82  
83        Calendar calendarDataLimite = Calendar.getInstance();
84        calendarDataLimite.setTime(dataLimite);
85  
86        calendarDataLimite.clear(Calendar.HOUR);
87        calendarDataLimite.clear(Calendar.HOUR_OF_DAY);
88        calendarDataLimite.clear(Calendar.MINUTE);
89        calendarDataLimite.clear(Calendar.SECOND);
90        calendarDataLimite.clear(Calendar.MILLISECOND);
91        calendarDataLimite.clear(Calendar.AM_PM);
92  
93        /* PODE SER EDITADO ATÉ A DATA LIMITE */
94        if (calendarDataAtual.compareTo(calendarDataLimite) > 0) {
95          return true;
96        }
97      }
98      return false;
99  
100     /*
101      * Código anterior: if(Data.getDataAtual().after(dataLimite)) return true;
102      * return false;
103      */
104   }
105 
106   /**
107    * Método que verifica se um Relatório de Acompanhamento (Posição da Função de
108    * Acompanhamento) pode ser acessado.
109    * @param acompRelatorio Objeto AcompRelatorioRel
110    * @return Situação utilizando variáveis estáticas declardas nesta classe
111    * @author felipe
112    */
113   public int podeAcessarRelatorio(UsuarioUsu usuario, TipoFuncAcompTpfa funcao, AcompRelatorioArel acompRelatorio) throws ECARException {
114     ItemEstUsutpfuacDao itemEstUsutpfuacDao = new ItemEstUsutpfuacDao(request);
115     List usuariosPermitidos = itemEstUsutpfuacDao.getUsuariosAcompanhamento(acompRelatorio.getAcompReferenciaItemAri().getItemEstruturaIett());
116 
117     if (!usuariosPermitidos.contains(usuario)) {
118       return OPERACAO_NEGADA_USUARIO_SEM_PERMISSAO;
119     }
120     else {
121       if (acompRelatorio != null && "S".equals(acompRelatorio.getIndLiberadoArel())) {
122         return OPERACAO_PERMITIDA;
123       }
124       else {
125         try {
126 
127           itemEstUsutpfuacDao.buscar(acompRelatorio.getAcompReferenciaItemAri().getItemEstruturaIett().getCodIett(), funcao.getCodTpfa());
128           return OPERACAO_PERMITIDA;
129         } catch (ECARException e) {
130           this.logger.error(e);
131           return OPERACAO_NEGADA_POSICAO_EM_EDICAO;
132         }
133       }
134     }
135   }
136 
137   /**
138    * Método que verifica se um Relatório de Acompanhamento (Posição da Função de
139    * Acompanhamento) pode ser gravado. As condições para a gravação são as
140    * sequintes: (1) Se a Posição não foi liberada, pode ser gravada (2) Se o
141    * Acompanhamento de Referência a qual pertence o Relatório de Acompanhamento
142    * possuir status LIBERADO, Relatório NÃO PODE ser gravado
143    * @param acompRelatorio Objeto AcompRelatorioRel
144    * @return Situação utilizando variáveis estáticas declardas nesta classe
145    * @author felipe
146    */
147   public int podeGravarRelatorio(UsuarioUsu usuario, TipoFuncAcompTpfa funcao, AcompReferenciaItemAri acompReferenciaItem, AcompRelatorioArel acompRelatorio) {
148     try {
149 
150       boolean usuarioSemPermissao = true;
151       ItemEstUsutpfuacIettutfa itemEstUsutpfuacIettutfa = new ItemEstUsutpfuacDao(request).buscar(acompReferenciaItem.getItemEstruturaIett().getCodIett(), funcao.getCodTpfa());
152 
153       if (itemEstUsutpfuacIettutfa != null) {
154         if (itemEstUsutpfuacIettutfa.getUsuarioUsu() != null && itemEstUsutpfuacIettutfa.getUsuarioUsu().equals(usuario)) {
155           usuarioSemPermissao = false;
156         }
157         else if (itemEstUsutpfuacIettutfa.getSisAtributoSatb() != null) {
158           Iterator itUsuarios = new UsuarioDao().getUsuariosBySisAtributoSatb(itemEstUsutpfuacIettutfa.getSisAtributoSatb()).iterator();
159           while (itUsuarios.hasNext()) {
160             UsuarioUsu usu = (UsuarioUsu) itUsuarios.next();
161             if (usu.equals(usuario)) {
162               usuarioSemPermissao = false;
163             }
164           }
165         }
166       }
167       if (usuarioSemPermissao) {
168         return OPERACAO_NEGADA_USUARIO_SEM_PERMISSAO;
169       }
170 
171     } catch (ECARException e) {
172       return OPERACAO_NEGADA_USUARIO_SEM_PERMISSAO;
173     }
174     if (acompReferenciaItem.getStatusRelatorioSrl() != null && acompReferenciaItem.getStatusRelatorioSrl().getCodSrl().intValue() == AcompReferenciaItemDao.STATUS_LIBERADO) {
175       /* se o acompanhamento do item já foi liberado não pode gravar */
176       return OPERACAO_NEGADA_ACOMPANHAMENTO_REFERENCIA_LIBERADO;
177     }
178     if ("S".equals(acompRelatorio.getIndLiberadoArel())) {
179       return OPERACAO_NEGADA_POSICAO_LIBERADA;
180     }
181     else {
182       return OPERACAO_PERMITIDA;
183     }
184   }
185 
186   /**
187    * Método que verifica se um Relatório de Acompanhamento (Posição da Função de
188    * Acompanhamento) pode ser liberado. A condição para a liberação é: (1) Se o
189    * Acompanhamento de Referência a qual pertence o Relatório de Acompanhamento
190    * possuir status LIBERADO, Relatório NÃO PODE ser liberado
191    * @param acompRelatorio Objeto AcompRelatorioRel
192    * @return Situação utilizando variáveis estáticas declardas nesta classe
193    * @author felipe
194    */
195   public int podeLiberarRelatorio(UsuarioUsu usuario, TipoFuncAcompTpfa funcao, AcompReferenciaItemAri acompReferenciaItem, AcompRelatorioArel acompRelatorio) throws ECARException {
196     try {
197 
198       boolean usuarioSemPermissao = true;
199       ItemEstUsutpfuacIettutfa itemEstUsutpfuacIettutfa = new ItemEstUsutpfuacDao(request).buscar(acompReferenciaItem.getItemEstruturaIett().getCodIett(), funcao.getCodTpfa());
200 
201       if (itemEstUsutpfuacIettutfa != null) {
202         if (itemEstUsutpfuacIettutfa.getUsuarioUsu() != null && itemEstUsutpfuacIettutfa.getUsuarioUsu().equals(usuario)) {
203           usuarioSemPermissao = false;
204         }
205         else if (itemEstUsutpfuacIettutfa.getSisAtributoSatb() != null) {
206           Iterator itUsuarios = new UsuarioDao().getUsuariosBySisAtributoSatb(itemEstUsutpfuacIettutfa.getSisAtributoSatb()).iterator();
207           while (itUsuarios.hasNext()) {
208             UsuarioUsu usu = (UsuarioUsu) itUsuarios.next();
209             if (usu.equals(usuario)) {
210               usuarioSemPermissao = false;
211             }
212           }
213         }
214       }
215       if (usuarioSemPermissao) {
216         return OPERACAO_NEGADA_USUARIO_SEM_PERMISSAO;
217       }
218 
219     } catch (ECARException e) {
220       return OPERACAO_NEGADA_USUARIO_SEM_PERMISSAO;
221     }
222     if (acompReferenciaItem.getStatusRelatorioSrl() != null && acompReferenciaItem.getStatusRelatorioSrl().getCodSrl().intValue() == AcompReferenciaItemDao.STATUS_LIBERADO) {
223       // se o acompanhamento do item já foi liberado não pode liberar
224       return OPERACAO_NEGADA_ACOMPANHAMENTO_REFERENCIA_LIBERADO;
225     }
226     /* item já possui algum status. deve validar para liberar */
227     if (acompRelatorio.getIndLiberadoArel() != null && "S".equals(acompRelatorio.getIndLiberadoArel())) {
228       /* status S (já está liberado) */
229       return OPERACAO_NEGADA_POSICAO_LIBERADA;
230     }
231     else {
232       return OPERACAO_PERMITIDA;
233     }
234   }
235 
236   /**
237    * Método que verifica se um Relatório de Acompanhamento (Posição da Função de
238    * Acompanhamento) pode ser recuperado. As condições para a recuperação são as
239    * sequintes: (1) Se o Acompanhamento de Referência a qual pertence o
240    * Relatório de Acompanhamento possuir status LIBERADO, Relatório NÃO PODE ser
241    * recuperado senão (2) Se o parecer do relatório for S verifica a Posição
242    * gravada pela função pai: 3.1 Se não existir registro gravado pela função
243    * pai, ou se a função pai não exisitir, filho PODE RECUPERAR posição 3.2 Se
244    * existir função pai: se o pai tiver liberado posição, filho NÃO PODE
245    * recuperar posição. Se o pai não tiver liberado posição filho PODE RECUPERAR
246    * posição
247    * @param acompRelatorio Objeto AcompRelatorioRel
248    * @return Situação utilizando variáveis estáticas declardas nesta classe
249    * @author felipe
250    */
251   public int podeRecuperarRelatorio(UsuarioUsu usuario, TipoFuncAcompTpfa funcao, AcompReferenciaItemAri acompReferenciaItem, AcompRelatorioArel acompRelatorio) throws ECARException {
252     try {
253 
254       boolean usuarioSemPermissao = true;
255       ItemEstUsutpfuacIettutfa itemEstUsutpfuacIettutfa = new ItemEstUsutpfuacDao(request).buscar(acompReferenciaItem.getItemEstruturaIett().getCodIett(), funcao.getCodTpfa());
256 
257       if (itemEstUsutpfuacIettutfa != null) {
258         if (itemEstUsutpfuacIettutfa.getUsuarioUsu() != null && itemEstUsutpfuacIettutfa.getUsuarioUsu().equals(usuario)) {
259           usuarioSemPermissao = false;
260         }
261         else if (itemEstUsutpfuacIettutfa.getSisAtributoSatb() != null) {
262           Iterator itUsuarios = new UsuarioDao().getUsuariosBySisAtributoSatb(itemEstUsutpfuacIettutfa.getSisAtributoSatb()).iterator();
263           while (itUsuarios.hasNext()) {
264             UsuarioUsu usu = (UsuarioUsu) itUsuarios.next();
265             if (usu.equals(usuario)) {
266               usuarioSemPermissao = false;
267             }
268           }
269         }
270       }
271       if (usuarioSemPermissao) {
272         return OPERACAO_NEGADA_USUARIO_SEM_PERMISSAO;
273       }
274 
275     } catch (ECARException e) {
276       return OPERACAO_NEGADA_USUARIO_SEM_PERMISSAO;
277     }
278     if (acompReferenciaItem.getStatusRelatorioSrl() != null && acompReferenciaItem.getStatusRelatorioSrl().getCodSrl().intValue() == AcompReferenciaItemDao.STATUS_LIBERADO) {
279       /* se o acompanhamento do item já foi liberado não pode recuperar */
280       return OPERACAO_NEGADA_ACOMPANHAMENTO_REFERENCIA_LIBERADO;
281     }
282     /* item já possui algum status. deve validar para recuperar */
283     if (acompRelatorio.getIndLiberadoArel() != null && "S".equals(acompRelatorio.getIndLiberadoArel())) {
284       /* procura o acompanhamento do antecedente */
285       AcompRelatorioArel acompPai = acompRelatorio;
286       /* antecedente não foi liberado, pode recuperar */
287       int intRetorno = OPERACAO_PERMITIDA;
288       do {
289         TipoFuncAcompTpfa tipoFuncao = acompPai.getTipoFuncAcompTpfa();
290         if (tipoFuncao.getTipoFuncAcompTpfa() == null) {
291           /* função não possui pai, pode recuperar a qualquer hora */
292           break;
293         }
294         acompPai = getAcompRelatorio(tipoFuncao.getTipoFuncAcompTpfa(), acompPai.getAcompReferenciaItemAri());
295         if (acompPai != null)
296           if (acompPai.getIndLiberadoArel() != null && "S".equals(acompPai.getIndLiberadoArel())) {
297             /* antecedente já foi liberado, não pode recuperar */
298             intRetorno = OPERACAO_NEGADA_FUNCAO_SUPERIOR_LIBERADA;
299             break;
300           }
301       } while (acompPai != null);
302       return intRetorno;
303     }
304     else {
305       /* status nulo ou S não pode recuperar (já está em edição) */
306       return OPERACAO_NEGADA_POSICAO_EM_EDICAO;
307     }
308   }
309 
310   /**
311    * Cria um objeto AcompRelatorioArel a partir de parâmetros passados por
312    * request
313    * @param acompRelatorio
314    * @param request
315    * @throws ECARException
316    */
317   public void setAcompRelatorioArel(AcompRelatorioArel acompRelatorio, HttpServletRequest request, List campos) throws ECARException {
318 
319     boolean isFormUpload = FileUpload.isMultipartContent(request);
320     String cor = null;
321     String situacaoSit = null;
322     String codTpfa = null;
323     String codAri = null;
324     String codUsuario = null;
325     String descricaoArel = null;
326     String complementoArel = null;
327     String indLiberado = null;
328 
329     try {
330       if (isFormUpload) {
331         cor = FileUpload.verificaValorCampo(campos, "cor");
332         situacaoSit = FileUpload.verificaValorCampo(campos, "situacaoSit");
333         codTpfa = FileUpload.verificaValorCampo(campos, "codTpfa");
334         codAri = FileUpload.verificaValorCampo(campos, "codAri");
335         codUsuario = FileUpload.verificaValorCampo(campos, "codUsuario");
336         ;
337         descricaoArel = FileUpload.verificaValorCampo(campos, "descricaoArel");
338         ;
339         complementoArel = FileUpload.verificaValorCampo(campos, "complementoArel");
340         indLiberado = FileUpload.verificaValorCampo(campos, "indLiberado");
341       }
342       else {
343         cor = Pagina.getParamStr(request, "cor");
344         situacaoSit = Pagina.getParamStr(request, "situacaoSit");
345         codTpfa = Pagina.getParamStr(request, "codTpfa");
346         codAri = Pagina.getParamStr(request, "codAri");
347         codUsuario = Pagina.getParamStr(request, "codUsuario");
348         ;
349         descricaoArel = Pagina.getParamStr(request, "descricaoArel");
350         ;
351         complementoArel = Pagina.getParamStr(request, "complementoArel");
352         indLiberado = Pagina.getParamStr(request, "indLiberado");
353       }
354     } catch (Exception e) {
355       // TODO: handle exception
356     }
357 
358     if (!"".equals(cor)) {
359       acompRelatorio.setCor((Cor) this.buscar(Cor.class, Long.valueOf(cor)));
360     }
361 
362     if (!"".equals(situacaoSit)) {
363       acompRelatorio.setSituacaoSit((SituacaoSit) this.buscar(SituacaoSit.class, Long.valueOf(situacaoSit)));
364     }
365     AcompReferenciaItemAri acompReferenciaItem = (AcompReferenciaItemAri) this.buscar(AcompReferenciaItemAri.class, Long.valueOf(codAri));
366 
367     TipoFuncAcompTpfa funcaoAcomp = (TipoFuncAcompTpfa) this.buscar(TipoFuncAcompTpfa.class, Long.valueOf(codTpfa));
368 
369     UsuarioUsu usuario = (UsuarioUsu) this.buscar(UsuarioUsu.class, Long.valueOf(codUsuario));
370     acompRelatorio.setUsuarioUsuUltimaManutencao(usuario);
371 
372     acompRelatorio.setTipoFuncAcompTpfa(funcaoAcomp);
373     acompRelatorio.setAcompReferenciaItemAri(acompReferenciaItem);
374     acompRelatorio.setDescricaoArel(Util.normalizaQuebraDeLinha(descricaoArel));
375     acompRelatorio.setComplementoArel(Util.normalizaQuebraDeLinha(complementoArel));
376     acompRelatorio.setIndLiberadoArel(indLiberado);
377   }
378 
379   /**
380    * Grava uma posição para um acompanhamento e volta a mensagem a ser exibida
381    * para o usuário.
382    * @param acompRelatorio
383    * @param request
384    * @return
385    * @throws ECARException
386    */
387   public String salvar(AcompRelatorioArel acompRelatorio, HttpServletRequest request, List campos) throws ECARException {
388     setAcompRelatorioArel(acompRelatorio, request, campos);
389     acompRelatorio.setDataInclusaoArel(Data.getDataAtual());
390     super.salvar(acompRelatorio);
391     if ("S".equals(acompRelatorio.getIndLiberadoArel()))
392       return "acompanhamento.acompRelatorio.liberacao.sucesso";
393     else
394       return "acompanhamento.acompRelatorio.inclusao.sucesso";
395   }
396 
397   /**
398    * Altera uma posição para um acompanhamento e volta a mensagem a ser exibida
399    * para o usuário
400    * @param acompRelatorio
401    * @param request
402    * @return
403    * @throws ECARException
404    */
405   public String alterar(AcompRelatorioArel acompRelatorio, HttpServletRequest request, List campos) throws ECARException {
406     AcompRelatorioArel acompAtual = (AcompRelatorioArel) this.buscar(AcompRelatorioArel.class, acompRelatorio.getCodArel());
407     String indLiberadoAcompAtual = acompAtual.getIndLiberadoArel();
408     setAcompRelatorioArel(acompRelatorio, request, campos);
409     acompRelatorio.setDataUltManutArel(Data.getDataAtual());
410     super.alterar(acompRelatorio);
411     if ("S".equals(acompRelatorio.getIndLiberadoArel()))
412       return "acompanhamento.acompRelatorio.liberacao.sucesso";
413     else {
414       if ("N".equals(indLiberadoAcompAtual) && "N".equals(acompRelatorio.getIndLiberadoArel())) {
415         return "acompanhamento.acompRelatorio.alteracao.sucesso";
416       }
417       else {
418         if ("S".equals(indLiberadoAcompAtual) && "N".equals(acompRelatorio.getIndLiberadoArel()))
419           return "acompanhamento.acompRelatorio.recuperacao.sucesso";
420         else
421           return "acompanhamento.acompRelatorio.alteracao.sucesso";
422       }
423 
424     }
425   }
426 
427   /**
428    * Devolve um acompRelatorioArel, a partir dos objetos passados
429    * @param itemEstrutura
430    * @param funcao
431    * @return String nomeUsu
432    * @throws ECARException
433    */
434   public AcompRelatorioArel getAcompRelatorio(TipoFuncAcompTpfa tipoFuncao, AcompReferenciaItemAri acompRefItem) throws ECARException {
435 
436     AcompRelatorioArel acompRelatorio = new AcompRelatorioArel();
437 
438     acompRelatorio.setAcompReferenciaItemAri(acompRefItem);
439     acompRelatorio.setTipoFuncAcompTpfa(tipoFuncao);
440 
441     /* buscar em AcompRelatorio a partir de ItemEstUsu e de AcompReferenciaItem */
442     List lista = pesquisar(acompRelatorio, new String[] { "codArel", "asc" });
443 
444     for (Iterator it = lista.iterator(); it.hasNext();) {
445       acompRelatorio = (AcompRelatorioArel) it.next();
446       return acompRelatorio;
447     }
448 
449     return null;
450   }
451 
452   public AcompRelatorioArel criaNovoAcompRelatorio(AcompReferenciaItemAri acompReferenciaItem, UsuarioUsu usuario, TipoFuncAcompTpfa funcAcomp) throws ECARException {
453     AcompRelatorioArel acompRelatorio = new AcompRelatorioArel();
454     acompRelatorio.setAcompReferenciaItemAri(acompReferenciaItem);
455     acompRelatorio.setDataInclusaoArel(Data.getDataAtual());
456     acompRelatorio.setTipoFuncAcompTpfa(funcAcomp);
457     acompRelatorio.setUsuarioUsu(usuario);
458     return acompRelatorio;
459   }
460 
461   /**
462    * Obter os AcompRelatorioArel de uma lista de aris
463    * @param listAris
464    * @return List
465    * @throws ECARException
466    */
467   public List getArelsOfAris(List listAris) throws ECARException {
468     List retorno = new ArrayList();
469 
470     for (Iterator it = listAris.iterator(); it.hasNext();) {
471       AcompReferenciaItemAri ari = (AcompReferenciaItemAri) it.next();
472       if (ari.getAcompRelatorioArels() != null) {
473         retorno.addAll(ari.getAcompRelatorioArels());
474       }
475     }
476     return retorno;
477   }
478 
479   /**
480    * Obtêm uma lista de permissões de acesso a uma lista de relatório de
481    * acompanhamento de um usuário
482    * @param usuario UsuarioUsu
483    * @param listTipoFuncAcompTpfa List de TipoFuncAcompTpfa
484    * @param listAcompRelatorioArel List de AcompRelatorioArel
485    * @return List de AcessoRelatorio
486    */
487   public List getListaAcessoRelatorio(UsuarioUsu usuario, List listTipoFuncAcompTpfa, List listAcompRelatorioArel, List listTipoAcompFuncAcomp) throws ECARException {
488     List retorno = new ArrayList();
489     ItemEstUsutpfuacDao itemEstUsutpfuacDao = new ItemEstUsutpfuacDao(request);
490 
491     for (Iterator itArel = listAcompRelatorioArel.iterator(); itArel.hasNext();) {
492       AcompRelatorioArel arel = (AcompRelatorioArel) itArel.next();
493 
494       List usuariosPermitidos = itemEstUsutpfuacDao.getUsuariosAcompanhamento(arel.getAcompReferenciaItemAri().getItemEstruturaIett());
495 
496       for (Iterator itTpfa = listTipoFuncAcompTpfa.iterator(); itTpfa.hasNext();) {
497         TipoFuncAcompTpfa tpfa = (TipoFuncAcompTpfa) itTpfa.next();
498 
499         AcessoRelatorio acessoRelatorio = new AcessoRelatorio();
500         acessoRelatorio.setArel(arel);
501         acessoRelatorio.setTpfa(tpfa);
502 
503         if (!usuariosPermitidos.contains(usuario)) {
504           acessoRelatorio.setPermissao(OPERACAO_NEGADA_USUARIO_SEM_PERMISSAO);
505         }
506         else {
507           if (arel != null && Dominios.SIM.equals(arel.getIndLiberadoArel())) {
508             acessoRelatorio.setPermissao(OPERACAO_PERMITIDA);
509           }
510           else {
511 
512             TipoAcompFuncAcompTafc tafc = null;
513             for (Iterator it = listTipoAcompFuncAcomp.iterator(); it.hasNext();) {
514               TipoAcompFuncAcompTafc tafcTemp = (TipoAcompFuncAcompTafc) it.next();
515               if (tafcTemp.getTipoFuncAcompTpfa().equals(tpfa)) {
516                 tafc = tafcTemp;
517                 break;
518               }
519             }
520 
521             try {
522               if (tafc != null) {
523                 /*
524                  * Nova regra (mantis 11289): Ao exibir as abas de tipos de
525                  * funções de acompanhamento: Para registro de posição
526                  * OBRIGATÓRIO continua com está atualmente.
527                  */
528                 if (Dominios.OBRIGATORIO.equals(tafc.getIndRegistroPosicaoTafc())) {
529 
530                   boolean usuarioSemPermissao = true;
531                   ItemEstUsutpfuacIettutfa itemEstUsutpfuacIettutfa = new ItemEstUsutpfuacDao(request).buscar(arel.getAcompReferenciaItemAri().getItemEstruturaIett().getCodIett(), tpfa.getCodTpfa());
532 
533                   if (itemEstUsutpfuacIettutfa != null) {
534                     if (itemEstUsutpfuacIettutfa.getUsuarioUsu() != null && itemEstUsutpfuacIettutfa.getUsuarioUsu().equals(usuario)) {
535                       usuarioSemPermissao = false;
536                     }
537                     else if (itemEstUsutpfuacIettutfa.getSisAtributoSatb() != null) {
538                       Iterator itUsuarios = new UsuarioDao().getUsuariosBySisAtributoSatb(itemEstUsutpfuacIettutfa.getSisAtributoSatb()).iterator();
539                       while (itUsuarios.hasNext()) {
540                         UsuarioUsu usu = (UsuarioUsu) itUsuarios.next();
541                         if (usu.equals(usuario)) {
542                           usuarioSemPermissao = false;
543                         }
544                       }
545                     }
546                   }
547                   if (usuarioSemPermissao) {
548                     acessoRelatorio.setPermissao(OPERACAO_NEGADA_POSICAO_EM_EDICAO);
549                   }
550                   else {
551                     acessoRelatorio.setPermissao(OPERACAO_PERMITIDA);
552                   }
553 
554                 }
555                 /*
556                  * Para tipo de função de acompanhamento que seja OPCIONAL o
557                  * registro de posição no tipo de acompanhamento selecionado
558                  * (TipoAcompFuncAcompTafc.indRegistroPosicaoTafc), somente
559                  * apresentar a aba para o usuário que possuir permissão ou que
560                  * o acompanhamento esteja liberado.
561                  */
562                 else if (Dominios.OPCIONAL.equals(tafc.getIndRegistroPosicaoTafc())) {
563                   if (usuariosPermitidos.contains(usuario)) {
564                     acessoRelatorio.setPermissao(OPERACAO_PERMITIDA);
565                   }
566                   else {
567                     acessoRelatorio.setPermissao(OPERACAO_NEGADA_USUARIO_SEM_PERMISSAO);
568                   }
569                 }
570               }
571             } catch (ECARException e) {
572               acessoRelatorio.setPermissao(OPERACAO_NEGADA_POSICAO_EM_EDICAO);
573             }
574           }
575         }
576         retorno.add(acessoRelatorio);
577       }
578     }
579     return retorno;
580   }
581 
582   /**
583    * Verificar se falta registro para informar parecer quando é informado nova
584    * função de acompanhamento no item Mantis: 10715
585    * @param AcompRelatorioArel arel
586    * @param List listItens
587    * @return boolean
588    */
589   public boolean verificarInexistenciaArel(AcompReferenciaAref aref, List listItens) throws ECARException {
590     AcompReferenciaItemDao acompReferenciaItemDao = new AcompReferenciaItemDao(null);
591     ItemEstUsutpfuacDao itemEstUsutpfuacDao = new ItemEstUsutpfuacDao(null);
592 
593     for (Iterator it = listItens.iterator(); it.hasNext();) {
594       ItemEstruturaIett iett = (ItemEstruturaIett) it.next();
595       AcompReferenciaItemAri acompReferenciaItemAlterar = acompReferenciaItemDao.getAcompReferenciaItemByItemEstruturaIett(aref, iett);
596       Set arelsGravados = acompReferenciaItemAlterar.getAcompRelatorioArels();
597 
598       // obtem as funções de acompanhamento do item que emitem posição
599       for (Iterator itFuac = itemEstUsutpfuacDao.getFuacEmitePosicaoOrderByFuncAcomp(iett).iterator(); itFuac.hasNext();) {
600         TipoFuncAcompTpfa funcAcomp = ((ItemEstUsutpfuacIettutfa) itFuac.next()).getTipoFuncAcompTpfa();
601 
602         for (Iterator itTafc = aref.getTipoAcompanhamentoTa().getTipoAcompFuncAcompTafcs().iterator(); itTafc.hasNext();) {
603           TipoAcompFuncAcompTafc tafc = (TipoAcompFuncAcompTafc) itTafc.next();
604           if (tafc.getTipoFuncAcompTpfa().equals(funcAcomp)) {
605             boolean existeArelParaFuncao = false;
606             for (Iterator itArelsGravados = arelsGravados.iterator(); itArelsGravados.hasNext();) {
607               AcompRelatorioArel arel = (AcompRelatorioArel) itArelsGravados.next();
608               if (arel.getTipoFuncAcompTpfa().equals(funcAcomp)) {
609                 existeArelParaFuncao = true;
610               }
611             }
612             if (!existeArelParaFuncao) {
613               return true;
614             }
615           }
616         }
617       }
618     }
619     return false;
620   }
621 
622   /**
623    * Verifica se houve mudança na função de acompanhamento do item do Parecer!
624    * @author luanaoliveira
625    * @since 27/07/2007
626    * @param arel
627    * @return boolean - se houve mudança retorna true.
628    */
629   public boolean verificaMudancaFuncaoAcomp(AcompRelatorioArel arel) {
630 
631     TipoFuncAcompTpfa funcaoArel = arel.getTipoFuncAcompTpfa();
632 
633     Set listaFuncoesItem = arel.getAcompReferenciaItemAri().getItemEstruturaIett().getItemEstUsutpfuacIettutfas();
634 
635     List listaFuncoes = new ArrayList();
636 
637     if (listaFuncoesItem != null) {
638 
639       Iterator it = listaFuncoesItem.iterator();
640 
641       while (it.hasNext()) {
642         ItemEstUsutpfuacIettutfa utfa = (ItemEstUsutpfuacIettutfa) it.next();
643 
644         listaFuncoes.add(utfa.getTipoFuncAcompTpfa());
645       }
646     }
647 
648     return !listaFuncoes.contains(funcaoArel);
649 
650   }
651 
652   /**
653    * Verifica se o usuário é acompanhamento habilitado a emitir Relatório /
654    * Parecer
655    * @param usuario
656    * @param ari
657    * @return
658    */
659   public boolean emiteRelatorio(UsuarioUsu usuario, AcompReferenciaItemAri ari) throws ECARException {
660     AcompReferenciaItemDao ariDao = new AcompReferenciaItemDao(request);
661 
662     List listAcompRef = ariDao.getAcompRelatorioArelOrderByFuncaoAcomp(ari);
663     AcompRelatorioDao arelDao = new AcompRelatorioDao(request);
664 
665     boolean emiterelatorio = false;
666 
667     if (listAcompRef != null)
668       for (Iterator<AcompRelatorioArel> it = listAcompRef.iterator(); it.hasNext();) {
669         AcompRelatorioArel arel = (AcompRelatorioArel) it.next();
670         TipoFuncAcompTpfa tpfa = arel.getTipoFuncAcompTpfa();
671 
672         if (arelDao.podeGravarRelatorio(usuario, tpfa, ari, arel) == AcompRelatorioDao.OPERACAO_PERMITIDA) {
673           emiterelatorio = true;
674           break;
675         }
676 
677         /*
678          * Caso o item na estrutura esteja bloqueado, verificar para quais
679          * funções de acompanhamento ela está liberada, mesmo que bloqueada.
680          */
681         /*
682          * if (emiterelatorio){ //Verificar na tabela do pode bloquear } else {
683          * return emiterelatorio; }
684          */}
685 
686     return emiterelatorio;
687   }
688 
689 }