ValidaPermissao xref

View Javadoc

1   /*
2    * Created on 14/06/2005
3    *
4    */
5   package ecar.permissao;
6   
7   import java.util.ArrayList;
8   import java.util.Iterator;
9   import java.util.List;
10  import java.util.Set;
11  
12  import org.apache.log4j.Logger;
13  import org.hibernate.HibernateException;
14  import org.hibernate.Query;
15  
16  import comum.util.Pagina;
17  
18  import ecar.dao.EstruturaAcessoDao;
19  import ecar.dao.EstruturaDao;
20  import ecar.dao.ItemEstrutUsuarioDao;
21  import ecar.dao.ItemEstruturaDao;
22  import ecar.dao.TipoAcompGrpAcessoDao;
23  import ecar.dao.TipoAcompTipofuncacompSisatributoTaTpfaSatbDao;
24  import ecar.dao.TipoFuncAcompDao;
25  import ecar.exception.ECARException;
26  import ecar.login.SegurancaECAR;
27  import ecar.pojo.AcompReferenciaItemAri;
28  import ecar.pojo.EstrutTpFuncAcmpEtttfa;
29  import ecar.pojo.EstruturaAcessoEtta;
30  import ecar.pojo.EstruturaEtt;
31  import ecar.pojo.EstruturaFuncaoEttf;
32  import ecar.pojo.ItemEstrutUsuarioIettus;
33  import ecar.pojo.ItemEstruturaIett;
34  import ecar.pojo.OrgaoOrg;
35  import ecar.pojo.SisAtributoSatb;
36  import ecar.pojo.TipoAcompanhamentoTa;
37  import ecar.pojo.TipoFuncAcompTpfa;
38  import ecar.pojo.UsuarioUsu;
39  
40  /**
41   * @author garten
42   */
43  public class ValidaPermissao {
44      
45  	private Logger logger = null;
46  
47  	public static final String SIM = "S";
48      public static final String NAO = "N";
49  	
50  	public static final String EM_MONITORAMENTO = "M";
51  	public static final String PROPRIA_SECRETARIA = "P";    
52  	public static final String OUTRAS_SECRETARIAS = "O";
53  	
54  	public static final String LEITURA_ACOMP_MONITORADO_SUA_SECRETARIA = "LEITURA_ACOMP_MONITORADO_SUA_SECRETARIA";
55  	public static final String LEITURA_ACOMP_MONITORADO_OUTRA_SECRETARIA = "LEITURA_ACOMP_MONITORADO_OUTRA_SECRETARIA";
56  	public static final String LEITURA_ACOMP_SUA_SECRETARIA = "LEITURA_ACOMP_SUA_SECRETARIA";
57  	public static final String LEITURA_ACOMP_OUTRA_SECRETARIA = "LEITURA_ACOMP_OUTRA_SECRETARIA";
58  	
59  	/* VARIÁVEIS UTILIZADAS PARA VERIFICAR PERMISSÕES - UTILIZADAS COMO VALORES BINÁRIOS */
60  	public static final short PERMISSAO_EXCLUIR = 1;
61  	public static final short PERMISSAO_CONSULTAR = 2;  // se continuar, utilizar, 4, 8, 16, 32, 64, ...
62  	public static final short PERMISSAO_CONSULTAR_PARECER = 4;
63  
64  	/* VARIÁVEIS UTILIZADAS PARA VERIFICAR PERMISSÕES DE INCLUIR REGISTRO DE ACOMPANHAMENTO  */
65  	public static final int PERMISSAO_TODOS_ORGAOS = 1;
66  	public static final int PERMISSAO_SEUS_ORGAOS = 2;  
67  	public static final int PERMISSAO_SUA_RESPONSABILIDADE = 3;
68  		
69  	private short PERMISSOES = 0;
70  	
71  	private boolean ignorarPermissoes = false;
72  
73  	/**
74  	 * Construtor Valida Permissao.<br>
75  	 * 
76  	 * @author N/C
77       * @since N/C
78       * @version N/C
79  	 */
80  	public ValidaPermissao() {
81  		setIgnorarPermissoes(false);
82  
83  		logger = Logger.getLogger(this.getClass());
84  		
85  		try {
86  			Object ignorarPermissoesContext = String.valueOf("");//Connector.getInstance().getResource("ignorarPermissoes");
87  			
88  			if(ignorarPermissoesContext != null) {
89  				if("true".equals(ignorarPermissoesContext.toString())) {
90  					setIgnorarPermissoes(true);
91  				}
92  			}
93  		}
94  		catch(Exception e) {
95  			// não precisa logar exceção
96  			org.apache.log4j.Logger.getLogger(this.getClass()).error(e);
97  		}
98  	}
99  	
100     /**
101      * Verificar, para um item, se o usuario tem permissao para exclui-lo.<br>
102      * Pode excluir se usuario x grupo x item x iettus tem ind_exclusao = 'S'.<br>
103      * 
104      * @author N/C
105      * @since N/C
106      * @version N/C
107      * @param ItemEstruturaIett item
108      * @param UsuarioUsu usuario
109      * @param Set gruposUsuario
110      * @return boolean
111      */
112     public boolean permissaoExcluirItem(ItemEstruturaIett item, UsuarioUsu usuario, Set gruposUsuario) {
113     	try {
114 	    	if(getIgnorarPermissoes()) {
115 	    		return true;
116 	    	}
117 	    	
118 			Set itemUsuarios = item.getItemEstrutUsuarioIettusesByCodIett();
119 			Iterator it = itemUsuarios.iterator();
120 			while(it.hasNext()){
121 				ItemEstrutUsuarioIettus ieUsuario = (ItemEstrutUsuarioIettus) it.next();
122 				if(ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_GRUPO) && gruposUsuario.contains(ieUsuario.getSisAtributoSatb())){
123 					if(SIM.equals(ieUsuario.getIndExcluirIettus()))
124 						return true;
125 				}
126 				if((ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_USUARIO) 
127 					|| ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_FUNCAO_ACOMPANHAMENTO))
128 					&& 
129 					((ieUsuario.getUsuarioUsu() != null && ieUsuario.getUsuarioUsu().equals(usuario)) || (ieUsuario.getSisAtributoSatb() != null && gruposUsuario.contains(ieUsuario.getSisAtributoSatb())))){
130 					if(SIM.equals(ieUsuario.getIndExcluirIettus()))
131 						return true;				
132 				}
133 			}
134 			
135 	        return false;
136 		}
137 		catch(Exception e) {
138 			this.logger.error(e);
139 	        return false;
140 		}
141     }
142 
143     /**
144      * Verificar, para uma estrutura, se o usuario pode adicionar um item.<br>
145      * Pode adicionar se grupo x etta tem ind_incl_item = 'S'.<br>
146      * 
147      * @author N/C
148      * @since N/C
149      * @version N/C
150      * @param EstruturaEtt estrutura
151      * @param Set gruposUsuario
152      * @return boolean
153      */
154     public boolean permissaoAdicionarItem(EstruturaEtt estrutura, Set gruposUsuario) {
155     	try {
156 	    	if( ignorarPermissoes ) {
157 	    		return true;
158 	    	}
159 	    	
160 	    	for (Iterator it = estrutura.getEstruturaAcessoEttas().iterator(); it.hasNext();) {
161 				EstruturaAcessoEtta estruturaAcesso = (EstruturaAcessoEtta) it.next();
162 				if(gruposUsuario.contains(estruturaAcesso.getSisAtributoSatb())){
163 					 if(estruturaAcesso.getIndIncItemEtta() != null && SIM.equals(estruturaAcesso.getIndIncItemEtta())){
164 						  return true;				
165 					 }
166 				}
167 			 }
168 			 return false;		
169 		}
170 		catch(Exception e) {
171 			this.logger.error(e);
172 	        return false;
173 		}
174     }
175 
176 
177     /**
178      * Verificar, para um item, se o usuario pode altera-lo.<br>
179      * Pode alterar se usuario x grupo x item x iettus tem ind_edicao = 'S'.<br>
180      * 
181      * @author N/C
182      * @since N/C
183      * @version N/C
184      * @param ItemEstruturaIett item
185      * @param UsuarioUsu usuario
186      * @param Set gruposUsuario
187      * @return boolean
188      */
189     public Boolean permissaoAlterarItem(ItemEstruturaIett item, UsuarioUsu usuario, Set gruposUsuario, EstruturaFuncaoEttf estruturaFuncaoEttf) {
190     	try {
191     		if(getIgnorarPermissoes()) {
192     			return true;
193     		}
194 
195     		Set itemUsuarios = item.getItemEstrutUsuarioIettusesByCodIett();
196     		Iterator it = itemUsuarios.iterator();
197 
198     		while(it.hasNext()){
199     			ItemEstrutUsuarioIettus ieUsuario = (ItemEstrutUsuarioIettus) it.next();
200     			
201     			/* Procurar saber que informação é essa para documentar*/
202     			if(ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_GRUPO) && 
203     					gruposUsuario.contains(ieUsuario.getSisAtributoSatb())) {
204     				
205     				/* Se o usuário tem permissão para editar o item */
206     				if(SIM.equals(ieUsuario.getIndEdicaoIettus())) {
207     					
208     					/*Verfica se o planejamento do item está bloqueado */
209     					if (item.getIndBloqPlanejamentoIett() == null || item.getIndBloqPlanejamentoIett().equals(NAO)) {
210     						return true;
211     					} else {
212     						if (estruturaFuncaoEttf == null || estruturaFuncaoEttf.getIndPodeBloquearEttf().equals(NAO)){
213     							return true;
214     						}
215     					}
216     				}
217     			} 
218     			
219     			if((ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_USUARIO) 
220     					|| ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_FUNCAO_ACOMPANHAMENTO)) 
221     					&& ( (ieUsuario.getUsuarioUsu() != null && ieUsuario.getUsuarioUsu().equals(usuario)) 
222     						|| (ieUsuario.getSisAtributoSatb() != null && gruposUsuario.contains(ieUsuario.getSisAtributoSatb())))){
223     				
224     				/*Verifica se o usuário pode editar o item*/
225     				if(SIM.equals(ieUsuario.getIndEdicaoIettus())) {
226     					if (item.getIndBloqPlanejamentoIett() == null || 
227     							NAO.equals(item.getIndBloqPlanejamentoIett())) {
228     						return true;
229     					} else {
230     						if (estruturaFuncaoEttf == null || estruturaFuncaoEttf.getIndPodeBloquearEttf().equals(NAO)){
231     							return true;
232     						}
233     					}
234     				}
235     			}
236     		}
237     		
238     		/*Correção homologacao v7.0 */
239     		/* Caso o item esteja bloqueado verificar se o usuário (ou os grupos) é função de acompanhamento com permissão de alterar */
240     		if (estruturaFuncaoEttf!=null &&  ( item.getIndBloqPlanejamentoIett() != null || SIM.equals(item.getIndBloqPlanejamentoIett()  ) ) ) {
241     			
242     			// Lista com as funções de acompanhamento para as quais o item não está bloqueado  
243 				Iterator itLiberadoParaTpfa =  estruturaFuncaoEttf.getLibTipoFuncAcompTpfas().iterator();
244 			
245 				// Lista com as funcoes de acompanhamento do usuário 
246 				List listTipoFuncaoUsuario = (new TipoFuncAcompDao(null)).getFuncoesAcompNaEstruturaDoUsuario(item, usuario, gruposUsuario);
247 		
248 				while (itLiberadoParaTpfa.hasNext()){
249 					TipoFuncAcompTpfa liberadoParaTpfa = (TipoFuncAcompTpfa) itLiberadoParaTpfa.next();
250 
251 					if (listTipoFuncaoUsuario!= null &&  listTipoFuncaoUsuario.contains(liberadoParaTpfa)){
252 						return true;
253 					}
254 				}
255     		}
256     		
257     		return false;
258     	}
259     	catch(Exception e) {
260     		this.logger.error(e);
261     		return false;
262     	}
263     }
264     
265     /**
266      * Verificar, para um item, se o usuario pode ler seus dados e funcoes.<br>
267      * Pode consultar se usuario x grupo x item x iettus tem<br> 
268      * ind_leitura = 'S'.<br>
269      * 
270      * @author N/C
271      * @since N/C
272      * @version N/C
273      * @param ItemEstruturaIett item
274      * @param UsuarioUsu usuario
275      * @param Set gruposUsuario
276      * @return boolean
277      */
278     public boolean permissaoConsultarItem(ItemEstruturaIett item, UsuarioUsu usuario, Set gruposUsuario) {
279     	try {
280 	    	if(getIgnorarPermissoes()) {
281 	    		return true;
282 	    	}
283 	    	
284 			Set itemUsuarios = item.getItemEstrutUsuarioIettusesByCodIett();
285 	    	
286 	    	if(itemUsuarios == null) {
287 	    		return true;
288 	    	}
289 	
290 	    	Iterator it = itemUsuarios.iterator();
291 			while(it.hasNext()){
292 				ItemEstrutUsuarioIettus ieUsuario = (ItemEstrutUsuarioIettus) it.next();
293 				if(ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_GRUPO) && gruposUsuario.contains(ieUsuario.getSisAtributoSatb())){
294 					if(ieUsuario.getIndLeituraIettus().equals(SIM))
295 						return true;
296 				}
297 				if((ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_USUARIO) 
298 						|| ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_FUNCAO_ACOMPANHAMENTO))				
299 						&& 
300 						((ieUsuario.getUsuarioUsu() != null && ieUsuario.getUsuarioUsu().equals(usuario)) || (ieUsuario.getSisAtributoSatb() != null && gruposUsuario.contains(ieUsuario.getSisAtributoSatb())))){
301 					if(ieUsuario.getIndLeituraIettus().equals(SIM))
302 						return true;				
303 				}
304 			}
305 	        return false;
306     	}
307     	catch(Exception e) {
308 			this.logger.error(e);
309 	        return false;
310     	}
311     }
312     
313     /**
314      * Verificar, para um item, se o usuario pode ativar o monitoramento.<br>
315      * Pode ativar o monitoramento se<br>
316      * usuario x grupo x item x iettus tem ind_ativ_monit = 'S' e<br>
317      * item.ind_monitoramento = 'N'.<br>
318      * 
319      * @author N/C
320      * @since N/C
321      * @version N/C
322      * @param ItemEstruturaIett item
323      * @param UsuarioUsu usuario
324      * @param Set gruposUsuario
325      * @return boolean
326      */
327     public boolean permissaoAtivarMonitoramentoItem(ItemEstruturaIett item, UsuarioUsu usuario, Set gruposUsuario) {
328     	try {
329 	    	if(getIgnorarPermissoes()) {
330 	    		return true;
331 	    	}
332 	    	
333 			Set itemUsuarios = item.getItemEstrutUsuarioIettusesByCodIett();
334 			if(itemUsuarios != null){
335 				Iterator it = itemUsuarios.iterator();
336 				while(it.hasNext()){
337 					ItemEstrutUsuarioIettus ieUsuario = (ItemEstrutUsuarioIettus) it.next();
338 					if(ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_GRUPO) && gruposUsuario.contains(ieUsuario.getSisAtributoSatb())){
339 						if(ieUsuario.getIndAtivMonitIettus().equals(SIM) && (item.getIndMonitoramentoIett() == null || item.getIndMonitoramentoIett().equals(NAO)))
340 							return true;
341 					}
342 					if((ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_USUARIO) 
343 							|| ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_FUNCAO_ACOMPANHAMENTO))
344 							&& 
345 							((ieUsuario.getUsuarioUsu() != null && ieUsuario.getUsuarioUsu().equals(usuario)) || (ieUsuario.getSisAtributoSatb() != null && gruposUsuario.contains(ieUsuario.getSisAtributoSatb())))){
346 						if(ieUsuario.getIndAtivMonitIettus().equals(SIM) && (item.getIndMonitoramentoIett() == null || item.getIndMonitoramentoIett().equals(NAO)))
347 							return true;				
348 					}
349 				}			
350 			}
351 	        return false;       				        
352     	}
353     	catch(Exception e) {
354 			this.logger.error(e);
355 	        return false;
356     	}
357     }
358     
359 
360     /**
361      * Verificar, para um item, se o usuario pode desativar o monitoramento.<br>
362      * Pode desativar o monitoramento se<br>
363      * usuario x grupo x item x iettus tem ind_desat_monit = 'S' e<br>
364      * item.ind_monitoramento = 'S'<br>
365      * 
366      * @author N/C
367      * @since N/C
368      * @version N/C
369      * @param ItemEstruturaIett item
370      * @param UsuarioUsu usuario
371      * @param Set gruposUsuario
372      * @return boolean
373      */
374     public boolean permissaoDesativarMonitoramentoItem(ItemEstruturaIett item, UsuarioUsu usuario, Set gruposUsuario) {
375     	try {
376 	    	if(getIgnorarPermissoes()) {
377 	    		return true;
378 	    	}
379 	    	
380 			Set itemUsuarios = item.getItemEstrutUsuarioIettusesByCodIett();
381 			Iterator it = itemUsuarios.iterator();
382 			while(it.hasNext()){
383 				ItemEstrutUsuarioIettus ieUsuario = (ItemEstrutUsuarioIettus) it.next();
384 				if(ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_GRUPO) && gruposUsuario.contains(ieUsuario.getSisAtributoSatb())){
385 					if(ieUsuario.getIndDesatMonitIettus().equals(SIM) && (item.getIndMonitoramentoIett() != null && item.getIndMonitoramentoIett().equals(SIM)))
386 						return true;
387 				}
388 				if((ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_USUARIO) 
389 						|| ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_FUNCAO_ACOMPANHAMENTO))
390 						&& 
391 						((ieUsuario.getUsuarioUsu() != null && ieUsuario.getUsuarioUsu().equals(usuario)) || (ieUsuario.getSisAtributoSatb() != null && gruposUsuario.contains(ieUsuario.getSisAtributoSatb())))){
392 					if(ieUsuario.getIndDesatMonitIettus().equals(SIM) && (item.getIndMonitoramentoIett() != null && item.getIndMonitoramentoIett().equals(SIM)))
393 						return true;				
394 				}
395 			}       		
396 	        return false;
397     	}
398     	catch(Exception e) {
399 			this.logger.error(e);
400 	        return false;
401     	}
402     }
403 
404 
405     /**
406      * Verificar, para um item, se o usuario pode bloquear planejamento.<br>
407      * Pode bloquear o planejamento se<br>
408      * usuario x grupo x item x iettus tem ind_bloq_plan = 'S' e<br>
409      * item.ind_bloq_planejamento = 'N'<br>
410      * 
411      * @author N/C
412      * @since N/C
413      * @version N/C
414      * @param ItemEstruturaIett item
415      * @param UsuarioUsu usuario
416      * @param Set gruposUsuario
417      * @return boolean
418      */
419     public boolean permissaoBloquearPlanejamentoItem(ItemEstruturaIett item, UsuarioUsu usuario, Set gruposUsuario) {
420     	try {
421 	    	if(getIgnorarPermissoes()) {
422 	    		return true;
423 	    	}
424 	    	
425 			Set itemUsuarios = item.getItemEstrutUsuarioIettusesByCodIett();
426 			if(itemUsuarios != null){
427 				Iterator it = itemUsuarios.iterator();
428 				while(it.hasNext()){
429 					ItemEstrutUsuarioIettus ieUsuario = (ItemEstrutUsuarioIettus) it.next();
430 					if(ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_GRUPO) && gruposUsuario.contains(ieUsuario.getSisAtributoSatb())){
431 						if(ieUsuario.getIndBloqPlanIettus().equals(SIM) && (item.getIndBloqPlanejamentoIett() == null || item.getIndBloqPlanejamentoIett().equals(NAO)))
432 							return true;
433 					}
434 					if((ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_USUARIO) 
435 							|| ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_FUNCAO_ACOMPANHAMENTO))
436 							&& 
437 							((ieUsuario.getUsuarioUsu() != null && ieUsuario.getUsuarioUsu().equals(usuario)) || (ieUsuario.getSisAtributoSatb() != null && gruposUsuario.contains(ieUsuario.getSisAtributoSatb())))){
438 						if(ieUsuario.getIndBloqPlanIettus().equals(SIM) && (item.getIndBloqPlanejamentoIett() == null || item.getIndBloqPlanejamentoIett().equals(NAO)))
439 							return true;				
440 					}
441 				}	
442 			}		       		        				
443 	        return false;
444     	}
445     	catch(Exception e) {
446 			this.logger.error(e);
447 	        return false;
448     	}
449     }
450 
451     /**
452      * Verificar, para um item, se o usuario pode liberar o planejamento.<br>
453      * Pode liberar o planejamento se<br>
454      * usuario x grupo x item x iettus tem ind_desbl_plan = 'S' e<br>
455      * item.ind_bloq_plan = 'S'<br>
456      * 
457      * @author N/C
458      * @since N/C
459      * @version N/C
460      * @param ItemEstruturaIett item
461      * @param UsuarioUsu usuario
462      * @param Set gruposUsuario
463      * @return boolean
464      */
465     public boolean permissaoLiberarPlanejamentoItem(ItemEstruturaIett item, UsuarioUsu usuario, Set gruposUsuario) {
466     	try {
467 	    	if(getIgnorarPermissoes()) {
468 	    		return true;
469 	    	}
470 	    	
471 			Set itemUsuarios = item.getItemEstrutUsuarioIettusesByCodIett();
472 			Iterator it = itemUsuarios.iterator();
473 			while(it.hasNext()){
474 				ItemEstrutUsuarioIettus ieUsuario = (ItemEstrutUsuarioIettus) it.next();
475 				if(ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_GRUPO) && gruposUsuario.contains(ieUsuario.getSisAtributoSatb())){
476 					if(ieUsuario.getIndDesblPlanIettus().equals(SIM) && (item.getIndBloqPlanejamentoIett() != null && item.getIndBloqPlanejamentoIett().equals(SIM)))
477 						return true;
478 				}
479 				if((ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_USUARIO) 
480 						|| ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_FUNCAO_ACOMPANHAMENTO))
481 						&& 
482 						((ieUsuario.getUsuarioUsu() != null && ieUsuario.getUsuarioUsu().equals(usuario)) || (ieUsuario.getSisAtributoSatb() != null && gruposUsuario.contains(ieUsuario.getSisAtributoSatb())))){
483 					if(ieUsuario.getIndDesblPlanIettus().equals(SIM) && (item.getIndBloqPlanejamentoIett() != null && item.getIndBloqPlanejamentoIett().equals(SIM)))
484 						return true;				
485 				}
486 			}       		        						
487 	        return false;
488     	}
489     	catch(Exception e) {
490 			this.logger.error(e);
491 	        return false;
492     	}
493     }
494     
495        
496     /**
497      * Devolve true quando o usuario faz parte de algum grupo em estrutura_acesso que tem permissao de incluir 
498      * referencia em monitoramento.<br>
499      * 
500      * @author N/C
501      * @since N/C
502      * @version N/C
503      * @param Set gruposUsuario
504      * @return boolean
505      * @throws ECARException
506      */
507 //    public boolean permissaoAcessoReferenciaMonitoramento(Set gruposUsuario) throws ECARException {
508 //    	if(getIgnorarPermissoes()) {
509 //    		return true;
510 //    	}
511 //    	
512 //        return new EstruturaAcessoDao(null).temPermissoesAcessoAcompMonitorado(gruposUsuario);
513 //    }
514 
515     /**
516      * Devolve true quando o usuario faz parte de algum grupo em estrutura_acesso que tem permissao de incluir 
517      * referencia para sua própria secretaria.<br>
518      * 
519      * @author N/C
520      * @since N/C
521      * @version N/C
522      * @param Set gruposUsuario
523      * @return boolean
524      * @throws ECARException
525      */
526 //	public boolean permissaoAcessoReferenciaSecretaria (Set gruposUsuario) throws ECARException {
527 //    	if(getIgnorarPermissoes()) {
528 //    		return true;
529 //    	}
530 //    	
531 //        return new EstruturaAcessoDao(null).temPermissoesAcessoSecretaria(gruposUsuario);		
532 //    }
533 
534 	/**
535      * Devolve true quando o usuario faz parte de algum grupo em estrutura_acesso que tem permissao de incluir 
536      * referencia para qualquer secretaria que não seja sua propria.<br>
537      * 
538      * @author N/C
539      * @since N/C
540      * @version N/C
541      * @param Set gruposUsuario
542      * @return boolean
543      * @throws ECARException
544      */
545 //	public boolean permissaoAcessoReferenciaOutraSecretaria (Set gruposUsuario) throws ECARException {
546 //    	if(getIgnorarPermissoes()) {
547 //    		return true;
548 //    	}
549 //    	
550 //        return new EstruturaAcessoDao(null).temPermissoesAcessoOutraSecretaria(gruposUsuario);
551 //    }
552 
553     /**
554      * Devolve true quando o usuario faz parte de algum grupo em estrutura_acesso que tem permissao de incluir 
555      * referencia em monitoramento para itens de uma estrutura.<br>
556      * 
557      * @author N/C
558      * @since N/C
559      * @version N/C
560      * @param Set gruposUsuario
561      * @param EstruturaEtt estrutura
562      * @return boolean
563      * @throws ECARException
564      */
565 //	public boolean permissaoAcessoReferenciaMonitoramento (Set gruposUsuario, EstruturaEtt estrutura) throws ECARException {
566 //    	if(getIgnorarPermissoes()) {
567 //    		return true;
568 //    	}
569 //    	
570 //  return new EstruturaAcessoDao(null).temPermissoesAcessoAcompMonitorado(gruposUsuario, estrutura);
571 //    }
572 
573     /**
574      * Devolve true quando o usuario faz parte de algum grupo em estrutura_acesso que tem permissao de incluir 
575      * referencia para a secretaria do usuário para itens de uma estrutura.<br>
576      * 
577      * @author N/C
578      * @since N/C
579      * @version N/C
580      * @param Set gruposUsuario
581      * @param EstruturaEtt estrutura
582      * @return boolean
583      * @throws ECARException
584      */
585 //	public boolean permissaoAcessoReferenciaSecretaria (Set gruposUsuario, EstruturaEtt estrutura) throws ECARException {
586 //    	if(getIgnorarPermissoes()) {
587 //    		return true;
588 //    	}
589 //    	
590 //        return new EstruturaAcessoDao(null).temPermissoesAcessoSecretaria(gruposUsuario, estrutura);		
591 //    }
592 	
593 	/**
594      * Devolve true quando o usuario faz parte de algum grupo em <br>
595      * estrutura_acesso que tem permissao de incluir  referencia <br>
596      * para a qualquer secreataria que não seja a prorpria secretaria<br>
597      * do usuário para itens de uma estrutura.<br>
598      * 
599      * @author N/C
600      * @since N/C
601      * @version N/C
602      * @param Set gruposUsuario
603      * @param EstruturaEtt estrutura
604      * @return boolean
605      * @throws ECARException
606      */
607 //	public boolean permissaoAcessoReferenciaOutraSecretaria (Set gruposUsuario, EstruturaEtt estrutura) throws ECARException {
608 //    	if(getIgnorarPermissoes()) {
609 //    		return true;
610 //    	}
611 //    	
612 //        return new EstruturaAcessoDao(null).temPermissoesAcessoOutraSecretaria(gruposUsuario, estrutura);
613 //    }
614 	
615 	/**
616      * Verifica se um usuário tem permissão para acesso à elaboração de acompanhamento de um item.<br>
617      * As condições para isso são:<br>
618      * (TODO Cade as condicoes?)
619      * 
620      * @author N/C
621      * @since N/C
622      * @version N/C
623      * @param ItemEstruturaIett item
624      * @param UsuarioUsu usuario
625      * @param Set gruposUsuario
626      * @return boolean
627      * @throws ECARException
628      */
629 //	public boolean permissaoAcessoItemElaboracaoAcompEmMonitoramento(ItemEstruturaIett item, UsuarioUsu usuario, Set gruposUsuario) throws ECARException{
630 //    	if(getIgnorarPermissoes()) {
631 //    		return true;
632 //    	}
633 //    	
634 //		return permissaoAcessoItemElaboracaoAcomp(item, usuario, gruposUsuario, EM_MONITORAMENTO);
635 //	}
636 
637 //	/**
638 // 	 * Verifica se usuario tem permissao de acesso ao item da propria da secretaria.<br>
639 //	 * 
640 //	 * @author N/C
641 //     * @since N/C
642 //     * @version N/C
643 //	 * @param ItemEstruturaIett item
644 //	 * @param UsuarioUsu usuario
645 //	 * @param Set gruposUsuario
646 //	 * @return boolean
647 //	 * @throws ECARException
648 //	 */
649 //	public boolean permissaoAcessoItemElaboracaoAcompPropriaSecretaria(ItemEstruturaIett item, UsuarioUsu usuario, Set gruposUsuario) throws ECARException{
650 //    	if(getIgnorarPermissoes()) {
651 //    		return true;
652 //    	}
653 //    	
654 //		return permissaoAcessoItemElaboracaoAcomp(item, usuario, gruposUsuario, PROPRIA_SECRETARIA);
655 //	}
656 
657 	/**
658 	 * Verifica se usuario tem permissao de acesso ao item.<br>
659 	 * 
660 	 * @author N/C
661      * @since N/C
662      * @version N/C
663 	 * @param ItemEstruturaIett item
664 	 * @param UsuarioUsu usuario
665 	 * @param Set gruposUsuario
666 	 * @return boolean
667 	 * @throws ECARException
668 	 */
669 //	public boolean permissaoAcessoItemElaboracaoAcompOutraSecretaria(ItemEstruturaIett item, UsuarioUsu usuario, Set gruposUsuario) throws ECARException{
670 //    	if(getIgnorarPermissoes()) {
671 //    		return true;
672 //    	}
673 //    	
674 //		return permissaoAcessoItemElaboracaoAcomp(item, usuario, gruposUsuario, OUTRAS_SECRETARIAS);
675 //	}
676 
677 	/**
678 	 * Verifica se usuario tem permissao de acesso ao item.<br>
679 	 * 
680 	 * @author N/C
681      * @since N/C
682      * @version N/C
683 	 * @param ItemEstruturaIett item
684 	 * @param UsuarioUsu usuario
685 	 * @param Set gruposUsuario
686 	 * @param String tipoAcesso
687 	 * @return boolean
688 	 * @throws ECARException
689 	 */
690 	public boolean permissaoAcessoItemElaboracaoAcomp(ItemEstruturaIett item, UsuarioUsu usuario, Set gruposUsuario, String tipoAcesso, TipoAcompanhamentoTa tipoAcompanhamentoTa) throws ECARException{
691     	if(getIgnorarPermissoes()) {
692     		return true;
693     	}
694     	
695     	List itensUsuario = new ItemEstrutUsuarioDao(null).getItemEstrutUsuarioItemOrigemAndEmitePosicaoAndInfAndamento(item.getCodIett());
696 		Iterator it = itensUsuario.iterator();
697 		while(it.hasNext()){
698 			ItemEstrutUsuarioIettus ieUsuario = (ItemEstrutUsuarioIettus) it.next();
699 			if(ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_GRUPO) && gruposUsuario.contains(ieUsuario.getSisAtributoSatb())){
700 				return true;
701 			}
702 			if(((ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_USUARIO)
703 					|| ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_FUNCAO_ACOMPANHAMENTO))
704 					&& 
705 					(ieUsuario.getUsuarioUsu() != null && ieUsuario.getUsuarioUsu().equals(usuario)) || (ieUsuario.getSisAtributoSatb() != null && gruposUsuario.contains(ieUsuario.getSisAtributoSatb())))){
706 				return true;				
707 			}
708 		}
709 		
710 		if (permissaoAcessoReferencia(tipoAcompanhamentoTa, gruposUsuario)) {
711 			return true;
712 		}
713 		
714 //		if(tipoAcesso.equals(EM_MONITORAMENTO)){
715 //			if(permissaoAcessoReferenciaMonitoramento(gruposUsuario, item.getEstruturaEtt()))
716 //				return true;			
717 //		}		
718 //		if(tipoAcesso.equals(PROPRIA_SECRETARIA)){
719 //			if(permissaoAcessoReferenciaSecretaria(gruposUsuario, item.getEstruturaEtt()))
720 //				return true;			
721 //		}
722 //		if(tipoAcesso.equals(OUTRAS_SECRETARIAS)){
723 //			if(permissaoAcessoReferenciaOutraSecretaria(gruposUsuario, item.getEstruturaEtt()))
724 //				return true;			
725 //		}
726 		
727 		return false;
728 	}
729 	
730 	
731 	
732 	/**
733 	 * Remove da lista os itens em que o usuário(ou seus grupos) não tenha permissao 
734 	 * de acesso na Estrutura do item.<br>
735 	 * 
736 	 * @author N/C
737      * @since N/C
738      * @version N/C
739 	 * @param List lista
740 	 * @param Set gruposUsuario
741 	 * @param String tipoAcesso
742 	 * @return List
743 	 * @throws ECARException
744 	 */
745 	/*public List removeItensSemAcessoElaboracaoAcomp(List lista, Set gruposUsuario, String tipoAcesso, TipoAcompanhamentoTa tipoAcompanhamentoTa) throws ECARException{
746 		Iterator it = lista.iterator();
747 		
748 		while(it.hasNext()){
749 			ItemEstruturaIett itemEstrutura = (ItemEstruturaIett) it.next();
750 			
751 			
752 
753 			
754 			if (!permissaoAcessoReferencia(tipoAcompanhamentoTa, gruposUsuario)
755 			
756 			if(tipoAcesso.equals(EM_MONITORAMENTO)) {
757 				if(!permissaoAcessoReferenciaMonitoramento(gruposUsuario, itemEstrutura.getEstruturaEtt())) {
758 					it.remove();
759 				}
760 			} else if(tipoAcesso.equals(PROPRIA_SECRETARIA)) {
761 				if(!permissaoAcessoReferenciaSecretaria(gruposUsuario, itemEstrutura.getEstruturaEtt())) {
762 					it.remove();
763 				}
764 			} else if(tipoAcesso.equals(OUTRAS_SECRETARIAS)) {
765 				if(!permissaoAcessoReferenciaOutraSecretaria(gruposUsuario, itemEstrutura.getEstruturaEtt())) {
766 					it.remove();
767 				}
768 			} 
769 		}
770 		
771 		return lista;
772 	}*/
773 
774     /**
775      * Descobre se o usuario tem acesso a algum item filho, neto, ..., do item passado como param.<br>
776      * <p>
777      * Obs.: Pode ter performance melhorada, por exemplo instanciar uma lista na classe,
778      * 		executando o select somente uma vez por tela. Depois por item, em método 
779      * 		separado, realizar a verificação se filhos, netos do item está na lista.
780      *  
781      * @author N/C
782      * @since N/C
783      * @version N/C
784      * @param ItemEstruturaIett item
785      * @param UsuarioUsu usuario
786      * @param Set gruposUsuario
787      * @return boolean
788      * @throws ECARException
789      */
790     public boolean permissaoAcessoItensFilhos(ItemEstruturaIett item, UsuarioUsu usuario, Set gruposUsuario) throws ECARException {
791     	if( ignorarPermissoes ) {
792     		return true;
793     	}
794     	
795     	try{
796     		ItemEstruturaDao itemEstruturaDao = new ItemEstruturaDao(null);
797     		EstruturaDao estruturaDao = new EstruturaDao(null);
798 
799 //    		List estruturas = estruturaDao.getDescendentes(item.getEstruturaEtt());
800     		List estruturas = estruturaDao.getListaEstruturas(item.getEstruturaEtt());
801 	        if(estruturas != null && estruturas.size() > 0){
802 	        	ArrayList<Long> codEtt = new ArrayList<Long>();
803 	        	
804 	        	for (Iterator itEtt = estruturas.iterator(); itEtt.hasNext();) {
805 					EstruturaEtt ett = (EstruturaEtt) itEtt.next();
806 					codEtt.add(ett.getCodEtt());
807 				}
808 	        	
809 	        	StringBuilder sql = new StringBuilder(
810 	        			 "select item " +
811 			                "from ItemEstruturaIett item " +
812 			                "join item.estruturaEtt as estrutura " + 
813 							"join item.itemEstrutUsuarioIettusesByCodIett as iettus " +
814 			                "where estrutura.codEtt in (:estruturas) " +
815 			                "and ( iettus.usuarioUsu.codUsu = :usuario"	        	
816 	        	);
817 					
818 	        	ArrayList<Long> codSatb = new ArrayList<Long>();
819 				if(gruposUsuario != null && gruposUsuario.size() > 0) {
820 					sql.append( " or iettus.sisAtributoSatb.codSatb in (:grupos)" );
821 
822 					for (Iterator itSatb = gruposUsuario.iterator(); itSatb.hasNext();) {
823 						SisAtributoSatb satb = (SisAtributoSatb) itSatb.next();
824 						codSatb.add(satb.getCodSatb());
825 					}
826 				}
827 				
828 				sql.append( " ) " );
829 	
830 	            Query q = estruturaDao.getSession().createQuery(sql.toString());
831 	            
832 	            q.setParameterList("estruturas", codEtt);
833 	            q.setLong("usuario", usuario.getCodUsu().longValue());
834 	
835 	            if(gruposUsuario != null && gruposUsuario.size() > 0){
836 	            	q.setParameterList("grupos", codSatb);
837 				}
838 	    		
839 	            List itensFilhos = q.list();
840 	            
841 	            for (Iterator it = itensFilhos.iterator(); it.hasNext();) {
842 	            	ItemEstruturaIett itemFilho = (ItemEstruturaIett) it.next();
843 	            	
844 	            	/* Verifica se item é filho, neto, bisneto do item passado como parâmetro */
845 	            	if((itemEstruturaDao.getAscendentes(itemFilho)).contains(item)) {
846 	            		return true;
847 	            	}
848 	    		}
849 			}
850     	}catch(HibernateException e){
851 			this.logger.error(e);
852     		throw new ECARException("");
853     	}
854 	        
855         return false;
856     }
857 	
858 	/**
859 	 * Retorna verdadeiro se um usuário tem permissão para 
860 	 * Informação de realizado físico Pode informar realizado físico  se
861      * usuario x grupo x item x iettus tem ind_inf_andamento = 'S' e.<br>
862      * 
863      * @author N/C
864      * @since N/C
865      * @version N/C
866 	 * @param ItemEstruturaIett item
867 	 * @param UsuarioUsu usuario
868 	 * @param Set gruposUsuario
869 	 * @return boolean
870 	 * @throws ECARException
871 	 */
872 	public boolean permissaoInformarRealizadoFisico(ItemEstruturaIett item, UsuarioUsu usuario, Set gruposUsuario) throws ECARException{		
873     	if(getIgnorarPermissoes()) {
874     		return true;
875     	}
876     	
877 		Set itensUsuario = item.getItemEstrutUsuarioIettusesByCodIett();
878 		if(itensUsuario != null){
879 			Iterator it = itensUsuario.iterator();
880 			while(it.hasNext()){
881 				ItemEstrutUsuarioIettus ieUsuario = (ItemEstrutUsuarioIettus) it.next();
882 				if(ieUsuario.getItemEstruturaIett().equals(item) && ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_GRUPO) && gruposUsuario.contains(ieUsuario.getSisAtributoSatb())){
883 					if(ieUsuario.getIndInfAndamentoIettus().equals(SIM) || ieUsuario.getIndInfAndamentoIettus().equals(SIM))
884 						return true;
885 				}
886 				if(ieUsuario.getItemEstruturaIett().equals(item) 
887 						&& ((ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_USUARIO) 
888 								|| ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_FUNCAO_ACOMPANHAMENTO))
889 								&& 
890 								((ieUsuario.getUsuarioUsu() != null && ieUsuario.getUsuarioUsu().equals(usuario)) || (ieUsuario.getSisAtributoSatb() != null && gruposUsuario.contains(ieUsuario.getSisAtributoSatb()))))){
891 					if(ieUsuario.getIndInfAndamentoIettus().equals(SIM) || ieUsuario.getIndInfAndamentoIettus().equals(SIM))
892 						return true;				
893 				}
894 			}					
895 		}
896 		return false;
897 	}
898 	
899 	/**
900 	 * Verifica se usuario tem permissao para Informar parecer.<br>
901 	 * 
902 	 * @author N/C
903      * @since N/C
904      * @version N/C
905 	 * @param ItemEstruturaIett item
906 	 * @param UsuarioUsu usuario
907 	 * @param Set gruposUsuario
908 	 * @return boolean
909 	 * @throws ECARException
910 	 */
911 	public boolean permissaoInformarParecer(ItemEstruturaIett item, UsuarioUsu usuario, Set gruposUsuario) throws ECARException{		
912     	if(getIgnorarPermissoes()) {
913     		return true;
914     	}
915     	
916 		Set itensUsuario = item.getItemEstrutUsuarioIettusesByCodIett();
917 		if(itensUsuario != null){
918 			Iterator it = itensUsuario.iterator();
919 			while(it.hasNext()){
920 				ItemEstrutUsuarioIettus ieUsuario = (ItemEstrutUsuarioIettus) it.next();
921 				if(ieUsuario.getItemEstruturaIett().equals(item) && ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_GRUPO) && gruposUsuario.contains(ieUsuario.getSisAtributoSatb())){
922 					if(ieUsuario.getIndEmitePosIettus().equals(SIM) || ieUsuario.getIndEmitePosIettus().equals(SIM))
923 						return true;
924 				}
925 				if(ieUsuario.getItemEstruturaIett().equals(item) 
926 						&& ((ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_USUARIO) 
927 								|| ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_FUNCAO_ACOMPANHAMENTO))
928 								&& 
929 								((ieUsuario.getUsuarioUsu() != null && ieUsuario.getUsuarioUsu().equals(usuario)) || (ieUsuario.getSisAtributoSatb() != null && gruposUsuario.contains(ieUsuario.getSisAtributoSatb()))))){
930 					if(ieUsuario.getIndEmitePosIettus().equals(SIM) || ieUsuario.getIndEmitePosIettus().equals(SIM))
931 						return true;				
932 				}
933 			}					
934 		}
935 		return false;
936 	}
937 	
938 	/**
939 	 * Método alternativo aos métodos permissaoConsultarItem e permissaoExcluirItem
940 	 * Agrupa numa variavel binaria os valores das permissoes, utilizando a 
941 	 *    operação binaria OU ("|")<br>
942 	 * ex.:<br>
943 	 * * 0000 ****** 1010<br>
944 	 * | 1000 ******| 0011<br>
945 	 * **-------- ***** --------<br>
946 	 * * 1000 ****** 1011<br>
947 	 * 
948 	 * @author N/C
949      * @since N/C
950      * @version N/C
951 	 * @param ItemEstruturaIett item
952 	 * @param UsuarioUsu usuario
953 	 * @param Set gruposUsuario
954 	 * @throws ECARException
955 	 */
956 	public void permissoesItem(ItemEstruturaIett item, UsuarioUsu usuario, Set gruposUsuario) throws ECARException {
957 		try{
958 			PERMISSOES = 0;
959 			
960 			StringBuilder query = new StringBuilder(
961 					"select distinct itemUsuario from ItemEstrutUsuarioIettus itemUsuario" +                
962 					" where itemUsuario.itemEstruturaIett.codIett = :codIett" +
963 					" and ( itemUsuario.usuarioUsu.codUsu = :codUsu");
964 			
965 			if(gruposUsuario != null && gruposUsuario.size() > 0) 
966 				query.append( " or itemUsuario.sisAtributoSatb.codSatb in (:grupos)" ) ;
967 			
968 			query.append(" )" );
969 			
970 			Query q = new ItemEstrutUsuarioDao(null).getSession().createQuery(query.toString());   
971 	    	q.setLong("codIett", item.getCodIett().longValue());
972 	        q.setLong("codUsu", usuario.getCodUsu().longValue());
973 	        
974 	        ArrayList<Long> codSatb = new ArrayList<Long>();
975 	        if(gruposUsuario != null && gruposUsuario.size() > 0){
976 	        	
977 	        	for (Iterator itSatb = gruposUsuario.iterator(); itSatb.hasNext();) {
978 					codSatb.add( ((SisAtributoSatb)itSatb.next()).getCodSatb() );
979 				}
980 	        	q.setParameterList("grupos", codSatb);
981 	        }
982 			
983 			List lista = q.list();
984 			
985 			for (Iterator it = lista.iterator(); it.hasNext();) {
986 				ItemEstrutUsuarioIettus itemUsuario = (ItemEstrutUsuarioIettus) it.next();
987 				if(SIM.equals(itemUsuario.getIndExcluirIettus())){
988 					PERMISSOES |= PERMISSAO_EXCLUIR;
989 				}
990 				if(SIM.equals(itemUsuario.getIndLeituraIettus())){
991 					PERMISSOES |= PERMISSAO_CONSULTAR;
992 				}
993 				if(SIM.equals(itemUsuario.getIndLeituraParecerIettus())){
994 					PERMISSOES |= PERMISSAO_CONSULTAR_PARECER;
995 				}
996 			}
997 		}catch(HibernateException e){
998 			this.logger.error(e);
999 			throw new ECARException(e);
1000 		}
1001     }
1002 	
1003 	/**
1004 	 * Verifica se tem permissao para consultar - valor na variável binaria<br>
1005 	 *      utilizando a operação E ("&")<br>
1006 	 * obs.:  ver método permissoesItem, necessita da sua utilização.<br>
1007 	 * ex.:<br>
1008 	 * ******** 1100<br>
1009 	 * ******& 0110<br>
1010 	 * ********______<br>
1011 	 * ******** 0100<br>
1012 	 * 
1013 	 * @author N/C
1014      * @since N/C
1015      * @version N/C
1016 	 * @return boolean
1017 	 */
1018 	public boolean permissaoConsultarItem() {
1019     	if( ignorarPermissoes ) {
1020     		return true;
1021     	}
1022     	
1023 		if((PERMISSOES & PERMISSAO_CONSULTAR) == PERMISSAO_CONSULTAR)
1024 			return true;
1025 		
1026         return false;
1027     }
1028 	
1029 	public boolean permissaoConsultarParecerItem() {
1030     	if( ignorarPermissoes ) {
1031     		return true;
1032     	}
1033     	
1034 		if((PERMISSOES & PERMISSAO_CONSULTAR_PARECER) == PERMISSAO_CONSULTAR_PARECER)
1035 			return true;
1036 		
1037         return false;
1038     }
1039 	
1040 	
1041 	/**
1042 	 * Verifica se tem permissao para excluir - valor na variável binaria
1043 	 * 	    utilizando a operação E ("&")<br>
1044 	 * obs.:  ver método permissoesItem, necessita da sua utilização.<br>
1045 	 * 
1046 	 * ex.:<br>
1047 	 * ** 1100<br>
1048 	 *& 0110<br>
1049 	 * ** --------<br>
1050 	 * ** 0100<br>
1051 	 * 
1052 	 * @author N/C
1053      * @since N/C
1054      * @version N/C
1055 	 * @return boolean
1056 	 */
1057 	public boolean permissaoExcluirItem() {
1058     	if( ignorarPermissoes ) {
1059     		return true;
1060     	}
1061     	
1062 		if((PERMISSOES & PERMISSAO_EXCLUIR) == PERMISSAO_EXCLUIR)
1063 			return true;
1064 		
1065         return false;
1066     }
1067 
1068 	
1069     /**
1070      * Verificar se o usuario tem permissao de leitura de acompanhamento para um item.<br>
1071      * 
1072      * @author N/C
1073      * @since N/C
1074      * @version N/C
1075      * @param AcompReferenciaItemAri ari
1076      * @param UsuarioUsu usuarioUsu
1077      * @param Set gruposUsuario
1078      * @return boolean
1079      * @throws ECARException
1080      */
1081 	public boolean permissaoLeituraAcompanhamento(AcompReferenciaItemAri ari, UsuarioUsu usuarioUsu, Set gruposUsuario) throws ECARException{
1082 		
1083 		
1084 		try {
1085 	    	if(getIgnorarPermissoes()) {
1086 	    		return true;
1087 	    	}
1088 	    	
1089 			
1090 			String indItemMonitoradosAri = ari.getIndItemMonitoradosAri();
1091 			
1092 			// Mantis: 10511
1093 			//if(!"S".equals(indItemMonitoradosAri)
1094 			//		&& (permissaoAcessoReferenciaOutraSecretaria(gruposUsuario, ari.getItemEstruturaIett().getEstruturaEtt())
1095 			//				|| permissaoAcessoReferenciaSecretaria(gruposUsuario, ari.getItemEstruturaIett().getEstruturaEtt()))) {
1096 				
1097 			//	return true;
1098 			//}
1099 
1100 			//OrgaoOrg orgaoAri = ari.getItemEstruturaIett().getOrgaoOrgByCodOrgaoResponsavel1Iett();
1101 			
1102 			// monitorados de sua responsabilidade:
1103 			// Listar registros de acompanhamento dos itens com indicador de monitorado e em que o usuário esta relacionado
1104 			// com alguma função de acompanhamento para o item (tipo "F" em tb_item_estrutura_usuario_iettus)
1105 			if("S".equals(indItemMonitoradosAri) 
1106 					//&& permissaoLeituraAcompSuaResponsabilidade(gruposUsuario, ari.getItemEstruturaIett().getEstruturaEtt())) {
1107 					){
1108 				Set itensUsuario = ari.getItemEstruturaIett().getItemEstrutUsuarioIettusesByCodIett();
1109 				Iterator it = itensUsuario.iterator();
1110 				while(it.hasNext()){
1111 					ItemEstrutUsuarioIettus ieUsuario = (ItemEstrutUsuarioIettus) it.next();
1112 	
1113 					if(ieUsuario.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_FUNCAO_ACOMPANHAMENTO)
1114 							&& 
1115 							((ieUsuario.getUsuarioUsu() != null && ieUsuario.getUsuarioUsu().equals(usuarioUsu)) || (ieUsuario.getSisAtributoSatb() != null && gruposUsuario.contains(ieUsuario.getSisAtributoSatb())))){
1116 							
1117 						return true;
1118 					}
1119 					
1120 					//Merge feito por Patricia da parte de Davi no Ecar TUR
1121 					// Verifica se o usuário ou o grupo do usuário tem permissão de ler parecer do acompanhamento
1122 					if ((usuarioUsu.equals(ieUsuario.getUsuarioUsu()) || gruposUsuario.contains(ieUsuario.getSisAtributoSatb())) 
1123 							&& "S".equals(ieUsuario.getIndLeituraParecerIettus())){
1124 						
1125 						return true;
1126 					}
1127 				}
1128 			}
1129 			
1130 			//permissão para verificar se o grupo do usuário tem permissão de visualização
1131 			if (permissaoAcessoReferencia(ari.getAcompReferenciaAref().getTipoAcompanhamentoTa(), gruposUsuario)){
1132 				return true;
1133 			}
1134 
1135 			// monitorados de sua secretaria/órgão:
1136 			// Listar registros de acompanhamento dos itens com indicador de monitorado e em que o código do órgão responsável 1 
1137 			// seja o mesmo código do órgão do usuário autenticado (tb_usuario e tb_item_estrutura)
1138 			//if("S".equals(indItemMonitoradosAri) 
1139 			//		&& permissaoLeituraAcompMonitoradoSuaSecretaria(gruposUsuario, ari.getItemEstruturaIett().getEstruturaEtt())
1140 			//		&& (orgaoAri != null && usuarioUsu.getOrgaoOrgs().contains(orgaoAri))) {
1141 			//	
1142 			//	return true;
1143 			//}
1144 			 
1145 			// para sua secretaria/órgão:
1146 			// Listar registros de acompanhamento dos itens sem indicador de monitorado e em que o código do órgão responsável 1 
1147 			// seja o mesmo código do órgão do usuário autenticado (tb_usuario e tb_item_estrutura)
1148 			// Mantis: 10511: Não é mais necessário, já testa no primeiro IF
1149 //			if(!"S".equals(indItemMonitoradosAri)
1150 //					&& permissaoAcessoReferenciaSecretaria(gruposUsuario, ari.getItemEstruturaIett().getEstruturaEtt())
1151 //					&& (orgaoAri != null && usuarioUsu.getOrgaoOrgs().contains(orgaoAri))) {
1152 //				
1153 //				return true;
1154 //			}
1155 			
1156 			// monitorados de outras secretarias/orgãos:
1157 			// Listar registros de acompanhamento dos itens com indicador de monitorado e em que o código do órgão responsável 1 
1158 			// seja diferente do código do órgão do usuário autenticado (tb_usuario e tb_item_estrutura)
1159 			//if("S".equals(indItemMonitoradosAri)
1160 			//		&& permissaoLeituraAcompMonitoradoOutraSecretaria(gruposUsuario, ari.getItemEstruturaIett().getEstruturaEtt())
1161 			//		&& (orgaoAri == null || !usuarioUsu.getOrgaoOrgs().contains(orgaoAri))) {
1162 			//	
1163 			//	return true;
1164 			//}
1165 			
1166 			// para outras secretaria/órgão
1167 			// Listar registros de acompanhamento dos itens sem indicador de monitorado e em que o código do órgão responsável 1 
1168 			// seja diferente do código do órgão do usuário autenticado (tb_usuario e tb_item_estrutura)
1169 			// Mantis: 10511: Não é mais necessário, já testa no primeiro IF
1170 //			if(!"S".equals(indItemMonitoradosAri)
1171 //					&& permissaoAcessoReferenciaOutraSecretaria(gruposUsuario, ari.getItemEstruturaIett().getEstruturaEtt())
1172 //					&& (orgaoAri == null || !usuarioUsu.getOrgaoOrgs().contains(orgaoAri))) {
1173 //				
1174 //				return true;
1175 //			}
1176 			
1177 		}
1178 		catch(Exception e) {
1179 			this.logger.error(e);
1180 			throw new ECARException(e);
1181 		}
1182 
1183 		return false;
1184 	}
1185 
1186     /**
1187      * Verifica se os grupos de acesso possuem permissão de leitura de
1188      * acompanhamento para itens monitorados próprios.<br> 
1189      * 
1190      * @author N/C
1191      * @since N/C
1192      * @version N/C
1193      * @param Set gruposUsuario
1194      * @param EstruturaEtt estrutura
1195      * @return boolean
1196      * @throws ECARException
1197      */
1198     //public boolean permissaoLeituraAcompMonitoradoProprio (Set gruposUsuario, EstruturaEtt estrutura) throws ECARException {
1199     //	if(getIgnorarPermissoes()) {
1200     //		return true;
1201     //	}
1202     //	
1203     //    return new EstruturaAcessoDao(null).temPermissoesLeituraAcompMonitoradoProprio(gruposUsuario, estrutura);
1204     //}
1205 
1206     /**
1207      * Verifica se os grupos de acesso possuem permissão de leitura de 
1208      * acompanhamento para itens monitorados de outras secretarias.<br>
1209      * 
1210      * @author N/C
1211      * @since N/C
1212      * @version N/C
1213      * @param Set gruposUsuario
1214      * @param EstruturaEtt estrutura
1215      * @return boolean
1216      * @throws ECARException
1217      */
1218 //    public boolean permissaoLeituraAcompMonitoradoOutraSecretaria (Set gruposUsuario, EstruturaEtt estrutura) throws ECARException {
1219 //    	if(getIgnorarPermissoes()) {
1220 //    		return true;
1221 //    	}
1222 //    	
1223 //        return new EstruturaAcessoDao(null).temPermissoesLeituraAcompMonitoradoOutraSecretaria(gruposUsuario, estrutura);
1224 //    }
1225 
1226     /**
1227      * Verifica se os grupos de acesso possuem permissão de leitura 
1228      * de acompanhamento para itens monitorados de sua secretaria.<br>
1229      * 
1230      * @author N/C
1231      * @since N/C
1232      * @version N/C
1233      * @param Set gruposUsuario
1234      * @param EstruturaEtt estrutura
1235      * @return boolean
1236      * @throws throws ECARException
1237      */
1238 //    public boolean permissaoLeituraAcompMonitoradoSuaSecretaria (Set gruposUsuario, EstruturaEtt estrutura) throws ECARException {
1239 //    	if(getIgnorarPermissoes()) {
1240 //    		return true;
1241 //    	}
1242 //    	
1243 //        return new EstruturaAcessoDao(null).temPermissoesLeituraAcompMonitoradoSuaSecretaria(gruposUsuario, estrutura);
1244 //    }
1245 
1246     /**
1247      * Verifica se os grupos de acesso possuem permissão de leitura 
1248      * de acompanhamento para itens monitorados de sua responsabilidade.<br>
1249      * 
1250      * @author N/C
1251      * @since N/C
1252      * @version N/C
1253      * @param Set gruposUsuario
1254      * @param EstruturaEtt estrutura
1255      * @return boolean
1256      * @throws ECARException
1257      */
1258 //    public boolean permissaoLeituraAcompSuaResponsabilidade (Set gruposUsuario, EstruturaEtt estrutura) throws ECARException {
1259 //    	if(getIgnorarPermissoes()) {
1260 //    		return true;
1261 //    	}
1262 //    	
1263 //        return new EstruturaAcessoDao(null).temPermissoesLeituraAcompSuaResponsabilidade(gruposUsuario, estrutura);
1264 //    }
1265 
1266     /**
1267      * Retorna boolean ignorarPermissoes.<br>
1268      * 
1269      * @author N/C
1270      * @since N/C
1271      * @version N/C
1272      * @return boolean
1273      */
1274 	public boolean getIgnorarPermissoes() {
1275 		return ignorarPermissoes;
1276 	}
1277 
1278 	/**
1279 	 * Atribui valor especificado para boolean ignorarPermissoes.<br>
1280 	 * 
1281 	 * @author N/C
1282      * @since N/C
1283      * @version N/C
1284 	 * @param boolean ignorarPermissoes
1285 	 */
1286 	private void setIgnorarPermissoes(boolean ignorarPermissoes) {
1287 		this.ignorarPermissoes = ignorarPermissoes;
1288 	}
1289 	
1290 
1291 	/**
1292 	 * Verificar se o item tem permissao.<br>
1293 	 * @param codIett - Codigo do item
1294 	 * @param codUsu - codigo do usuario
1295 	 * @param gruposUsuario - grupos do usuario
1296 	 * @return <true> se tiver permissao 
1297 	 */
1298 	public boolean permissaoConsultaIETT(Long codIett, SegurancaECAR seguranca) throws ECARException {
1299 		
1300 		try{
1301 			StringBuilder query = new StringBuilder(
1302 					"select distinct itemUsuario from ItemEstrutUsuarioIettus itemUsuario" +                
1303 					" where itemUsuario.itemEstruturaIett.codIett = :codIett" +
1304 					" and ( itemUsuario.usuarioUsu.codUsu = :codUsu"
1305 													);
1306 			
1307 			if( seguranca.getGruposAcesso() != null && seguranca.getGruposAcesso().size() > 0) 
1308 				query.append( " or itemUsuario.sisAtributoSatb.codSatb in (:grupos)" ) ;
1309 			
1310 			query.append(" )" );
1311 			
1312 			Query q = new ItemEstrutUsuarioDao(null).getSession().createQuery(query.toString());   
1313 	    	q.setLong("codIett", codIett);
1314 	        q.setLong("codUsu", seguranca.getCodUsu());
1315 	        
1316 	        ArrayList<Long> codSatb = new ArrayList<Long>();
1317 	        if(seguranca.getGruposAcesso() != null && seguranca.getGruposAcesso().size() > 0) {
1318 	        	
1319 	        	for (Iterator itSatb = seguranca.getGruposAcesso().iterator(); itSatb.hasNext();) {
1320 					codSatb.add( ((SisAtributoSatb)itSatb.next()).getCodSatb() );
1321 				}
1322 	        	q.setParameterList("grupos", codSatb);
1323 	        }
1324 			
1325 			if(q.list().iterator().hasNext())
1326 				return true;
1327 
1328 			return false;
1329 			
1330 		}catch(HibernateException e){
1331 			this.logger.error(e);
1332 			throw new ECARException(e);
1333 		}		
1334 	}
1335 	public boolean permissaoConsultaParecerIETT(Long codIett, SegurancaECAR seguranca) throws ECARException {
1336 		
1337 		try{
1338 			StringBuilder query = new StringBuilder(
1339 					"select distinct itemUsuario from ItemEstrutUsuarioIettus itemUsuario" +                
1340 					" where itemUsuario.itemEstruturaIett.codIett = :codIett" +
1341 					" and itemUsuario.indLeituraParecerIettus = :indLeituraParecerIettus" +
1342 					" and ( itemUsuario.usuarioUsu.codUsu = :codUsu"
1343 					);
1344 			
1345 			if( seguranca.getGruposAcesso() != null && seguranca.getGruposAcesso().size() > 0) 
1346 				query.append( " or itemUsuario.sisAtributoSatb.codSatb in (:grupos)" ) ;
1347 			
1348 			query.append(" )" );
1349 			
1350 			Query q = new ItemEstrutUsuarioDao(null).getSession().createQuery(query.toString());   
1351 	    	q.setLong("codIett", codIett);
1352 	        q.setLong("codUsu", seguranca.getCodUsu());
1353 	        q.setString("indLeituraParecerIettus", Pagina.SIM);
1354 	        
1355 	        ArrayList<Long> codSatb = new ArrayList<Long>();
1356 	        if(seguranca.getGruposAcesso() != null && seguranca.getGruposAcesso().size() > 0) {
1357 	        	
1358 	        	for (Iterator itSatb = seguranca.getGruposAcesso().iterator(); itSatb.hasNext();) {
1359 					codSatb.add( ((SisAtributoSatb)itSatb.next()).getCodSatb() );
1360 				}
1361 	        	q.setParameterList("grupos", codSatb);
1362 	        }
1363 			
1364 			return q.list().iterator().hasNext();
1365 			
1366 		}catch(HibernateException e){
1367 			this.logger.error(e);
1368 			throw new ECARException(e);
1369 		}		
1370 	}	
1371 	
1372 	public boolean permissaoConsultaParecerIETTGrupos(Long codIett, Long codTpfa, Long codTa, SegurancaECAR seguranca) throws ECARException {
1373 		boolean permissao = false;
1374 		try{
1375 			StringBuilder query = new StringBuilder(
1376 					"select distinct itemUsuario from ItemEstrutUsuarioIettus itemUsuario" +                
1377 					" where itemUsuario.itemEstruturaIett.codIett = :codIett" +
1378 					" and itemUsuario.indLeituraParecerIettus = :indLeituraParecerIettus" +
1379 					" and ( itemUsuario.usuarioUsu.codUsu = :codUsu"
1380 					);
1381 			
1382 			if( seguranca.getGruposAcesso() != null && seguranca.getGruposAcesso().size() > 0) 
1383 				query.append( " or itemUsuario.sisAtributoSatb.codSatb in (:grupos)" ) ;
1384 			
1385 			query.append(" )" );
1386 			
1387 			Query q = new ItemEstrutUsuarioDao(null).getSession().createQuery(query.toString());   
1388 	    	q.setLong("codIett", codIett);
1389 	        q.setLong("codUsu", seguranca.getCodUsu());
1390 	        q.setString("indLeituraParecerIettus", Pagina.SIM);
1391 	        
1392 	        ArrayList<Long> codSatb = new ArrayList<Long>();
1393 	        if(seguranca.getGruposAcesso() != null && seguranca.getGruposAcesso().size() > 0) {
1394 	        	
1395 	        	for (Iterator itSatb = seguranca.getGruposAcesso().iterator(); itSatb.hasNext();) {
1396 					codSatb.add( ((SisAtributoSatb)itSatb.next()).getCodSatb() );
1397 				}
1398 	        	q.setParameterList("grupos", codSatb);
1399 	        }
1400 			
1401 			permissao = q.list().iterator().hasNext();
1402 			
1403 			
1404 			StringBuilder queryGrupos = new StringBuilder(
1405 					"select distinct taTpfaSatb from TipoAcompTipofuncacompSisatributoTaTpfaSatb taTpfaSatb" +                
1406 					" where taTpfaSatb.tipoFuncAcompTpfa.codTpfa = :codTpfa" +
1407 					" and taTpfaSatb.tipoAcompanhamentoTa.codTa = :codTa" +
1408 					" and taTpfaSatb.indLeituraParecer = :indLeituraParecer"
1409 					);
1410 			
1411 			if( seguranca.getGruposAcesso() != null && seguranca.getGruposAcesso().size() > 0) 
1412 				queryGrupos.append(" and taTpfaSatb.sisAtributoSatb.codSatb in (:grupos)" ) ;
1413 			
1414 			Query qGrupo = new ItemEstrutUsuarioDao(null).getSession().createQuery(queryGrupos.toString());   
1415 	    	qGrupo.setLong("codTpfa", codTpfa);
1416 	    	
1417 	    	if( seguranca.getGruposAcesso() != null && seguranca.getGruposAcesso().size() > 0)
1418 	    		qGrupo.setLong("codTa", codTa);
1419 	    	
1420 	    	qGrupo.setString("indLeituraParecer", Pagina.SIM);
1421 	    	
1422 	        qGrupo.setParameterList("grupos", codSatb);
1423 	        
1424 			
1425 			return permissao || qGrupo.list().iterator().hasNext();			
1426 			
1427 		}catch(HibernateException e){
1428 			this.logger.error(e);
1429 			throw new ECARException(e);
1430 		}		
1431 	}	
1432 	
1433 // Método criado por Robson. Otimização do método acima. Falta testar.	
1434 //	public boolean permissaoConsultaParecerIETTGrupos(Long codIett, Long codTpfa, Long codTa, SegurancaECAR seguranca) throws ECARException {
1435 //		try{
1436 //			StringBuilder query = new StringBuilder(
1437 //					"select distinct itemUsuario from ItemEstrutUsuarioIettus itemUsuario" +                
1438 //					" where itemUsuario.itemEstruturaIett.codIett = :codIett" +
1439 //					" and itemUsuario.indLeituraParecerIettus = :indLeituraParecerIettus" +
1440 //					" and ( itemUsuario.usuarioUsu.codUsu = :codUsu");
1441 //			
1442 //			boolean possuiGrupo = (seguranca.getGruposAcesso() != null && seguranca.getGruposAcesso().size() > 0);
1443 //			
1444 //			if(possuiGrupo) query.append( " or itemUsuario.sisAtributoSatb in (:grupos)");
1445 //			
1446 //			query.append(" )" );
1447 //			
1448 //			Query q = new ItemEstrutUsuarioDao(null).getSession().createQuery(query.toString())   
1449 //							.setMaxResults(1)
1450 //					    	.setLong("codIett", codIett)
1451 //					        .setLong("codUsu", seguranca.getCodUsu())
1452 //					        .setString("indLeituraParecerIettus", Pagina.SIM);
1453 //			
1454 //			if( seguranca.getGruposAcesso() != null && seguranca.getGruposAcesso().size() > 0) 
1455 //	        	q.setParameterList("grupos", seguranca.getGruposAcesso());
1456 //			
1457 //			StringBuilder queryGrupos = new StringBuilder(
1458 //					"select distinct taTpfaSatb from TipoAcompTipofuncacompSisatributoTaTpfaSatb taTpfaSatb" +                
1459 //					" where taTpfaSatb.tipoFuncAcompTpfa.codTpfa = :codTpfa" +
1460 //					" and taTpfaSatb.tipoAcompanhamentoTa.codTa = :codTa" +
1461 //					" and taTpfaSatb.indLeituraParecer = :indLeituraParecer");
1462 //			
1463 //			if(possuiGrupo) queryGrupos.append(" and taTpfaSatb.sisAtributoSatb in (:grupos)" ) ;
1464 //			
1465 //			Query qGrupo = new ItemEstrutUsuarioDao(null).getSession().createQuery(queryGrupos.toString())
1466 //								.setMaxResults(1)
1467 //								.setLong("codTpfa", codTpfa)
1468 //								.setLong("codTa", codTa)
1469 //								.setString("indLeituraParecer", Pagina.SIM);
1470 //	    	
1471 //	    	if(possuiGrupo) qGrupo.setParameterList("grupos", seguranca.getGruposAcesso());
1472 //			
1473 //			return !q.list().isEmpty() || !qGrupo.list().isEmpty();			
1474 //			
1475 //		}catch(HibernateException e){
1476 //			this.logger.error(e);
1477 //			throw new ECARException(e);
1478 //		}		
1479 //	}	
1480 	
1481 	
1482 	/**
1483 	 * @author Robson
1484 	 * @param gruposUsuario
1485 	 * @param tipoAcesso
1486 	 * @return boolean
1487 	 */
1488 	public boolean permissaoAcessoSecretariasUsuario(Set gruposUsuario, int tipoAcesso){
1489 		// XXX: novas funcoes de acesso
1490 		if(this.getIgnorarPermissoes())
1491 			return true;
1492 		else
1493 			return new TipoAcompGrpAcessoDao().permissaoAcessoSecretariasUsuario(gruposUsuario, tipoAcesso); 
1494 	}
1495 	
1496 	/**
1497 	 * 
1498 	 * @param tipoAcompanhamentoTa
1499 	 * @param gruposUsuario
1500 	 * @return boolean
1501 	 * @throws ECARException
1502 	 */
1503 	public boolean permissaoAcessoReferencia(TipoAcompanhamentoTa tipoAcompanhamentoTa, Set gruposUsuario) throws ECARException{
1504     	if(getIgnorarPermissoes()) {
1505     		return true;
1506     	}
1507     	
1508         return new EstruturaAcessoDao(null).temPermissoesAcessoAcomp(tipoAcompanhamentoTa, gruposUsuario);
1509     }
1510 	
1511 	/**
1512 	 * 
1513 	 * @param gruposUsuario
1514 	 * @return boolean
1515 	 * @throws ECARException
1516 	 */
1517 	public boolean permissaoAcessoReferencia(Set gruposUsuario) throws ECARException{
1518     	if(getIgnorarPermissoes()) {
1519     		return true;
1520     	}
1521     	
1522         return new EstruturaAcessoDao(null).temPermissoesAcessoAcomp(gruposUsuario);
1523     }
1524 	
1525 	//
1526 	public boolean permissaoAcessoReferenciaTodosOrgaos(TipoAcompanhamentoTa tipoAcompanhamentoTa, Set gruposUsuario)throws ECARException{
1527     	if(getIgnorarPermissoes()) {
1528     		return true;
1529     	}
1530     	
1531         return new EstruturaAcessoDao(null).temPermissoesAcessoAcompTodosOrgaos(tipoAcompanhamentoTa, gruposUsuario);
1532 	}
1533 	
1534 	//
1535 	public boolean permissaoAcessoReferenciaSeusOrgaos(TipoAcompanhamentoTa tipoAcompanhamentoTa, Set gruposUsuario)throws ECARException{
1536     	if(getIgnorarPermissoes()) {
1537     		return true;
1538     	}
1539     	
1540         return new EstruturaAcessoDao(null).temPermissoesAcessoAcompSeusOrgaos(tipoAcompanhamentoTa, gruposUsuario);
1541 	}
1542 	
1543 	//
1544 	public boolean permissaoAcessoReferenciaOrgaosSuaResponsabilidade(TipoAcompanhamentoTa tipoAcompanhamentoTa, Set gruposUsuario)throws ECARException{
1545     	if(getIgnorarPermissoes()) {
1546     		return true;
1547     	}
1548     	
1549     	return new EstruturaAcessoDao(null).temPermissoesAcessoAcompOrgaosSuaResponsabilidade(tipoAcompanhamentoTa, gruposUsuario);
1550 	}
1551 	
1552 	/**
1553      * Retorna uma lista de TipoFuncAcompTpfa que representa os pareceres que um determinado Grupo pode visualizar em determinado Tipo de acompanhamento
1554      * @param tipoAcompanhamentoTa
1555      * @param grupoPermissaoAcessoSatb
1556      * @return
1557      */
1558     public List permissaoVisualizarPareceres(TipoAcompanhamentoTa tipoAcompanhamentoTa, Set gruposAcessoSatb){
1559 		List retorno = new ArrayList();
1560 	    
1561 		try {
1562 			TipoAcompTipofuncacompSisatributoTaTpfaSatbDao taTpfaSatbDao = new TipoAcompTipofuncacompSisatributoTaTpfaSatbDao();
1563 			retorno = taTpfaSatbDao.pesquisarPermissaoVisualizarParecerTipoFuncaoAcompTpfa(tipoAcompanhamentoTa, gruposAcessoSatb);
1564 		} catch (ECARException e) {
1565 			//Não precisa lançar exceção aqui. Neste caso a lista passada será vazia. 
1566 		}
1567 		
1568 		return retorno;
1569   }	
1570 
1571 }