/*
* Criado em 13/12/2004
*
*/
package ecar.dao;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.math.BigDecimal;
import java.sql.Timestamp;
import java.text.MessageFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.Enumeration;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.collections.map.LinkedMap;
import org.hibernate.Criteria;
import org.hibernate.Hibernate;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.hibernate.type.IntegerType;
import comum.database.Dao;
import comum.util.ConstantesECAR;
import comum.util.Data;
import comum.util.FileUpload;
import comum.util.Mensagem;
import comum.util.Pagina;
import comum.util.Util;
import ecar.action.ActionEstrutura;
import ecar.action.ActionSisAtributo;
import ecar.bean.AtributoEstruturaBean;
import ecar.bean.AtributoEstruturaListagemItens;
import ecar.bean.IndicativoItemWebServiceBean;
import ecar.bean.ItemWSMinBean;
import ecar.bean.ItemWebServiceBean;
import ecar.bean.NomeImgsNivelPlanejamentoBean;
import ecar.bean.OrdenacaoIett;
import ecar.bean.OrdenacaoPorNivel;
import ecar.exception.ECARException;
import ecar.historico.Historico;
import ecar.historico.HistoricoIett;
import ecar.login.SegurancaECAR;
import ecar.permissao.ControlePermissao;
import ecar.permissao.ValidaPermissao;
import ecar.pojo.AcompReferenciaAref;
import ecar.pojo.AcompReferenciaItemAri;
import ecar.pojo.AgendaAge;
import ecar.pojo.AgendaEntidadesAgeent;
import ecar.pojo.AgendaOcorrenciaAgeo;
import ecar.pojo.ApontamentoApt;
import ecar.pojo.AreaAre;
import ecar.pojo.ConfiguracaoCfg;
import ecar.pojo.DestaqueItemRelDtqir;
import ecar.pojo.EfIettFonteTotEfieft;
import ecar.pojo.EstrutTpFuncAcmpEtttfa;
import ecar.pojo.EstruturaAtributoEttat;
import ecar.pojo.EstruturaEtt;
import ecar.pojo.EstruturaFuncaoEttf;
import ecar.pojo.FuncaoFun;
import ecar.pojo.FuncaoSisAtributo;
import ecar.pojo.ItemEstUsutpfuacIettutfa;
import ecar.pojo.ItemEstrUplCategIettuc;
import ecar.pojo.ItemEstrtBenefIettb;
import ecar.pojo.ItemEstrtIndResulCorIettrcor;
import ecar.pojo.ItemEstrtIndResulIettr;
import ecar.pojo.ItemEstrtIndResulLocalIettirl;
import ecar.pojo.ItemEstrutAcaoIetta;
import ecar.pojo.ItemEstrutCriterioIettc;
import ecar.pojo.ItemEstrutEntidadeIette;
import ecar.pojo.ItemEstrutFisicoIettf;
import ecar.pojo.ItemEstrutLocalIettl;
import ecar.pojo.ItemEstrutUploadIettup;
import ecar.pojo.ItemEstrutUsuarioIettus;
import ecar.pojo.ItemEstruturaIett;
import ecar.pojo.ItemEstruturaIettMin;
import ecar.pojo.ItemEstruturaIettPPA;
import ecar.pojo.ItemEstruturaSisAtributoIettSatb;
import ecar.pojo.ItemEstruturaSisAtributoIettSatbPK;
import ecar.pojo.ItemFuncaoLink;
import ecar.pojo.ObjetoEstrutura;
import ecar.pojo.OrgaoOrg;
import ecar.pojo.PaiFilho;
import ecar.pojo.PeriodicidadePrdc;
import ecar.pojo.PontoCriticoPtc;
import ecar.pojo.PontoCriticoSisAtributoPtcSatb;
import ecar.pojo.RegDemandaRegd;
import ecar.pojo.SequenciadoraSeq;
import ecar.pojo.SisAtributoSatb;
import ecar.pojo.SisGrupoAtributoSga;
import ecar.pojo.SituacaoSit;
import ecar.pojo.SubAreaSare;
import ecar.pojo.TipoAcompFuncAcompTafc;
import ecar.pojo.TipoAcompanhamentoTa;
import ecar.pojo.TipoFuncAcompTpfa;
import ecar.pojo.TipoValor;
import ecar.pojo.TipoValorEnum;
import ecar.pojo.UnidadeOrcamentariaUO;
import ecar.pojo.UsuarioUsu;
import ecar.pojo.historico.HistoricoItemEstruturaIett;
import ecar.pojo.historico.HistoricoPontoCriticoPtc;
import ecar.pojo.historico.HistoricoXml;
import ecar.taglib.util.Input;
import ecar.util.Dominios;
import ecar.util.Entidade;
/**
* @author felipev, aleixo
*
*/
public class ItemEstruturaDao extends Dao {
// private List<ItemEstruturaIett> lista = new ArrayList<ItemEstruturaIett>();
//
// public void setLista(List<ItemEstruturaIett> lista) {
// this.lista = lista;
// }
//
// public List<ItemEstruturaIett> getLista() {
// return lista;
// }
/**
* Construtor. Chama o Session factory do Hibernate
* @param request
*/
public ItemEstruturaDao(HttpServletRequest request) {
super();
this.request = request;
}
/**
* Construtor. Utiliza a Session criada para manter uma �nica transa��o
* @param request
* @param session
*/
public ItemEstruturaDao(HttpServletRequest request,Session session) {
super(session);
if (request != null){
this.request = request;
}
}
/**
* Retorna o valor de um atributo em um itemEstrutura
* @param itemEstrutura
* @param nomeAtributo
* @param fkAtributo
* @return
* @throws ECARException
*/
public String getValorAtributoItemEstrutura(
ItemEstruturaIett itemEstrutura, String nomeAtributo,
String fkAtributo) throws ECARException {
try {
Object retorno = Util.invocaGet(itemEstrutura, nomeAtributo);
if (retorno != null) {
if (fkAtributo != null && !"".equals(fkAtributo)) {
retorno = Util.invocaGet(retorno, fkAtributo);
if (retorno != null)
return retorno.toString();
else
return "";
} else {
if (retorno.getClass().equals(Timestamp.class)
|| retorno.getClass().equals(Date.class))
retorno = Data.parseDate((Date) retorno);
return retorno.toString();
}
}
} catch (Exception e) {
}
return "";
}
/**
* Retorna o valor de um atributo em um historicoItemEstruturaIett
* @param historicoItemEstruturaIett
* @param nomeAtributo
* @param fkAtributo
* @return
* @throws ECARException
*/
public String getValorAtributoItemEstrutura(
HistoricoItemEstruturaIett historicoItemEstruturaIett, String nomeAtributo,
String fkAtributo) throws ECARException {
try {
Object retorno = Util.invocaGet(historicoItemEstruturaIett, nomeAtributo);
if (retorno != null) {
if (fkAtributo != null && !"".equals(fkAtributo)) {
retorno = Util.invocaGet(retorno, fkAtributo);
if (retorno != null)
return retorno.toString();
else
return "";
} else {
if (retorno.getClass().equals(Timestamp.class)
|| retorno.getClass().equals(Date.class))
retorno = Data.parseDate((Date) retorno);
return retorno.toString();
}
}
} catch (Exception e) {
}
return "";
}
/**
* Retorna o usu�rio associoado a uma fun��o de acompanhamento em um itemEstrutura
* @param itemEstrutura
* @param funAcomp
* @return
* @throws ECARException
*/
public UsuarioUsu getValorFunAcompItemEstrutura(ItemEstruturaIett itemEstrutura, TipoFuncAcompTpfa funAcomp) throws ECARException{
ItemEstUsutpfuacIettutfa ieUsuTf = new ItemEstUsutpfuacIettutfa();
ieUsuTf.setItemEstruturaIett(itemEstrutura);
ieUsuTf.setTipoFuncAcompTpfa(funAcomp);
try{
List result = this.pesquisar(ieUsuTf, null);
if( result != null){
for (Iterator it = result.iterator(); it.hasNext();) {
ItemEstUsutpfuacIettutfa element = (ItemEstUsutpfuacIettutfa) it.next();
return element.getUsuarioUsu();
}
return null;
} else {
return null;
}
} catch(ECARException e){
this.logger.error(e);
return null;
}
}
/**
* Retorna o usu�rio associoado a uma fun��o de acompanhamento em um historicoItemEstruturaIett
* @param historicoItemEstruturaIett
* @param funAcomp
* @return
* @throws ECARException
*/
@SuppressWarnings("empty-statement")
public UsuarioUsu getValorFunAcompItemEstrutura(HistoricoItemEstruturaIett historicoItemEstruturaIett, TipoFuncAcompTpfa funAcomp) throws ECARException{
try{
Set result = historicoItemEstruturaIett.getItemEstUsutpfuacIettutfas();;
if( result != null){
for (Iterator it = result.iterator(); it.hasNext();) {
ItemEstUsutpfuacIettutfa element = (ItemEstUsutpfuacIettutfa) it.next();
if (element.getTipoFuncAcompTpfa().equals(funAcomp)){
return element.getUsuarioUsu();
}
}
return null;
} else {
return null;
}
} catch(Exception e){
this.logger.error(e);
return null;
}
}
/**
* Retorna o SisAtributoSatb associado a uma fun��o de acompanhamento em um itemEstrutura
* @param itemEstrutura
* @param funAcomp
* @return
* @throws ECARException
*/
public SisAtributoSatb getValorSatbFunAcompItemEstrutura(ItemEstruturaIett itemEstrutura, TipoFuncAcompTpfa funAcomp) throws ECARException{
ItemEstUsutpfuacIettutfa ieUsuTf = new ItemEstUsutpfuacIettutfa();
ieUsuTf.setItemEstruturaIett(itemEstrutura);
ieUsuTf.setTipoFuncAcompTpfa(funAcomp);
try{
List result = this.pesquisar(ieUsuTf, null);
if( result != null){
for (Iterator it = result.iterator(); it.hasNext();) {
ItemEstUsutpfuacIettutfa element = (ItemEstUsutpfuacIettutfa) it.next();
return element.getSisAtributoSatb();
}
return null;
} else {
return null;
}
} catch(ECARException e){
this.logger.error(e);
return null;
}
}
/**
* Retorna o SisAtributoSatb associado a uma fun��o de acompanhamento em um historicoItemEstruturaIett
* @param historicoItemEstruturaIett
* @param funAcomp
* @return
* @throws ECARException
*/
public SisAtributoSatb getValorSatbFunAcompItemEstrutura(HistoricoItemEstruturaIett historicoItemEstruturaIett, TipoFuncAcompTpfa funAcomp) throws ECARException{
try{
Set result = historicoItemEstruturaIett.getItemEstUsutpfuacIettutfas();
if( result != null){
for (Iterator it = result.iterator(); it.hasNext();) {
ItemEstUsutpfuacIettutfa element = (ItemEstUsutpfuacIettutfa) it.next();
if (element.getTipoFuncAcompTpfa().equals(funAcomp)){
return element.getSisAtributoSatb();
}
}
return null;
} else {
return null;
}
} catch(Exception e){
this.logger.error(e);
return null;
}
}
/**
* Cria um objeto ItemEstruturaIett a partir de par�metros passados no
* objeto request
*
* @param request
* @param itemEstrutura
* @throws ECARException
*/
public void setItemEstrutura(HttpServletRequest request, ItemEstruturaIett itemEstrutura) throws ECARException {
// Verifica se o planejamento est� bloqueado
Boolean planejamentoBloqueado = false;
if (itemEstrutura.getIndBloqPlanejamentoIett() != null &&
itemEstrutura.getIndBloqPlanejamentoIett().equals("S")) {
planejamentoBloqueado = true;
}
// SegurancaECAR seg = (SegurancaECAR)request.getSession().getAttribute("seguranca");
// List funcoesDoUsuario = (new TipoFuncAcompDao(null)).getFuncoesAcompNaEstruturaDoUsuario(itemEstrutura , seg.getUsuario(), seg.getGruposAcesso());
// Define os atributos que s�o independentes de o planejamento estar bloqueado
itemEstrutura.setDataUltManutencaoIett(Data.getDataAtual());
if (!"".equals(Pagina.getParamStr(request, "codIettPai"))) {
itemEstrutura.setItemEstruturaIett((ItemEstruturaIett) this.buscar(ItemEstruturaIett.class, Long.valueOf(Pagina.getParamStr(request, "codIettPai"))));
}
if (!"".equals(Pagina.getParamStr(request, "codIett"))) {
itemEstrutura.setCodIett(Long.valueOf(Pagina.getParamStr(request, "codIett")));
}
//TODO Para ser Testado
if (Pagina.getParamStr(request, "codEtt") != null && !Pagina.getParamStr(request, "codEtt").equals(Dominios.STRING_VAZIA)) {
itemEstrutura.setEstruturaEtt((EstruturaEtt) new EstruturaDao(request).buscar(EstruturaEtt.class, Long.valueOf(Pagina.getParamStr(request, "codEtt"))));
} else {
itemEstrutura.setEstruturaEtt((EstruturaEtt) new EstruturaDao(request).buscar(EstruturaEtt.class, Long.valueOf(Pagina.getParamStr(request, "itemEstrutura"))));
}
itemEstrutura.setIndAtivoIett(Pagina.SIM);
// hint de desempenho. J� diz a qual nivel o item pertence.
itemEstrutura.setNivelIett(Integer.valueOf(getNivel(itemEstrutura)));
SegurancaECAR seg = (SegurancaECAR)request.getSession().getAttribute("seguranca");
List funcoesDoUsuario = (new TipoFuncAcompDao(null)).getFuncoesAcompNaEstruturaDoUsuario(itemEstrutura , seg.getUsuario(), seg.getGruposAcesso());
// Busca a lista de atributos definidos para estrutura. Est� lista � necess�ria para saber
// se, no caso do planejamento estar bloqueado, o atributo pode ou n�o ser alterado.
// No caso de o planejamento n�o estar bloqueado ou ser a inser��o de um novo item,
// n�o faz diferen�a.
List atributos = new ArrayList();
EstruturaDao estruturaDao = new EstruturaDao(request);
EstruturaEtt estrutura = itemEstrutura.getEstruturaEtt();
atributos = estruturaDao.getAtributosEstruturaDadosGerais(estrutura);
// Realiza itera��o entre todos os atributos configurados na estrutura.
Iterator it = atributos.iterator();
while(it.hasNext()) {
ObjetoEstrutura element = (ObjetoEstrutura) it.next();
// Verifica se o atritubo � "siglaIett".
if (element.iGetNome().equals("siglaIett")) {
// Verifica se o planejamento n�o est� bloqueado ou se, caso bloqueado, o campo n�o est�
// bloqueado. Satisfeito estas condi��es, o atributo pode ser definido.
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario ) ) {
if("".equals(Pagina.getParamStr(request, "siglaIett"))) {
itemEstrutura.setSiglaIett(null);
} else {
itemEstrutura.setSiglaIett(Pagina.getParamStr(request, "siglaIett"));
}
} else {
}
} else if (element.iGetNome().equals("nomeIett")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
itemEstrutura.setNomeIett(Pagina.getParamStr(request, "nomeIett"));
}
} else if (element.iGetNome().equals("descricaoIett")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
itemEstrutura.setDescricaoIett(Pagina.getParamStr(request, "descricaoIett"));
}
} else if (element.iGetNome().equals("origemIett")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario )) {
itemEstrutura.setOrigemIett(Pagina.getParamStr(request, "origemIett"));
}
} else if (element.iGetNome().equals("indAtivoIett")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario)) {
String indAtivo = Pagina.getParamStr(request, "indAtivoIett");
if("".equals(indAtivo.trim())) {
indAtivo = "S";
}
itemEstrutura.setIndAtivoIett(indAtivo);
}
} else if (element.iGetNome().equals("indMonitoramentoIett")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
String indMonitoramento = Pagina.getParamStr(request, "indMonitoramentoIett");
if("".equals(indMonitoramento.trim())) {
indMonitoramento = "N";
}
itemEstrutura.setIndMonitoramentoIett(indMonitoramento);
}
} else if (element.iGetNome().equals("indBloqPlanejamentoIett")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
String indBloqPlanejamento = Pagina.getParamStr(request, "indBloqPlanejamentoIett");
if("".equals(indBloqPlanejamento.trim())) {
indBloqPlanejamento = "N";
}
itemEstrutura.setIndBloqPlanejamentoIett(indBloqPlanejamento);
}
} else if (element.iGetNome().equals("objetivoGeralIett")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
itemEstrutura.setObjetivoGeralIett(Pagina.getParamStr(request, "objetivoGeralIett"));
}
} else if (element.iGetNome().equals("objetivoEspecificoIett")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
itemEstrutura.setObjetivoEspecificoIett(Pagina.getParamStr(request, "objetivoEspecificoIett"));
}
} else if (element.iGetNome().equals("beneficiosIett")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
itemEstrutura.setBeneficiosIett(Pagina.getParamStr(request, "beneficiosIett"));
}
} else if (element.iGetNome().equals("dataInicioIett")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
if (!"".equals(Pagina.getParamStr(request, "dataInicioIett"))) {
itemEstrutura.setDataInicioIett(Pagina.getParamDataBanco(request, "dataInicioIett"));
} else {
itemEstrutura.setDataInicioIett(null);
}
}
} else if (element.iGetNome().equals("dataTerminoIett")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
if (!"".equals(Pagina.getParamStr(request, "dataTerminoIett"))) {
itemEstrutura.setDataTerminoIett(Pagina.getParamDataBanco(request, "dataTerminoIett"));
} else {
itemEstrutura.setDataTerminoIett(null);
}
}
} else if (element.iGetNome().equals("areaAre")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
if (!"".equals(Pagina.getParamStr(request, "areaAre"))) {
itemEstrutura.setAreaAre((AreaAre) new AreaDao(request).buscar(AreaAre.class, Long.valueOf(Pagina.getParamStr(request, "areaAre"))));
} else {
itemEstrutura.setAreaAre(null);
}
}
} else if (element.iGetNome().equals("subAreaSare")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
if (!"".equals(Pagina.getParamStr(request, "subAreaSare"))) {
itemEstrutura.setSubAreaSare((SubAreaSare) new SubAreaDao(request).buscar(SubAreaSare.class, Long.valueOf(Pagina.getParamStr(request, "subAreaSare"))));
} else {
itemEstrutura.setSubAreaSare(null);
}
}
} else if (element.iGetNome().equals("unidadeOrcamentariaUO")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
if (!"".equals(Pagina.getParamStr(request, "unidadeOrcamentariaUO"))) {
itemEstrutura.setUnidadeOrcamentariaUO((UnidadeOrcamentariaUO) new UnidadeOrcamentariaDao(request).buscar(UnidadeOrcamentariaUO.class, Long.valueOf(Pagina.getParamStr(request, "unidadeOrcamentariaUO"))));
} else {
itemEstrutura.setUnidadeOrcamentariaUO(null);
}
}
} else if (element.iGetNome().equals("orgaoOrgByCodOrgaoResponsavel1Iett")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
if (!"".equals(Pagina.getParamStr(request,"orgaoOrgByCodOrgaoResponsavel1Iett"))) {
itemEstrutura.setOrgaoOrgByCodOrgaoResponsavel1Iett((OrgaoOrg) new OrgaoDao(request).buscar(OrgaoOrg.class,Long
.valueOf(Pagina.getParamStr(request, "orgaoOrgByCodOrgaoResponsavel1Iett"))));
} else {
itemEstrutura.setOrgaoOrgByCodOrgaoResponsavel1Iett(null);
}
}
} else if (element.iGetNome().equals("orgaoOrgByCodOrgaoResponsavel2Iett")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
if (!"".equals(Pagina.getParamStr(request,"orgaoOrgByCodOrgaoResponsavel2Iett"))) {
itemEstrutura.setOrgaoOrgByCodOrgaoResponsavel2Iett((OrgaoOrg) new OrgaoDao(request).buscar(OrgaoOrg.class,Long
.valueOf(Pagina.getParamStr(request, "orgaoOrgByCodOrgaoResponsavel2Iett"))));
} else{
itemEstrutura.setOrgaoOrgByCodOrgaoResponsavel2Iett(null);
}
}
} else if (element.iGetNome().equals("periodicidadePrdc")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
if (!"".equals(Pagina.getParamStr(request, "periodicidadePrdc"))) {
itemEstrutura.setPeriodicidadePrdc((PeriodicidadePrdc) new PeriodicidadeDao(request).buscar(PeriodicidadePrdc.class, Long.valueOf(Pagina.getParamStr(request, "periodicidadePrdc"))));
} else {
itemEstrutura.setPeriodicidadePrdc(null);
}
}
} else if (element.iGetNome().equals("indCriticaIett")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
String indCritica = Pagina.getParamStr(request,"indCriticaIett");
if (Dominios.STRING_VAZIA.equals(indCritica.trim())) {
itemEstrutura.setIndCriticaIett(null);
} else {
itemEstrutura.setIndCriticaIett(indCritica);
}
}
} else if (element.iGetNome().equals("indModeloIett")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
String indModelo = Pagina.getParamStr(request,"indModeloIett");
if (Dominios.STRING_VAZIA.equals(indModelo.trim())) {
itemEstrutura.setIndModeloIett(null);
} else {
itemEstrutura.setIndModeloIett(indModelo);
}
}
} else if (element.iGetNome().equals("valPrevistoFuturoIett")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
if (!"".equals(Pagina.getParamStr(request, "valPrevistoFuturoIett"))) {
itemEstrutura.setValPrevistoFuturoIett(new BigDecimal(Double.valueOf(Util.formataNumero(Pagina.getParamStr(request, "valPrevistoFuturoIett"))).doubleValue()));
} else {
itemEstrutura.setValPrevistoFuturoIett(null);
}
}
} else if (element.iGetNome().equals("dataR1")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
if (!"".equals(Pagina.getParamStr(request, "dataR1"))) {
itemEstrutura.setDataR1(Pagina.getParamDataBanco(request, "dataR1"));
} else {
itemEstrutura.setDataR1(null);
}
}
} else if (element.iGetNome().equals("dataR2")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
if (!"".equals(Pagina.getParamStr(request, "dataR2"))) {
itemEstrutura.setDataR2(Pagina.getParamDataBanco(request, "dataR2"));
} else {
itemEstrutura.setDataR2(null);
}
}
} else if (element.iGetNome().equals("dataR3")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
if (!"".equals(Pagina.getParamStr(request, "dataR3"))) {
itemEstrutura.setDataR3(Pagina.getParamDataBanco(request, "dataR3"));
} else {
itemEstrutura.setDataR3(null);
}
}
} else if (element.iGetNome().equals("dataR4")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
if (!"".equals(Pagina.getParamStr(request, "dataR4"))) {
itemEstrutura.setDataR4(Pagina.getParamDataBanco(request, "dataR4"));
} else {
itemEstrutura.setDataR4(null);
}
}
} else if (element.iGetNome().equals("dataR5")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
if (!"".equals(Pagina.getParamStr(request, "dataR5"))) {
itemEstrutura.setDataR5(Pagina.getParamDataBanco(request, "dataR5"));
} else {
itemEstrutura.setDataR5(null);
}
}
} else if (element.iGetNome().equals("descricaoR1")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
itemEstrutura.setDescricaoR1(Pagina.getParamStr(request, "descricaoR1"));
}
} else if (element.iGetNome().equals("descricaoR2")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
itemEstrutura.setDescricaoR2(Pagina.getParamStr(request, "descricaoR2"));
}
} else if (element.iGetNome().equals("descricaoR3")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
itemEstrutura.setDescricaoR3(Pagina.getParamStr(request, "descricaoR3"));
}
} else if (element.iGetNome().equals("descricaoR4")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
itemEstrutura.setDescricaoR4(Pagina.getParamStr(request, "descricaoR4"));
}
} else if (element.iGetNome().equals("descricaoR5")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
itemEstrutura.setDescricaoR5(Pagina.getParamStr(request, "descricaoR5"));
}
} else if (element.iGetNome().equals("situacaoSit")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
if(!"".equals(Pagina.getParamStr(request, "situacaoSit"))){
String codSit = Pagina.getParamStr(request, "situacaoSit");
itemEstrutura.setSituacaoSit((SituacaoSit)new SituacaoDao(null).buscar(SituacaoSit.class, Long.valueOf(codSit)));
} else {
itemEstrutura.setSituacaoSit(null);
}
}
} else if (element.iGetNome().equals("nivelPlanejamento")) {
if (!planejamentoBloqueado || (planejamentoBloqueado && !element.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, element, funcoesDoUsuario) ) {
itemEstrutura.setItemEstruturaNivelIettns(new HashSet());
ConfiguracaoDao configuracaoDao = new ConfiguracaoDao(request);
String campoNivelPlanejamento = "a" + configuracaoDao.getConfiguracao().getSisGrupoAtributoSgaByCodSgaGrAtrNvPlan().getCodSga().toString();
if(request.getParameterValues(campoNivelPlanejamento) != null){
String[] atributosLivres = request.getParameterValues(campoNivelPlanejamento);
for(int i = 0; i < atributosLivres.length; i++) {
if (!atributosLivres[i].equals("")) {
itemEstrutura.getItemEstruturaNivelIettns().add( this.buscar(SisAtributoSatb.class, Long.valueOf(atributosLivres[i])));
}
}
}
}
}
}
// Define as Fun��es de acompanhamentos.
setFuncoesAcompanhamentoItemEstrutura(request, itemEstrutura);
}
/**
* Devolve um int indicando em qual n�vel da hierarquia de itens o Item se encontra
* @param itemEstrutura
* @return
* @throws ECARException
*/
private int getNivel(ItemEstruturaIett itemEstrutura) throws ECARException {
int nivel = 1;
while (itemEstrutura.getItemEstruturaIett() != null) {
itemEstrutura = itemEstrutura.getItemEstruturaIett();
nivel++;
}
return nivel;
}
/**
* Seta os atributos livres vindos do request para um itemEstrutura
*
* @author aleixo
* @since 28/05/2007
* @param request
* @param itemEstrutura
* @throws ECARException
*/
private List getAtributosLivresItemEstrutura(HttpServletRequest request, ItemEstruturaIett itemEstrutura) throws ECARException {
Boolean planejamentoBloqueado = false;
if (itemEstrutura.getIndBloqPlanejamentoIett() != null &&
itemEstrutura.getIndBloqPlanejamentoIett().equals("S")) {
planejamentoBloqueado = true;
}
SegurancaECAR seg = (SegurancaECAR)request.getSession().getAttribute("seguranca");
List funcoesDoUsuario = (new TipoFuncAcompDao(null)).getFuncoesAcompNaEstruturaDoUsuario(itemEstrutura , seg.getUsuario(), seg.getGruposAcesso());
/*
* Obter o c�digo do grupo do atributo livre para pegar pelo campo "a" + codSga;
*/
FuncaoDao funcaoDao = new FuncaoDao(request );
FuncaoFun funcao = funcaoDao.getFuncaoDadosGerais();
List sgas = new ArrayList();
if(itemEstrutura.getEstruturaEtt() != null && itemEstrutura.getEstruturaEtt().getEstruturaAtributoEttats() != null && !itemEstrutura.getEstruturaEtt().getEstruturaAtributoEttats().isEmpty()){
for(Iterator it = itemEstrutura.getEstruturaEtt().getEstruturaAtributoEttats().iterator(); it.hasNext();){
EstruturaAtributoEttat ettat = (EstruturaAtributoEttat) it.next();
if(ettat.getAtributosAtb() != null && ettat.getAtributosAtb().getSisGrupoAtributoSga() != null){
if ((ettat.getAtributosAtb().getFuncaoFun().equals(funcao)) &&
(!planejamentoBloqueado ||
(planejamentoBloqueado && !ettat.iGetBloqueado()) ||
podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, ettat, funcoesDoUsuario)) ) {
sgas.add(ettat.getAtributosAtb().getSisGrupoAtributoSga());
}
}
}
}
List atributosLivres = new ArrayList();
//Percorrer grupo de atributos para selecionar os atributos livres...
for(Iterator it = sgas.iterator(); it.hasNext();){
SisGrupoAtributoSga grupoAtributo = (SisGrupoAtributoSga) it.next();
String nomeCampo = "a" + grupoAtributo.getCodSga().toString();
String tipoCampo = grupoAtributo.getSisTipoExibicGrupoSteg().getCodSteg().toString();
//Se for CheckBox ou RadioButton ou ListBox, n�o gravar InformacaoIettSatb
//Alterado por Jos� Andr� Fernandes, foi acrescentado ListBox
if(tipoCampo.equals(SisTipoExibicGrupoDao.CHECKBOX) || tipoCampo.equals(SisTipoExibicGrupoDao.LISTBOX)){
String[] atributos = request.getParameterValues(nomeCampo);
int numAtributos = 0;
if (atributos != null) {
numAtributos = atributos.length;
}
for(int i = 0; i < numAtributos; i++){
//N�o seto todos os outros campos, pois eles ser�o setados depois de gravar o item.
ItemEstruturaSisAtributoIettSatb atributoLivre = new ItemEstruturaSisAtributoIettSatb();
atributoLivre.setDataUltManutencao(Data.getDataAtual());
atributoLivre.setUsuarioUsu(((ecar.login.SegurancaECAR) request.getSession().getAttribute("seguranca")).getUsuario());
atributoLivre.setItemEstruturaIett(itemEstrutura);
atributoLivre.setSisAtributoSatb((SisAtributoSatb) this.buscar(SisAtributoSatb.class, Long.valueOf(atributos[i])));
atributoLivre.setFuncao(funcao);
atributoLivre.atribuirPKPai();
atributosLivres.add(atributoLivre);
}
}
//Se for Radio Button...
else if(tipoCampo.equals(SisTipoExibicGrupoDao.RADIO_BUTTON) || tipoCampo.equals(SisTipoExibicGrupoDao.COMBOBOX)){
if(!"".equals(Pagina.getParamStr(request, nomeCampo))){
//N�o seto todos os outros campos, pois eles ser�o setados depois de gravar o item.
ItemEstruturaSisAtributoIettSatb atributoLivre = new ItemEstruturaSisAtributoIettSatb();
atributoLivre.setDataUltManutencao(Data.getDataAtual());
atributoLivre.setUsuarioUsu(((ecar.login.SegurancaECAR) request.getSession().getAttribute("seguranca")).getUsuario());
atributoLivre.setItemEstruturaIett(itemEstrutura);
atributoLivre.setSisAtributoSatb((SisAtributoSatb) this.buscar(SisAtributoSatb.class, Long.valueOf(Pagina.getParamStr(request, nomeCampo))));
atributoLivre.setFuncao(funcao);
atributoLivre.atribuirPKPai();
atributosLivres.add(atributoLivre);
}
}
//Se for TEXT Field
else if (tipoCampo.equals(SisTipoExibicGrupoDao.TEXT) || tipoCampo.equals(SisTipoExibicGrupoDao.TEXTAREA)) {
// System.out.println(Pagina.getParamStr(request, atributosLivres));
if(!"".equals(Pagina.getParamStr(request, nomeCampo))){
//N�o seto todos os outros campos, pois eles ser�o setados depois de gravar o item.
ItemEstruturaSisAtributoIettSatb atributoLivre = new ItemEstruturaSisAtributoIettSatb();
atributoLivre.setDataUltManutencao(Data.getDataAtual());
atributoLivre.setUsuarioUsu(((ecar.login.SegurancaECAR) request.getSession().getAttribute("seguranca")).getUsuario());
atributoLivre.setItemEstruturaIett(itemEstrutura);
atributoLivre.setSisAtributoSatb((SisAtributoSatb) grupoAtributo.getSisAtributoSatbs().iterator().next());
atributoLivre.setInformacao(Pagina.getParamStr(request, nomeCampo));
atributoLivre.setFuncao(funcao);
atributoLivre.atribuirPKPai();
atributosLivres.add(atributoLivre);
}
} else if (tipoCampo.equals(SisTipoExibicGrupoDao.IMAGEM)) {
if(!"".equals(Pagina.getParamStr(request, nomeCampo))){
String pathRaiz = request.getContextPath();
//N�o seto todos os outros campos, pois eles ser�o setados depois de gravar o item.
ItemEstruturaSisAtributoIettSatb atributoLivre = new ItemEstruturaSisAtributoIettSatb();
atributoLivre.setDataUltManutencao(Data.getDataAtual());
atributoLivre.setUsuarioUsu(((ecar.login.SegurancaECAR) request.getSession().getAttribute("seguranca")).getUsuario());
atributoLivre.setItemEstruturaIett(itemEstrutura);
atributoLivre.setSisAtributoSatb((SisAtributoSatb) grupoAtributo.getSisAtributoSatbs().iterator().next());
atributoLivre.setInformacao(Pagina.getParamStr(request, nomeCampo));
atributoLivre.setFuncao(funcao);
atributoLivre.atribuirPKPai();
// tratamento imagem
String caminhoAuxiliarImagem = Pagina.getParamStr(request, "hidImagem" + "a"
+ grupoAtributo.getCodSga().toString());
if (caminhoAuxiliarImagem!=null && caminhoAuxiliarImagem.length()>0) {
String chave = atributoLivre.getInformacao();
chave = chave.substring(chave.indexOf("RemoteFile=")+ "RemoteFile=".length());
UsuarioUsu usuario = ((ecar.login.SegurancaECAR)request.getSession().getAttribute("seguranca")).getUsuario();
if(usuario.getMapArquivosAtuaisUsuarios() != null && usuario.getMapArquivosAtuaisUsuarios().containsKey(chave)){
// atributoLivre.setInformacao(usuario.getMapArquivosAtuaisUsuarios().get(chave));
caminhoAuxiliarImagem = usuario.getMapArquivosAtuaisUsuarios().get(chave);
caminhoAuxiliarImagem = pathRaiz +"/DownloadFile?RemoteFile=" + caminhoAuxiliarImagem;
}
// else{
// salvar a imagem fisicamente que tem o caminho real em "hidImagem"
try {
String nomeArquivoNovo = FileUpload.salvarArquivoSessaoFisicamente(request, "a" + grupoAtributo.getCodSga().toString(), caminhoAuxiliarImagem);
if(nomeArquivoNovo != null && !nomeArquivoNovo.equals(""))
atributoLivre.setInformacao(nomeArquivoNovo);
} catch (FileNotFoundException e) {
throw new ECARException("erro.arquivoUrl",e, new String[]{caminhoAuxiliarImagem});
} catch (Exception e) {
throw new ECARException("erro.upload",e, new String[]{caminhoAuxiliarImagem});
}
// }
}
atributosLivres.add(atributoLivre);
}
} else if (tipoCampo.equals(SisTipoExibicGrupoDao.MULTITEXTO)) {
Enumeration lAtrib = request.getParameterNames();
while (lAtrib.hasMoreElements()) {
String atrib = (String) lAtrib.nextElement();
if (atrib.lastIndexOf('_') > 0) {
//System.out.println("nomeatributo" + atrib);
String nomeAtrib = atrib.substring(0, atrib
.lastIndexOf('_'));
String codSisAtrib = atrib.substring(atrib
.lastIndexOf('_') + 1);
nomeCampo = "a" + grupoAtributo.getCodSga().toString()+"_"+codSisAtrib;
if (nomeAtrib.equals("a"+ grupoAtributo.getCodSga().toString())
&& !"".equals(Pagina.getParamStr(request,atrib))) {
ItemEstruturaSisAtributoIettSatb atributoLivre = new ItemEstruturaSisAtributoIettSatb();
atributoLivre.setDataUltManutencao(Data.getDataAtual());
atributoLivre.setUsuarioUsu(((ecar.login.SegurancaECAR) request.getSession().getAttribute("seguranca")).getUsuario());
atributoLivre.setItemEstruturaIett(itemEstrutura);
atributoLivre.setSisAtributoSatb((SisAtributoSatb) this.buscar(SisAtributoSatb.class, Long.valueOf(codSisAtrib)));
atributoLivre.setInformacao(Pagina.getParamStr(request, nomeCampo));
atributoLivre.setFuncao(funcao);
atributoLivre.atribuirPKPai();
atributosLivres.add(atributoLivre);
}
}
}
} else if (tipoCampo.equals(SisTipoExibicGrupoDao.VALIDACAO)) {
SisAtributoSatb sisAtributoSatb = (SisAtributoSatb)grupoAtributo.getSisAtributoSatbs().iterator().next();
//Eh verdadeiro se o conteudo do atributo livre for diferente de branco ou se o tipo de valida��o for igual as descritas abaixo.
if(!(Pagina.getParamStr(request, nomeCampo).equals(Dominios.STRING_VAZIA)) ||
(sisAtributoSatb.isAtributoAutoIcremental()) ||
(sisAtributoSatb.isAtributoContemMascara())) {
//N�o seto todos os outros campos, pois eles ser�o setados depois de gravar o item.
ItemEstruturaSisAtributoIettSatb atributoLivre = new ItemEstruturaSisAtributoIettSatb();
atributoLivre.setDataUltManutencao(Data.getDataAtual());
atributoLivre.setUsuarioUsu(((ecar.login.SegurancaECAR) request.getSession().getAttribute("seguranca")).getUsuario());
atributoLivre.setItemEstruturaIett(itemEstrutura);
atributoLivre.setSisAtributoSatb((SisAtributoSatb) grupoAtributo.getSisAtributoSatbs().iterator().next());
atributoLivre.setInformacao(Pagina.getParamStr(request, nomeCampo));
atributoLivre.setFuncao(funcao);
atributoLivre.atribuirPKPai();
atributosLivres.add(atributoLivre);
}
}
}
return atributosLivres;
}
/**
* Adiciona elementos � cole��o de Fun��es de Acompanhamento de um
* ItemEstrutura
*
* @param request
* @param itemEstrutura
* @throws ECARException
*/
public void setFuncoesAcompanhamentoItemEstrutura(HttpServletRequest request, ItemEstruturaIett itemEstrutura) throws ECARException {
// Verifica se o planejamento est� bloqueado
Boolean planejamentoBloqueado = false;
if (itemEstrutura.getIndBloqPlanejamentoIett() != null &&
itemEstrutura.getIndBloqPlanejamentoIett().equals("S")) {
planejamentoBloqueado = true;
}
/* obtem as funcoes de acompanhamento exercidas pelo usuario*/
SegurancaECAR seg = (SegurancaECAR)request.getSession().getAttribute("seguranca");
List funcoesDoUsuario = (new TipoFuncAcompDao(null)).getFuncoesAcompNaEstruturaDoUsuario(itemEstrutura , seg.getUsuario(), seg.getGruposAcesso());
//Limpa a collection
itemEstrutura.setItemEstUsutpfuacIettutfas(new HashSet());
// Descobre a Estrutura do item
EstruturaEtt estrutura = itemEstrutura.getEstruturaEtt();
// Descobre as fun��es de acompanhamento de uma estrutura
Set funcoesAcomp = estrutura.getEstrutTpFuncAcmpEtttfas();
// Itera pelas fun��es buscando no request o valor passado.
if (funcoesAcomp != null) {
for (Iterator it = funcoesAcomp.iterator(); it.hasNext();) {
EstrutTpFuncAcmpEtttfa funcao = (EstrutTpFuncAcmpEtttfa) it.next();
if (!planejamentoBloqueado || (planejamentoBloqueado && !funcao.iGetBloqueado()) || podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, funcao, funcoesDoUsuario) ) {
if (!"".equals(Pagina.getParamStr(request, "Fun" + funcao.getTipoFuncAcompTpfa().getCodTpfa()))) {
ItemEstUsutpfuacIettutfa funcaoItemEstrutura = new ItemEstUsutpfuacIettutfa();
funcaoItemEstrutura.setItemEstruturaIett(itemEstrutura);
funcaoItemEstrutura.setTipoFuncAcompTpfa(funcao.getTipoFuncAcompTpfa());
if (Pagina.getParamStr(request, "Fun" + funcao.getTipoFuncAcompTpfa().getCodTpfa()).startsWith("U")){
funcaoItemEstrutura.setUsuarioUsu((UsuarioUsu) this.buscar(UsuarioUsu.class, Long.valueOf(Pagina.getParamStr(request, "Fun" + funcao.getTipoFuncAcompTpfa().getCodTpfa()).substring(1))));
}
else if (Pagina.getParamStr(request, "Fun" + funcao.getTipoFuncAcompTpfa().getCodTpfa()).startsWith("G")){
funcaoItemEstrutura.setSisAtributoSatb((SisAtributoSatb) this.buscar(SisAtributoSatb.class, Long.valueOf(Pagina.getParamStr(request, "Fun" + funcao.getTipoFuncAcompTpfa().getCodTpfa()).substring(1))));
}
itemEstrutura.getItemEstUsutpfuacIettutfas().add(funcaoItemEstrutura);
}
}
}
}
}
/**
* Salva um registro de itemEstrutura. Salva � parte os item-estrutura-funcao-tipo-acomp
* devido a chave composta. (que deve ser setada depois de gravar o item)
*
* Provenientes da view(jsp)
*
* @param request
* @param itemEstrutura
* @param funcao
* @throws ECARException
*/
@SuppressWarnings("unchecked")
public void salvar(HttpServletRequest request, ItemEstruturaIett itemEstrutura, FuncaoFun funcao) throws ECARException {
try {
this.salvar(request, null, itemEstrutura, funcao,true);
} catch (IOException ioex) {
this.logger.error(ioex);
throw new ECARException("erro.arquivo");
}
}
/**
* Salva um registro de itemEstrutura. Salva � parte os item-estrutura-funcao-tipo-acomp
* devido a chave composta. (que deve ser setada depois de gravar o item)
*
* @param request
* @param itemEstrutura
* @param funcao
* @throws ECARException
* @throws IOException
*/
@SuppressWarnings("unchecked")
public void salvar(HttpServletRequest request,Transaction transactionArg,ItemEstruturaIett itemEstrutura, FuncaoFun funcao,boolean avaliarAtributoLivre) throws ECARException, IOException,HibernateException {
Transaction tx = null;
HistoricoItemEstruturaIett historicoItemEstruturaIett = new HistoricoItemEstruturaIett();
try{
ArrayList objetos = new ArrayList();
super.inicializarLogBean();
if (transactionArg == null) {
tx = session.beginTransaction();
}
itemEstrutura.setDataInclusaoIett(Data.getDataAtual());
List filhos = new ArrayList();
if (itemEstrutura.getItemEstUsutpfuacIettutfas() != null){
filhos.addAll(itemEstrutura.getItemEstUsutpfuacIettutfas());
}
session.save(itemEstrutura);
objetos.add(itemEstrutura);
/*
* Salvar os atributos livres, pois agora j� tenho o codIett
*/
List atributosLivres = null;
if (avaliarAtributoLivre) {
atributosLivres = this.getAtributosLivresItemEstrutura(request,itemEstrutura);
for(Iterator it = atributosLivres.iterator(); it.hasNext();){
ItemEstruturaSisAtributoIettSatb atbLivre = (ItemEstruturaSisAtributoIettSatb) it.next();
SisAtributoSatb sisAtributo = atbLivre.getSisAtributoSatb();
//Caso o tipo de valida��o seja uma das tr�s abaixo, ser� gerado um c�digo incremental.
if (sisAtributo != null &&
(sisAtributo.isAtributoAutoIcremental() || sisAtributo.isAtributoContemMascara())) {
this.geraValorIncremental(atbLivre,sisAtributo,funcao,itemEstrutura.getEstruturaEtt(),objetos);
}
session.save(atbLivre);
objetos.add(atbLivre);
}
}
//Interc�mbio de dados
if (itemEstrutura.getItemEstrutUsuarioIettusesByCodIett() != null){
Iterator itIettuses = itemEstrutura.getItemEstrutUsuarioIettusesByCodIett().iterator();
while (itIettuses.hasNext()){
ItemEstrutUsuarioIettus iettus = (ItemEstrutUsuarioIettus) itIettuses.next();
session.save(iettus);
objetos.add(iettus);
}
}
//
// controlar as permissoes passando o item e a lista das funcoes de acompanhamento velhas (vai ser uma lista vazia)
//
new ControlePermissao().atualizarPermissoesItemEstrutura(itemEstrutura, null, session, true, request);
// gravar permiss�o para o usu�rio que criou o item
ItemEstrutUsuarioIettus itemEstrutUsuario = new ItemEstrutUsuarioIettus();
itemEstrutUsuario.setItemEstruturaIett(itemEstrutura);
itemEstrutUsuario.setItemEstruturaIettOrigem(itemEstrutura);
itemEstrutUsuario.setCodTpPermIettus(ControlePermissao.PERMISSAO_USUARIO);
itemEstrutUsuario.setUsuarioUsu(itemEstrutura.getUsuarioUsuByCodUsuIncIett());
itemEstrutUsuario.setIndLeituraIettus("S");
itemEstrutUsuario.setIndEdicaoIettus("S");
itemEstrutUsuario.setIndExcluirIettus("S");
itemEstrutUsuario.setIndAtivMonitIettus("N");
itemEstrutUsuario.setIndDesatMonitIettus("N");
itemEstrutUsuario.setIndBloqPlanIettus("N");
itemEstrutUsuario.setIndDesblPlanIettus("N");
itemEstrutUsuario.setIndInfAndamentoIettus("N");
itemEstrutUsuario.setIndEmitePosIettus("N");
itemEstrutUsuario.setIndProxNivelIettus("N");
itemEstrutUsuario.setDataInclusaoIettus(Data.getDataAtual());
Iterator it = filhos.iterator();
while(it.hasNext()) {
PaiFilho object = (PaiFilho) it.next();
object.atribuirPKPai();
//salva os filhos
session.save(object);
objetos.add(object);
}
session.save(itemEstrutUsuario);
objetos.add(itemEstrutUsuario);
historicoItemEstruturaIett.carregar(itemEstrutura);
if (atributosLivres != null){
historicoItemEstruturaIett.setItemEstruturaSisAtributoIettSatbs(new HashSet(atributosLivres));
} else {
historicoItemEstruturaIett.setItemEstruturaSisAtributoIettSatbs(new HashSet<SisAtributoSatb>());
}
gerarHistorico(historicoItemEstruturaIett, Historico.INCLUIR);
if (transactionArg == null) {
tx.commit();
}
if(super.logBean != null) {
super.logBean.setCodigoTransacao(Data.getHoraAtual(false));
super.logBean.setOperacao("INC");
Iterator itObj = objetos.iterator();
while(itObj.hasNext()) {
super.logBean.setObj(itObj.next());
super.loggerAuditoria.info(logBean.toString());
}
}
} catch (IOException ioex) {
ioex.printStackTrace();
//Se a transa��o passada for igual a null executa o c�digo abaixo, pois se a transa��o passada for v�lida
//o chamador dever� fechar a transa��o
if (transactionArg == null){
if (tx != null) {
try {
tx.rollback();
} catch (HibernateException r) {
this.logger.error(r);
throw new ECARException("erro.arquivo");
}
this.logger.error(ioex);
throw new ECARException("erro.arquivo");
}
} else {
throw ioex;
}
} catch (HibernateException hbmex) {
hbmex.printStackTrace();
//Se a transa��o passada for igual a null executa o c�digo abaixo, pois se a transa��o passada for v�lida
//o chamador dever� fechar a transa��o
if (transactionArg == null){
if (tx != null) {
try {
tx.rollback();
} catch (HibernateException r) {
this.logger.error(r);
throw new ECARException("erro.hibernateException");
}
}
this.logger.error(hbmex);
throw new ECARException("erro.hibernateException");
} else {
throw hbmex;
}
}
}
/**
* Gera o valor para a parte incremental do atributo livre do tipo ID
*
* @param atributoLivreBean
* @param sisAtributo
* @param funcao
* @param estrutura
* @param objetos
* @throws IOException
* @throws ECARException
*/
protected void geraValorIncremental(FuncaoSisAtributo atributoLivreBean, SisAtributoSatb sisAtributo, FuncaoFun funcao,EstruturaEtt estrutura,List objetos) throws IOException, ECARException {
SequenciadorDao seqDao = new SequenciadorDao(session);
seqDao.setHttpRequest(request);
SequenciadoraSeq sequenciador = seqDao.consultar(sisAtributo, funcao,estrutura);
ActionSisAtributo action = new ActionSisAtributo();
if (sequenciador == null){ //O sequenciador ser� nulo quando ainda n�o tiver sequenciador inserido no banco para o tipo de configura��o deste atributo.
sequenciador = new SequenciadoraSeq();
sequenciador.inicializar();
sequenciador.setAtributoLivreSistema(sisAtributo);
GregorianCalendar gc = new GregorianCalendar();
gc.setGregorianChange(atributoLivreBean.getDataUltManutencao());
sequenciador.setAno(gc.get(GregorianCalendar.YEAR));
sequenciador.setEstrutura(estrutura);
sequenciador.setFuncao(funcao);
seqDao.salvar(sequenciador);
if (objetos!= null){
objetos.add(sequenciador);
}
} else { //O sequenciador n�o ser� nulo quando j� houver um sequenciador inserido no banco para o tipo de configura��o deste atributo.
//incrementa o contador sequencial.
sequenciador.incrementar();
//Validar, com base na m�scara, o novo valor do sequenciador que foi gerado.
if (sisAtributo.isAtributoContemMascara()) {
action.validarValorIncrementalComBaseMascara (atributoLivreBean.getInformacao(),sequenciador.getSequenciaSeq());
} else {
action.validarValorIncrementalComBaseMascara (null,sequenciador.getSequenciaSeq());
}
if (objetos!=null){
objetos.add(sequenciador);
}
}
atributoLivreBean.atualizaListaTiposValores(sisAtributo, sequenciador, action, funcao);
String novoConteudo;
if (sisAtributo.isAtributoContemMascara()) {
novoConteudo = action.formatarConteudoParteIncremental(atributoLivreBean.getInformacao(),sequenciador.getSequenciaSeq());
} else {
novoConteudo = sequenciador.getSequenciaSeq().toString();
}
atributoLivreBean.setInformacao(novoConteudo);
}
/**
* Realiza a altera��o do item, invocado a partir da view(jsp)
*
*
* @param request
* @param usuarioLogado
* @param historico
* @return
* @throws Exception
*/
public ItemEstruturaIett alterar(HttpServletRequest request, UsuarioUsu usuarioLogado, HistoricoIett historico) throws Exception {
SegurancaECAR seguranca = (SegurancaECAR)request.getSession().getAttribute("seguranca");
return this.alterar (null,request, usuarioLogado, seguranca.getGruposAcesso(), historico,null);
}
/**
* Altera um item estrutura com as funcoes de acompanhamento.
* @param request
* @param usuarioLogado
* @param gruposAcesso
* @param historico
* @return ItemEstruturaIett
* @throws Exception
*/
public ItemEstruturaIett alterar(HttpServletRequest request, UsuarioUsu usuarioLogado, Set gruposAcesso, HistoricoIett historico) throws Exception {
SegurancaECAR seguranca = (SegurancaECAR)request.getSession().getAttribute("seguranca");
ItemEstruturaIett itemEstruturaAlterado = null;
itemEstruturaAlterado = this.alterar(null, request, usuarioLogado, gruposAcesso, historico, null);
return itemEstruturaAlterado;
}
/**
* Invocado a partir da rotina de intercambio de dados
* @param transactionArg
* @param request
* @param usuarioLogado
* @param itemEstruturaArg
* @return
* @throws Exception
*/
public ItemEstruturaIett alterar(Transaction transactionArg, HttpServletRequest request, UsuarioUsu usuarioLogado, ItemEstruturaIett itemEstruturaArg) throws Exception{
SegurancaECAR seguranca = (SegurancaECAR)request.getSession().getAttribute("seguranca");
Set gruposAcesso = seguranca.getGruposAcesso();
HistoricoIett historico = new HistoricoIett(itemEstruturaArg, HistoricoIett.alteracao, this.getSession(), new ConfiguracaoDao(request), request);
ItemEstruturaIett itemEstruturaAlterado = null;
itemEstruturaAlterado = this.alterar(transactionArg, request, usuarioLogado, gruposAcesso, historico, itemEstruturaArg);
return itemEstruturaAlterado;
}
/**
* Altera um item estrutura com as funcoes de acompanhamento na mesma transa��o.
* @param request
* @param usuarioLogado
* @param gruposAcesso
* @param historico
* @return ItemEstruturaIett
* @throws Exception
*/
private ItemEstruturaIett alterar(Transaction transactionArg, HttpServletRequest request, UsuarioUsu usuarioLogado, Set gruposAcesso, HistoricoIett historico,ItemEstruturaIett itemEstruturaArg) throws Exception {
Transaction tx = null;
HistoricoItemEstruturaIett historicoItemEstruturaIett = new HistoricoItemEstruturaIett();
ItemEstruturaIett itemEstrutura = null;
boolean existeSisAtributoStabUsadoComoRestrititvo = false;
List listaSisAtributosSatbUsadosComoRestritivo = new ArrayList();
EstruturaDao estruturaDao = new EstruturaDao(request);
SisGrupoAtributoDao sgaDao = new SisGrupoAtributoDao(request);
try{
ArrayList objetos = new ArrayList();
super.inicializarLogBean();
if (transactionArg == null) {
tx = session.beginTransaction();
}
if (itemEstruturaArg == null) {
itemEstrutura = (ItemEstruturaIett) buscar(ItemEstruturaIett.class, Long.valueOf(Pagina.getParamStr(request, "codIett")));
} else {
itemEstrutura = itemEstruturaArg;
}
ItemEstruturaIett old = (ItemEstruturaIett) itemEstrutura.clone();
String indBloqPlanejamentoAnterior = itemEstrutura.getIndBloqPlanejamentoIett();
String indMonitoramentoAnterior = itemEstrutura.getIndMonitoramentoIett();
itemEstrutura.getItemEstUsutpfuacIettutfas().size();
Set lFuac = itemEstrutura.getItemEstUsutpfuacIettutfas();
/***Historico***/
historico.gerarHistorico(old);
/***Historico***/
// Verifica se o planejamento est� bloqueado
Boolean planejamentoBloqueado = false;
if (itemEstrutura.getIndBloqPlanejamentoIett() != null && itemEstrutura.getIndBloqPlanejamentoIett().equals("S")) {
planejamentoBloqueado = true;
}
List funcoesDoUsuario = (new TipoFuncAcompDao(null)).getFuncoesAcompNaEstruturaDoUsuario(itemEstrutura , usuarioLogado, gruposAcesso);
List funcoesBloqueadas = new ArrayList();
// Caso o planejamento esteja bloqueado, Busca as fun��es de acompanhamento que
// est�o bloqueadas e adiciona elas na lista "funcoesBloqueadas".
if (planejamentoBloqueado) {
// Descobre a Estrutura do item
EstruturaEtt estrutura = itemEstrutura.getEstruturaEtt();
// Descobre as fun��es de acompanhamento de uma estrutura
Set funcoesAcomp = estrutura.getEstrutTpFuncAcmpEtttfas();
// Itera pelas fun��es buscando as que est�o bloqueadas para altera��o
if (funcoesAcomp != null) {
for (Iterator it = funcoesAcomp.iterator(); it.hasNext();) {
EstrutTpFuncAcmpEtttfa funcao = (EstrutTpFuncAcmpEtttfa) it.next();
if (funcao.iGetBloqueado() && ( !podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, funcao, funcoesDoUsuario)) ) {
funcoesBloqueadas.add(funcao);
}
}
}
}
List funcoesNaoAlteradas = new ArrayList();
// apagar as funcoes de acompanhamento do item
if (itemEstrutura.getItemEstUsutpfuacIettutfas() != null) {
Iterator it = itemEstrutura.getItemEstUsutpfuacIettutfas().iterator();
while (it.hasNext()) {
ItemEstUsutpfuacIettutfa obj = (ItemEstUsutpfuacIettutfa)it.next();
// Assume que a fun��o est� desbloqueada
Boolean podeAlterar = true;
// Itera entre as fun��es que est�o bloqueadas. S� haver� valores nesta lista,
// caso o planejamento esteja bloqueado.
Iterator it2 = funcoesBloqueadas.iterator();
while (it2.hasNext()) {
EstrutTpFuncAcmpEtttfa funcaoBloqueada = (EstrutTpFuncAcmpEtttfa)it2.next();
// compara a fun��o e verifica se a confira��o est� para bloqueada.
// Caso bloqueada, define que o usu�rio n�o pode ter alterado a fun��o.
if (funcaoBloqueada.getComp_id().getCodTpfa().equals(obj.getComp_id().getCodTpfa())) {
podeAlterar = false;
break;
}
}
// S� remove do banco de dados as fun��es que o usu�rio poderia ter alterado.
if (podeAlterar) {
obj.setDataUltManutencao(Data.getDataAtual());
obj.setUsuManutencao(usuarioLogado);
//System.out.println("Deletou Fun��o Acomp: " + obj.getTipoFuncAcompTpfa().getDescricaoTpfa());
session.delete(obj);
objetos.add(obj);
} else {
funcoesNaoAlteradas.add(obj);
}
}
}
// Verifica quais s�o os atributos livres vinculados a estrutura.
// Isto s� � feito se o planejamento estiver bloqueado.
List sgas = new ArrayList();
if (planejamentoBloqueado) {
// busca os atributos livre configurados para o item em seu n�vel na estrutura
if(itemEstrutura.getEstruturaEtt() != null && itemEstrutura.getEstruturaEtt().getEstruturaAtributoEttats() != null && !itemEstrutura.getEstruturaEtt().getEstruturaAtributoEttats().isEmpty()){
for(Iterator it = itemEstrutura.getEstruturaEtt().getEstruturaAtributoEttats().iterator(); it.hasNext();){
EstruturaAtributoEttat ettat = (EstruturaAtributoEttat) it.next();
if(ettat.getAtributosAtb() != null && ettat.getAtributosAtb().getSisGrupoAtributoSga() != null){
// verifica se o atributo livre esta configurado para estar bloqueado.
if (ettat.iGetBloqueado() && ( !podeEditarAtributoBloqueadoNaEstrutura(itemEstrutura, ettat, funcoesDoUsuario)) ) {
//System.out.println("Atributo Livre" + ettat.getLabelEstruturaEttat());
sgas.add(ettat.getAtributosAtb().getSisGrupoAtributoSga());
}
}
}
}
}
List atributosLivres = this.getAtributosLivresItemEstrutura(request, itemEstrutura);
// apagar os atributos livres do item
if (itemEstrutura.getItemEstruturaSisAtributoIettSatbs() != null){
//busca os atributos livre configurados para este n�vel da estrutura
Iterator it = itemEstrutura.getItemEstruturaSisAtributoIettSatbs().iterator();
List satbsRestritivos = new ArrayList();
SisGrupoAtributoSga sgaRestritivo = null;
while (it.hasNext()) {
ItemEstruturaSisAtributoIettSatb obj = (ItemEstruturaSisAtributoIettSatb)it.next();
// assumo que o usu�rio poderia alterar este atributo.
Boolean podeAlterar = true;
if (planejamentoBloqueado) {
for(Iterator it2 = sgas.iterator(); it2.hasNext();){
SisGrupoAtributoSga grupoAtributo = (SisGrupoAtributoSga) it2.next();
if(grupoAtributo.getCodSga().equals(obj.getSisAtributoSatb().getSisGrupoAtributoSga().getCodSga())) {
// System.out.println("Atributo livre n�o editavel: " + grupoAtributo.getDescricaoSga());
podeAlterar = false;
break;
}
}
}
//verifica se a estrutura do item tem estrturas filhas e o atributo � um atributo restritivo.
if(obj.getSisAtributoSatb().getSisGrupoAtributoSga().getSisTipoExibicGrupoSteg().getCodSteg() == Input.LISTBOX ||
obj.getSisAtributoSatb().getSisGrupoAtributoSga().getSisTipoExibicGrupoSteg().getCodSteg() == Input.RADIO_BUTTON ||
obj.getSisAtributoSatb().getSisGrupoAtributoSga().getSisTipoExibicGrupoSteg().getCodSteg() == Input.COMBOBOX ||
obj.getSisAtributoSatb().getSisGrupoAtributoSga().getSisTipoExibicGrupoSteg().getCodSteg() == Input.CHECKBOX) {
if(existeEstruturaFilhaUsandoAtributoComoRestritivo( itemEstrutura, obj.getSisAtributoSatb()) &&
!atributosLivres.contains(obj) && podeAlterar) {
if (sgaRestritivo == null){
sgaRestritivo = obj.getSisAtributoSatb().getSisGrupoAtributoSga();
satbsRestritivos.add(obj.getSisAtributoSatb());
sgaRestritivo = obj.getSisAtributoSatb().getSisGrupoAtributoSga();
//estruturaDao.getLabelAtributoEstrutra(itemEstrutura.getEstruturaEtt(), obj.getSisAtributoSatb().getSisGrupoAtributoSga());
} else if (sgaRestritivo.equals(obj.getSisAtributoSatb().getSisGrupoAtributoSga())){
sgaRestritivo = obj.getSisAtributoSatb().getSisGrupoAtributoSga();
satbsRestritivos.add(obj.getSisAtributoSatb());
//args.append(", ").append(obj.getSisAtributoSatb().getDescricaoSatb());
}
existeSisAtributoStabUsadoComoRestrititvo = true;
}
}
if (podeAlterar && !existeSisAtributoStabUsadoComoRestrititvo) {
if(obj.getSisAtributoSatb().getSisGrupoAtributoSga().getSisTipoExibicGrupoSteg().getCodSteg() == Input.IMAGEM){
String nomeCampo = request.getParameter("a" + obj.getSisAtributoSatb().getSisGrupoAtributoSga().getCodSga().toString());
if (nomeCampo != null && nomeCampo.equals("")){
String fullFile = obj.getInformacao();
if (fullFile.lastIndexOf("=") != -1)
fullFile = fullFile.substring(fullFile.lastIndexOf("=") + 1);
File f = new File(fullFile);
if( f.exists() )
FileUpload.apagarArquivo(fullFile);
}
}
session.delete(obj);
objetos.add(obj);
}
}
if(existeSisAtributoStabUsadoComoRestrititvo && satbsRestritivos.size() > 0) {
String labelAtributoRestritivo = "'" + estruturaDao.getLabelAtributoEstrutra(itemEstrutura.getEstruturaEtt(), sgaRestritivo) + "'";
List satbsRestritivosOrdenados = sgaDao.ordenadarSisAtributos(sgaRestritivo, satbsRestritivos);
Iterator itSatbsRestritivosOrdenados = satbsRestritivosOrdenados.iterator();
StringBuffer labelSatbsRestritivos = new StringBuffer();
while (itSatbsRestritivosOrdenados.hasNext()){
SisAtributoSatb sisAtb = (SisAtributoSatb) itSatbsRestritivosOrdenados.next();
labelSatbsRestritivos.append("'" + sisAtb.getDescricaoSatb() + "'");
if (itSatbsRestritivosOrdenados.hasNext()){
labelSatbsRestritivos.append(", ");
}
}
if (satbsRestritivosOrdenados.size() > 1){
throw new ECARException("itemEstrutura.sisAtributoSatbEttSuperior.sisAtributoSatbUsadoComoAtributoRestritoEstruturaFilha", null, new String[]{labelSatbsRestritivos.toString(), labelAtributoRestritivo});
} else {
throw new ECARException("itemEstrutura.sisAtributoSatbEttSuperior.umSisAtributoSatbUsadoComoAtributoRestritoEstruturaFilha", null, new String[]{labelSatbsRestritivos.toString(), labelAtributoRestritivo});
}
}
}
// seta o novo item_estrutura
/**
* S� dever� setar os dados recebidos do request no objeto item Estrutura, se o objeto itemEstruturaArg passado
* como par�metro estiver nulo, caso o objeto itemEstruturaArg tenha valor ele j� dever� estar com todos os dados que
* ser�o alterados.
*/
if (itemEstruturaArg == null ) {
this.setItemEstrutura(request, itemEstrutura);
}
itemEstrutura.setUsuarioUsuByCodUsuUltManutIett(usuarioLogado);
itemEstrutura.setDataUltManutencaoIett(Data.getDataAtual());
/*
* Salvar os atributos livres, pois agora j� tenho o codIett
*/
for(Iterator it = atributosLivres.iterator(); it.hasNext();){
ItemEstruturaSisAtributoIettSatb atbLivre = (ItemEstruturaSisAtributoIettSatb) it.next();
SisAtributoSatb sisAtributo = atbLivre.getSisAtributoSatb();
FuncaoFun funcao;
FuncaoDao funcaoDao;
//Caso o tipo de valida��o seja igual a Mascara Editavel, ser� gerado um c�digo incremental.
if (sisAtributo.getAtribInfCompSatb() != null && sisAtributo.isAtributoMascaraEditavel()) {
funcaoDao = new FuncaoDao(request);
funcao = funcaoDao.getFuncaoDadosGerais();
this.atualizaValorAtributosID(atbLivre,sisAtributo,funcao);
} else if (sisAtributo.getAtribInfCompSatb() != null &&
(sisAtributo.isAtributoAutoIcremental() || sisAtributo.isAtributoMascara())) {
ItemEstruturaSisAtributoIettSatb atributoLivreNoItem = atbLivre.getItemEstruturaIett().buscarItemEstruturaSisAtributoLista(sisAtributo);
funcaoDao = new FuncaoDao(request);
funcao = funcaoDao.getFuncaoDadosGerais();
if (atributoLivreNoItem != null && atributoLivreNoItem.getTiposValores() != null && !atributoLivreNoItem.getTiposValores().isEmpty()) {
this.copiarTipoValorSemID(atbLivre, atributoLivreNoItem.getTiposValores(),funcao);
} else {
String arg = "Item "+atbLivre.getItemEstruturaIett().getCodIett()+" atributo livre "+sisAtributo.getCodSatb();
throw new ECARException("erro.atributo.item.inconsistente");
}
}
session.save(atbLivre);
objetos.add(atbLivre);
}
// Salva as Fun��es de acompanhamento do item.
if(itemEstrutura.getItemEstUsutpfuacIettutfas() != null) {
Iterator it = itemEstrutura.getItemEstUsutpfuacIettutfas().iterator();
while(it.hasNext()) {
PaiFilho object = (PaiFilho) it.next();
object.atribuirPKPai();
//salva os filhos
session.save(object);
objetos.add(object);
}
}
// Seta no itemEstrutura as fun��es de acompanhamento que o usu�rio n�o podia modificar.
// para atualizar logo abaixo as permiss�es do item.
Iterator it = funcoesNaoAlteradas.iterator();
while(it.hasNext()) {
itemEstrutura.getItemEstUsutpfuacIettutfas().add((ItemEstUsutpfuacIettutfa)it.next());
}
//
//controlar as permissoes passando o item e a lista das funcoes de acompanhamento antigas
//
new ControlePermissao().atualizarPermissoesItemEstrutura(itemEstrutura, lFuac, session, false, request);
if(Dominios.SIM.equals(Pagina.getParamStr(request, "ativarRetirarMonitoramentoItensFilho"))){
if(indMonitoramentoAnterior != null && !indMonitoramentoAnterior.equals(itemEstrutura.getIndMonitoramentoIett())){
this.propagarMonitoramento(itemEstrutura, historico);
}
}
if(indBloqPlanejamentoAnterior != null && !indBloqPlanejamentoAnterior.equals(itemEstrutura.getIndBloqPlanejamentoIett())) {
this.propagarPlanejamento(itemEstrutura, historico);
}
// Salva o ItemEstrutura
session.update(itemEstrutura);
objetos.add(itemEstrutura);
historicoItemEstruturaIett.carregar(itemEstrutura);
if (atributosLivres != null){
historicoItemEstruturaIett.setItemEstruturaSisAtributoIettSatbs(new HashSet(atributosLivres));
} else {
historicoItemEstruturaIett.setItemEstruturaSisAtributoIettSatbs(new HashSet<SisAtributoSatb>());
}
gerarHistorico(historicoItemEstruturaIett, Historico.ALTERAR);
if (transactionArg == null){
tx.commit();
}
if(super.logBean != null) {
super.logBean.setCodigoTransacao(Data.getHoraAtual(false));
super.logBean.setOperacao("INC_ALT_EXC");
Iterator itObj = objetos.iterator();
while(itObj.hasNext()) {
super.logBean.setObj(itObj.next());
super.loggerAuditoria.info(logBean.toString());
}
}
} catch (ECARException ecar){
if (transactionArg == null) {
if (tx != null){
try {
tx.rollback();
} catch (HibernateException r) {
this.logger.error(r);
throw new ECARException("erro.hibernateException");
}
}
}
this.logger.error(ecar);
throw ecar;
} catch (HibernateException hbmex) {
hbmex.printStackTrace();
if (transactionArg == null) {
if (tx != null) {
try {
tx.rollback();
} catch (HibernateException r) {
this.logger.error(r);
throw new ECARException("erro.hibernateException");
}
}
this.logger.error(hbmex);
throw new ECARException("erro.hibernateException");
} else {
this.logger.error(hbmex);
throw hbmex;
}
}
return itemEstrutura;
}
private void copiarTipoValorSemID(ItemEstruturaSisAtributoIettSatb atbLivre, Set<TipoValor> tiposValores,FuncaoFun funcao) {
Set listaTiposValores = new HashSet();
for (TipoValor tipoValor : tiposValores) {
TipoValor tipoValorInner = new TipoValor();
tipoValorInner.setConteudo(tipoValor.getConteudo());
tipoValorInner.setItemEstruturaSisAtributo(atbLivre);
tipoValorInner.setTipo(tipoValor.getTipo());
tipoValorInner.setFuncao(funcao);
listaTiposValores.add(tipoValorInner);
}
atbLivre.setTiposValores(listaTiposValores);
}
/**
* Atualiza a lista de tipos valores existentes
* @param atributoLivreBean
* @param sisAtributo
* @param funcao
* @throws ECARException
*/
protected void atualizaValorAtributosID(FuncaoSisAtributo atributoLivreBean, SisAtributoSatb sisAtributo,FuncaoFun funcao) throws ECARException {
ActionSisAtributo action = new ActionSisAtributo();
//cria novos tipos de valores.
atributoLivreBean.atualizaListaTiposValores(sisAtributo, null, action, funcao);
//Set listaTiposValores = listaTiposValores(atributoLivreBean,sisAtributo,null,action,funcao);
//atributoLivreBean.setTiposValores(listaTiposValores);
}
/**
* M�todo est� sendo usado para excluir Item-estrutura-usuario-funcao-acomp de um ItemEstrutura quando
* o item � excluido
* @param itemEstrutura
* @throws ECARException
*/
public void excluirItemEstruturaTipoFuncaoAcomp(ItemEstruturaIett itemEstrutura) throws ECARException{
List<ItemEstUsutpfuacIettutfa> filhos = new ArrayList<ItemEstUsutpfuacIettutfa>();
if(itemEstrutura.getItemEstUsutpfuacIettutfas() != null){
for (Iterator it = itemEstrutura.getItemEstUsutpfuacIettutfas().iterator(); it.hasNext();) {
ItemEstUsutpfuacIettutfa ieFun = (ItemEstUsutpfuacIettutfa) it.next();
filhos.add(ieFun);
}
super.excluir(filhos);
}
}
/**
* Recebe um array contendo c�digos de itens da estrutura e exclui todos os
* registros. Todas os dados do item e todos os dados dos dependentes s�o excluidos tamb�m
*
* @param codigosParaExcluir
* @param usuario
* @throws ECARException
*/
public void excluir(String[] codigosParaExcluir, UsuarioUsu usuario) throws ECARException {
this.excluir(null,codigosParaExcluir, usuario);
}
/**
* Recebe um array contendo c�digos de itens da estrutura e exclui todos os
* registros. Todas os dados do item e todos os dados dos dependentes s�o excluidos tamb�m
*
* @param codigosParaExcluir
* @param usuario
* @throws ECARException
*/
public void excluir(Transaction transactionArg ,String[] codigosParaExcluir, UsuarioUsu usuario) throws ECARException,HibernateException {
Transaction tx = null;
HistoricoItemEstruturaIett historicoItemEstruturaIett = new HistoricoItemEstruturaIett();
try {
ArrayList<ItemEstruturaIett> objetos = new ArrayList<ItemEstruturaIett>();
super.inicializarLogBean();
if (transactionArg == null) {
tx = session.beginTransaction();
}
for (int i = 0; i < codigosParaExcluir.length; i++) {
ItemEstruturaIett itemEstrutura = (ItemEstruturaIett) buscar(ItemEstruturaIett.class, Long.valueOf(codigosParaExcluir[i]));
ItemEstruturaIett old = (ItemEstruturaIett) itemEstrutura.clone();
itemEstrutura.setDataUltManutencaoIett(Data.getDataAtual());
itemEstrutura.setUsuarioUsuByCodUsuUltManutIett(usuario);
itemEstrutura.setIndAtivoIett(Dominios.NAO);
/******** Historico *********/
HistoricoIett historico = new HistoricoIett(itemEstrutura,
HistoricoIett.exclusao,
session,
new ConfiguracaoDao(request),
request);
historico.gerarHistorico(old);
/******** Historico *********/
session.update(itemEstrutura);
objetos.add(itemEstrutura);
List iettFilhos = this.getDescendentes(itemEstrutura, false);
for (Iterator it = iettFilhos.iterator(); it.hasNext();) {
ItemEstruturaIett itemEstruturaFilho = (ItemEstruturaIett) it.next();
old = (ItemEstruturaIett) itemEstruturaFilho.clone();
/***Historico***/
historico.gerarHistorico(old);
/***Historico***/
itemEstruturaFilho.setDataUltManutencaoIett(Data.getDataAtual());
itemEstruturaFilho.setUsuarioUsuByCodUsuUltManutIett(usuario);
itemEstruturaFilho.setIndAtivoIett(Dominios.NAO);
session.update(itemEstruturaFilho);
objetos.add(itemEstruturaFilho);
}
historicoItemEstruturaIett.carregar(itemEstrutura);
gerarHistorico(historicoItemEstruturaIett, Historico.EXCLUIR);
}
if (transactionArg == null) {
tx.commit();
}
if(super.logBean != null) {
super.logBean.setCodigoTransacao(Data.getHoraAtual(false));
super.logBean.setOperacao("EXC");
for (Iterator itObj = objetos.iterator(); itObj.hasNext();) {
Object element = (Object) itObj.next();
super.logBean.setObj(element);
super.loggerAuditoria.info(logBean.toString());
}
}
} catch (HibernateException hbmex) {
hbmex.printStackTrace();
//Se a transa��o passada for igual a null executa o c�digo abaixo, pois se a transa��o passada for v�lida
//o chamador dever� fechar a transa��o
if (transactionArg == null){
if (tx != null) {
try {
tx.rollback();
} catch (HibernateException r) {
this.logger.error(r);
throw new ECARException("erro.hibernateException");
}
}
this.logger.error(hbmex);
throw new ECARException("erro.hibernateException");
} else {
throw hbmex;
}
}
}
/**
* Retorna uma lista com todos os itens de Estrutura acima de um dado Item
*
* @param itemEstrutura
* @return
*/
public List getAscendentes(ItemEstruturaIett itemEstrutura) {
List<ItemEstruturaIett> retorno = new ArrayList<ItemEstruturaIett>();
while (itemEstrutura.getItemEstruturaIett() != null) {
itemEstrutura = itemEstrutura.getItemEstruturaIett();
retorno.add(itemEstrutura);
}
Collections.reverse(retorno);
return retorno;
}
/**
*
* @param itemEstrutura
* @return
*/
public ItemEstruturaIett getAscendenteMaximo(ItemEstruturaIett itemEstrutura) {
while (itemEstrutura.getItemEstruturaIett() != null) {
itemEstrutura = itemEstrutura.getItemEstruturaIett();
}
return itemEstrutura;
}
/**
* Retorna uma lista com todos os itens de Estrutura acima de um dado Item
* cujo n�vel mais alto da hierarquia � o itemPai passado como par�metro
* @param itemEstrutura
* @param itemPai
* @return
*/
public List getAscendentes(ItemEstruturaIett itemEstrutura, ItemEstruturaIett itemPai) {
List<ItemEstruturaIett> retorno = new ArrayList<ItemEstruturaIett>();
while (!itemEstrutura.equals(itemPai)) {
itemEstrutura = itemEstrutura.getItemEstruturaIett();
retorno.add(itemEstrutura);
}
Collections.reverse(retorno);
return retorno;
}
/**
* Retorna uma lista com todos os itens de Estrutura abaixo de um dado Item
*
* @param itemEstrutura
* @param efetuarRefreshItemEstrutura
* @return
* @throws ECARException
*/
public List getDescendentes(ItemEstruturaIett itemEstrutura, boolean efetuarRefreshItemEstrutura) throws ECARException{
List<ItemEstruturaIett> retorno = new ArrayList<ItemEstruturaIett>();
if(efetuarRefreshItemEstrutura) {
try{
// this.session.refresh(itemEstrutura);
} catch(HibernateException e){
this.logger.error(e);
throw new ECARException(e);
}
}
if (itemEstrutura.getItemEstruturaIetts() != null) {
for (Iterator it = itemEstrutura.getItemEstruturaIetts().iterator(); it.hasNext();) {
ItemEstruturaIett itemEstruturaFilho = (ItemEstruturaIett) it.next();
if (!retorno.contains(itemEstruturaFilho))
retorno.add(itemEstruturaFilho);
retorno.addAll(this.getDescendentes(itemEstruturaFilho, efetuarRefreshItemEstrutura));
}
}
return retorno;
}
/**
* recupera descendentes com pojo (ItemEstruturaIettMin)
* @param itemEstrutura
* @param efetuarRefreshItemEstrutura
* @return
* @throws ECARException
*/
public List getDescendentesMin(ItemEstruturaIettMin itemEstrutura, boolean efetuarRefreshItemEstrutura) throws ECARException{
List<ItemEstruturaIettMin> retorno = new ArrayList<ItemEstruturaIettMin>();
if(efetuarRefreshItemEstrutura) {
try{
this.session.refresh(itemEstrutura);
} catch(HibernateException e){
this.logger.error(e);
throw new ECARException(e);
}
}
if (itemEstrutura.getItemEstruturaIetts() != null) {
for (ItemEstruturaIettMin itemEstruturaFilho : itemEstrutura.getItemEstruturaIetts()) {
if (!retorno.contains(itemEstruturaFilho))
retorno.add(itemEstruturaFilho);
retorno.addAll(this.getDescendentesMin(itemEstruturaFilho, efetuarRefreshItemEstrutura));
}
}
return retorno;
}
/**
* Retorna uma lista com todos os itens de Estrutura abaixo de um dado Item - Busca os itens no BD.
*
* @param itemEstrutura
* @return
* @throws ECARException
*/
@SuppressWarnings("unchecked")
public List<ItemEstruturaIett> getDescendentesViaQry(ItemEstruturaIett itemEstrutura) throws ECARException{
try{
return this.getSession()
.createQuery("select iett from ItemEstruturaIett iett " +
"where iett.itemEstruturaIett.codIett = :codPai " +
"and iett.itemEstruturaIett.indAtivoIett = 'S'")
.setLong("codPai", itemEstrutura.getCodIett().longValue())
.list();
} catch(HibernateException e){
this.logger.error(e);
throw new ECARException(e);
}
}
public List<ItemEstruturaIettMin> getDistinctSigla(int nivel, EstruturaEtt ett) {
Query q = this.getSession().createQuery("SELECT DISTINCT iett FROM " +
"ItemEstruturaIettMin iett " +
"WHERE iett.indAtivoIett = 'S' " +
"AND iett.estruturaEtt = :ett " +
"AND iett.nivelIett = :n " +
"ORDER BY iett.codIett");
q.setInteger("n", nivel);
q.setParameter("ett", ett);
return q.list();
}
/**
* Retorna uma lista com todos os itens de Estrutura abaixo de um dado Item, recursivamente.
* Verifica tamb�m se o usu�rio tem permiss�o para dado item.
* Se n�o tem permiss�o para o item, verifica se tem para algum filho
*
* @param itemEstrutura
* @param efetuarRefreshItemEstrutura
* @param usuario
* @param gruposUsuario
* @return
* @throws ECARException
*/
public List getDescendentesComPermissao(ItemEstruturaIett itemEstrutura,
boolean efetuarRefreshItemEstrutura,
UsuarioUsu usuario,
Set gruposUsuario) throws ECARException{
ValidaPermissao validaPermissao = new ValidaPermissao();
List<ItemEstruturaIett> retorno = new ArrayList<ItemEstruturaIett>();
if(efetuarRefreshItemEstrutura) {
/* faz um refresh no item para que n�o seja aproveitado o objeto existente na session do Hibernate
* e termos um objeto com a cole�a� de filhos completa
*/
try{
this.session.refresh(itemEstrutura);
} catch(HibernateException e){
this.logger.error(e);
throw new ECARException(e);
}
}
if (itemEstrutura.getItemEstruturaIetts() != null) {
Iterator it = itemEstrutura.getItemEstruturaIetts().iterator();
while (it.hasNext()) {
ItemEstruturaIett itemEstruturaFilho = (ItemEstruturaIett) it.next();
if (!retorno.contains(itemEstruturaFilho)) {
validaPermissao.permissoesItem(itemEstruturaFilho, usuario, gruposUsuario);
if (validaPermissao.permissaoConsultarItem())
retorno.add(itemEstruturaFilho);
}
retorno.addAll(this.getDescendentesComPermissao(itemEstruturaFilho, efetuarRefreshItemEstrutura, usuario, gruposUsuario));
}
}
return retorno;
}
/**
* Retorna uma lista com todos os itens de Estrutura abaixo de um dado Item que sejam de um dos n�veis de palenjamento
* passados como par�metros na Lista
*
* @param itemEstrutura
* @param niveisPlanejamento
* @return
* @throws ECARException
*/
public List getDescendentesPorNivelPlanejamento(ItemEstruturaIett itemEstrutura, List niveisPlanejamento) throws ECARException{
List<ItemEstruturaIett> retorno = new ArrayList<ItemEstruturaIett>();
try{
this.session.refresh(itemEstrutura);
} catch(HibernateException e){
this.logger.error(e);
throw new ECARException(e);
}
if (itemEstrutura.getItemEstruturaIetts() != null) {
for (Iterator it = itemEstrutura.getItemEstruturaIetts().iterator(); it.hasNext();) {
ItemEstruturaIett itemEstruturaFilho = (ItemEstruturaIett) it.next();
if (!retorno.contains(itemEstruturaFilho)
&& Util.intersecao(itemEstruturaFilho.getItemEstruturaNivelIettns(), niveisPlanejamento).size() > 0
){
retorno.add(itemEstruturaFilho);
}
retorno.addAll(this.getDescendentesPorNivelPlanejamento(itemEstruturaFilho, niveisPlanejamento));
}
}
return retorno;
}
/**
* Retorna os Itens filhos de um Item cujo n�vel seja no m�ximo nivel pai + (nivel)
* @param itemEstrutura
* @param nivel
* @return
* @throws ECARException
*/
public List getDescendentes(ItemEstruturaIett itemEstrutura, int nivel) throws ECARException{
List<ItemEstruturaIett> retorno = new ArrayList<ItemEstruturaIett>();
int nivelMaximo = nivel + itemEstrutura.getNivelIett().intValue();
if (itemEstrutura.getItemEstruturaIetts() != null) {
for (Iterator it = itemEstrutura.getItemEstruturaIetts().iterator(); it.hasNext();) {
ItemEstruturaIett itemEstruturaFilho = (ItemEstruturaIett) it.next();
if (itemEstruturaFilho.getNivelIett().intValue() <= nivelMaximo && !retorno.contains(itemEstruturaFilho))
retorno.add(itemEstruturaFilho);
retorno.addAll(this.getDescendentes(itemEstruturaFilho, true));
}
}
return retorno;
}
/**
* Devolve uma lista de itens da estrutura ordenados (estrutura + primeiro campo da listagem de colunas
* da estrutura) e somente os itens que o usu�rio pode consultar.
* @param itemEstrutura
* @param usuarioUsu
* @param gruposUsuario
* @return List
* @throws ECARException
*/
public List getDescendentesComPermissoesOrdenado(ItemEstruturaIett itemEstrutura, UsuarioUsu usuarioUsu, Set gruposUsuario) throws ECARException{
ValidaPermissao validaPermissao = new ValidaPermissao();
List retorno = new ArrayList();
/*1.Obter um conjunto de estrutura do item passado como par�metro
(EstruturaDao.getSetEstruturasItem(item);)*/
EstruturaDao estruturaDao = new EstruturaDao(request);
List itens = estruturaDao.getSetEstruturasItem(itemEstrutura);
retorno.add(itemEstrutura);
/*2.Para cada estrutura 'e' obtida no passo anterior*/
Iterator itEstrutura = itens.iterator();
while(itEstrutura.hasNext()){
EstruturaEtt e = (EstruturaEtt) itEstrutura.next();
/*3.Obter as colunas dessa estrutura (EstruturaDao.getAtributosAcessoEstrutura('e');)*/
List atributos = estruturaDao.getAtributosAcessoEstrutura(e);
if(atributos != null && atributos.size() > 0){
ObjetoEstrutura objeto = (ObjetoEstrutura) atributos.get(0); //primeira coluna obtida
/*
4.Obter os itens filhos da estrutura 'e', ordenados pela primeira coluna obtida no passo anterior; ItemEstruturaDao.getItensFilhos(item, 'e', ObjetoEstrutura.iGetNomeOrdenarLista())
*/
List itensFilhos = getItensFilho(itemEstrutura, e, objeto.iGetNomeOrdenarLista());
/*5.Para cada item 'it' obtido no passo anterior*/
Iterator itFilhos = itensFilhos.iterator();
while(itFilhos.hasNext()){
ItemEstruturaIett itemFilho = (ItemEstruturaIett) itFilhos.next();
/*6.Obter a permissao do usuario para este item (ValidaPermissao.permissoesItem('it', usuario, grupos);*/
validaPermissao.permissoesItem(itemFilho, usuarioUsu, gruposUsuario);
/*7.Se validaPermissao.permissaoConsultarItem()*/
if (validaPermissao.permissaoConsultarItem()){
/*8.Adiciona o item 'it' na lista de retorno*/
retorno.add(itemFilho);
/*9.Chama o m�todo recursivamente (getDescendentesComPermissoesOrdenado('it', usuario, grupos);)*/
retorno.addAll(getDescendentesComPermissoesOrdenado(itemFilho, usuarioUsu, gruposUsuario));
}
}
}
}
return retorno;
}
/**
* Devolve uma lista de itens da estrutura ordenados (estrutura + primeiro campo da listagem de colunas
* da estrutura) e somente os itens que o usu�rio pode consultar por estrutura.
* @param estrutura
* @param codItemPai
* @param usuarioUsu
* @param gruposUsuario
* @return
* @throws ECARException
*/
public List getDescendentesComPermissoesOrdenadoByEstrutura(EstruturaEtt estrutura, long codItemPai, UsuarioUsu usuarioUsu, Set gruposUsuario) throws ECARException{
ValidaPermissao validaPermissao = new ValidaPermissao();
List<ItemEstruturaIett> retorno = new ArrayList<ItemEstruturaIett>();
try{
String select = "select iett from ItemEstruturaIett iett" +
" where iett.estruturaEtt.codEtt = :codEstrutura" +
" and iett.indAtivoIett = 'S'";
if(codItemPai != 0){
select += " and iett.itemEstruturaIett.codIett = :codPai";
}
Query q = this.session.createQuery(select);
q.setLong("codEstrutura", estrutura.getCodEtt().longValue());
if(codItemPai != 0){
q.setLong("codPai", codItemPai);
}
List itensEstrutura = q.list();
if(itensEstrutura != null && !itensEstrutura.isEmpty()){
for (Iterator itEtt = itensEstrutura.iterator(); itEtt.hasNext();) {
ItemEstruturaIett iett = (ItemEstruturaIett) itEtt.next();
validaPermissao.permissoesItem(iett, usuarioUsu, gruposUsuario);
if(validaPermissao.permissaoConsultarItem()){
retorno.add(iett);
retorno.addAll(this.getDescendentesComPermissoesOrdenado(iett, usuarioUsu, gruposUsuario));
}
}
}
} catch(HibernateException e){
this.logger.error(e);
throw new ECARException(e);
}
return retorno;
}
/**
* Retorna um list com identifica��es de todas os Atributos de N�vel de Acesso de um item
* @param item
* @return List de Long
*/
public ArrayList getNivelAcessoById(ItemEstruturaIett item) {
/*
* comentado bug #880
* A id�ia � que os n�veis de acesso venham na ordem da maneira que est� cadastrado no grupo de atributos, ou seja,
* por informa��es complementares. Do jeito que est� vem em qualquer ordem.
*
List lNiveis = new ArrayList();
if(item.getItemEstruturaNivelIettns()!= null && item.getItemEstruturaNivelIettns().size() > 0){
Iterator it = item.getItemEstruturaNivelIettns().iterator();
while(it.hasNext()){
SisAtributoSatb atributo = (SisAtributoSatb) it.next();
lNiveis.add(atributo.getCodSatb());
}
}
return lNiveis;
*/
// obter os niveis de acesso do item na ordem
List lNiveis = getNivelAcesso(item);
ArrayList<Long> resultado = new ArrayList<Long>();
// extrair os c�digos
for (Iterator iter = lNiveis.iterator(); iter.hasNext();) {
SisAtributoSatb atributo = (SisAtributoSatb) iter.next();
resultado.add(atributo.getCodSatb());
}
return resultado;
}
/**
* Retorna um list com os os Atributos de N�vel de Acesso de um item
* @param item
* @return List de SisAtributoSatb
*/
public List getNivelAcesso(ItemEstruturaIett item) {
/*
* comentando por causa do bug 880;
*
List lNiveis = new ArrayList();
if(item.getItemEstruturaNivelIettns()!= null && item.getItemEstruturaNivelIettns().size() > 0){
Iterator it = item.getItemEstruturaNivelIettns().iterator();
while(it.hasNext()){
SisAtributoSatb atributo = (SisAtributoSatb) it.next();
lNiveis.add(atributo);
}
}
return lNiveis;
*/
/*
* funcionamento:
* 1. Determinar um atributo do nivel de acesso para obter o grupo de atributos;
* 2. a partir do grupo obter todos os atributos ordenados;
* 3. retirar do resultado de 2 os atributos que n�o fazem parte do item
*
*/
List lNiveis = new ArrayList();
if (item.getItemEstruturaNivelIettns() != null && item.getItemEstruturaNivelIettns().size() > 0) {
// 1.
SisGrupoAtributoSga grupoAtributo = ((SisAtributoSatb) item.getItemEstruturaNivelIettns().iterator().next()).getSisGrupoAtributoSga();
try {
// 2.
lNiveis = new SisGrupoAtributoDao().getAtributosOrdenados(grupoAtributo);
// 3.
lNiveis.retainAll(item.getItemEstruturaNivelIettns());
} catch (ECARException e) {
this.logger.error(e);
}
}
return lNiveis;
}
/**
* Devolve uma Lista com todos os itens filho do item passado que sejam da estrutura passada como par�metro.
* Caso o item seja nulo, retorna uma Collection com os itens que pertencem a estrutura passada como par�metro.
* Recebe como argumento o item, a estrutura e o nome do campo pelo qual se deseja ordenar a lista
* @param item
* @param estrutura
* @param nomeCampoOrderBy
* @return List de itemEstruturaIett
* @throws ECARException
*/
public List getItensFilho(ItemEstruturaIett item, EstruturaEtt estrutura, String nomeCampoOrderBy) throws ECARException{
List lista = new ArrayList();
String nomeOrder;
/* assume um default quando nao pode mapear o campo para ordenar no cadastro de itens
* por exemplo, quando colocar a primeira coluna com uma funcao de acompanhamento
*/
if (nomeCampoOrderBy == null || "".equals(nomeCampoOrderBy))
nomeOrder = "this.nomeIett";
else
nomeOrder = "this." + nomeCampoOrderBy;
try{
if(item != null){
lista.addAll(this.getSession().createFilter(item.getItemEstruturaIetts(),
"where this.estruturaEtt.codEtt = " + estrutura.getCodEtt() + " order by " + nomeOrder).list());
} else {
lista.addAll(this.getSession().createFilter(estrutura.getItemEstruturaIetts(), "order by " + nomeOrder).list());
}
return lista;
} catch (HibernateException e){
this.logger.error(e);
throw new ECARException(e);
}
}
/**
* Devolve uma Lista com todos os itens filho do item passado que sejam da estrutura passada como par�metro,
* ordenados conforme a ordem de apresenta��o das colunas (campos) da lista de colunas.
*
* @author aleixo
* @since 26/06/2007
* @param item
* @param estrutura
* @param colunas
* @return List
* @throws ECARException
*/
public List getItensFilho(ItemEstruturaIett item, EstruturaEtt estrutura, List colunas) throws ECARException {
List lista = new ArrayList();
List<OrdenacaoIett> listaOrdem = new ArrayList<OrdenacaoIett>();
Set itensFilhos = (item != null) ? item.getItemEstruturaIetts() : estrutura.getItemEstruturaIetts();
if (itensFilhos != null && !itensFilhos.isEmpty()){
int tamanho = this.getTamanhoMaximoCampo(colunas, itensFilhos);
for(Iterator it = itensFilhos.iterator(); it.hasNext();){
ItemEstruturaIett iett = (ItemEstruturaIett) it.next();
if(!iett.getEstruturaEtt().equals(estrutura)){
continue;
}
OrdenacaoIett ordem = new OrdenacaoIett();
ordem.setIett(iett);
String campo = "";
//percorre as colunas
if(colunas != null && !colunas.isEmpty()){
for(Iterator it2 = colunas.iterator(); it2.hasNext();){
ObjetoEstrutura atb = (ObjetoEstrutura) it2.next();
String valor = "";
//String valor = this.getValorAtributoItemEstrutura(iett, atb.iGetNome(), atb.iGetNomeFk());
if("nivelPlanejamento".equals(atb.iGetNome())){
String niveis = "";
if(iett.getItemEstruturaNivelIettns() != null && !iett.getItemEstruturaNivelIettns().isEmpty()){
Iterator itNiveis = iett.getItemEstruturaNivelIettns().iterator();
while(itNiveis.hasNext()){
SisAtributoSatb nivel = (SisAtributoSatb) itNiveis.next();
niveis += nivel.getDescricaoSatb() + "; ";
}
niveis = niveis.substring(0, niveis.lastIndexOf(";"));
}
valor = niveis;
} else if (atb.iGetGrupoAtributosLivres() != null) {
Iterator itIettSatbs = iett.getItemEstruturaSisAtributoIettSatbs().iterator();
String informacaoIettSatb = "";
while (itIettSatbs.hasNext()) {
ItemEstruturaSisAtributoIettSatb itemEstruturaSisAtributoIettSatb = (ItemEstruturaSisAtributoIettSatb) itIettSatbs.next();
if (itemEstruturaSisAtributoIettSatb.getSisAtributoSatb().getSisGrupoAtributoSga().equals(atb.iGetGrupoAtributosLivres())){
if (atb.iGetGrupoAtributosLivres().getSisTipoExibicGrupoSteg().getCodSteg().equals(new Long(Input.TEXT)) ||
atb.iGetGrupoAtributosLivres().getSisTipoExibicGrupoSteg().getCodSteg().equals(new Long(Input.TEXTAREA)) ||
atb.iGetGrupoAtributosLivres().getSisTipoExibicGrupoSteg().getCodSteg().equals(new Long(Input.MULTITEXTO)) ||
atb.iGetGrupoAtributosLivres().getSisTipoExibicGrupoSteg().getCodSteg().equals(new Long(Input.VALIDACAO)) ) {
informacaoIettSatb = informacaoIettSatb + itemEstruturaSisAtributoIettSatb.getInformacao() + "; ";
} else if (!atb.iGetGrupoAtributosLivres().getSisTipoExibicGrupoSteg().getCodSteg().equals(new Long(Input.IMAGEM))) {
//se for do tipo imagem n�o faz nada, deixa em branco.
informacaoIettSatb = informacaoIettSatb + itemEstruturaSisAtributoIettSatb.getSisAtributoSatb().getDescricaoSatb() + "; ";
}
}
}
if (informacaoIettSatb.length() > 0){
informacaoIettSatb = informacaoIettSatb.substring(0, informacaoIettSatb.length() - 2);
}
valor = informacaoIettSatb;
} else {
valor = this.getValorAtributoItemEstrutura(iett, atb.iGetNome(), atb.iGetNomeFk());
}
Date data = Data.parseDate(valor, "dd/MM/yyyy");
if(data != null){ //� campo data!
//Conseguiu converter para objeto Date!!!
int d = Data.getDia(data);
int m = Data.getMes(data) + 1;
int a = Data.getAno(data);
String dia = (d < 10) ? "0" + String.valueOf(d) : String.valueOf(d);
String mes = (m < 10) ? "0" + String.valueOf(m) : String.valueOf(m);
String ano = String.valueOf(a);
valor = ano + mes + dia;
}
// campo += this.completarParaOrdenacao(valor, tamanho);
campo = valor;
break;
// campo = iett.getNomeIett();
}
}
else {
// campo = this.completarParaOrdenacao(iett.getNomeIett(), tamanho);
campo = iett.getNomeIett();
break;
}
ordem.setCampoOrdenar(Util.retiraAcentuacao(campo.toLowerCase().trim()));
listaOrdem.add(ordem);
}
}
//Ordenando pelo campo de ordena��o
Collections.sort(listaOrdem, new Comparator(){
public int compare(Object arg0, Object arg1) {
OrdenacaoIett o1 = (OrdenacaoIett) arg0;
OrdenacaoIett o2 = (OrdenacaoIett) arg1;
String o1String = o1.getCampoOrdenar().toLowerCase().replace("�","a").replace("�","e").replace("�","i").replace("�","o").replace("�","u").replace("�","a").replace("�","e").replace("�","o").replace("�","a").replace("�","o").replace("�","u").replace("�","a");
String o2String = o2.getCampoOrdenar().toLowerCase().replace("�","a").replace("�","e").replace("�","i").replace("�","o").replace("�","u").replace("�","a").replace("�","e").replace("�","o").replace("�","a").replace("�","o").replace("�","u").replace("�","a");
return o1String .compareTo(o2String);
}
});
for(OrdenacaoIett o : listaOrdem){
lista.add(o.getIett());
}
return lista;
}
/**
* Devolve uma Lista com todos os itens filho do item passado que sejam da estrutura passada como par�metro,
* ordenados conforme a ordem de apresenta��o das colunas (campos) da lista de colunas.
*
* @author aleixo
* @since 26/06/2007
* @param estrutura
* @param colunas
* @param estruturaVirtual
* @param seguranca
* @return List
* @throws ECARException
*/
public List getItensAssociados(EstruturaEtt estrutura, List colunas, EstruturaEtt estruturaVirtual, SegurancaECAR seguranca) throws ECARException {
List lista = new ArrayList();
List<OrdenacaoIett> listaOrdem = new ArrayList<OrdenacaoIett>();
Map mapItensEstruturaVirtual = null;
ItemEstruturaDao itemDao = new ItemEstruturaDao(null);
ActionEstrutura action = new ActionEstrutura();
//recupera os itens associados a uma estrutura virtual que pertencem a uma determinada estrutura real
Set <ItemEstruturaIett> itensFilhos = action.getItensComPermissaoPorEstruturaReal(estrutura, estruturaVirtual, seguranca);
if (itensFilhos != null && !itensFilhos.isEmpty()){
int tamanho = this.getTamanhoMaximoCampo(colunas, itensFilhos);
for(Iterator it = itensFilhos.iterator(); it.hasNext();){
ItemEstruturaIett iett = (ItemEstruturaIett) it.next();
if(!iett.getEstruturaEtt().equals(estrutura)){
continue;
}
OrdenacaoIett ordem = new OrdenacaoIett();
ordem.setIett(iett);
String campo = "";
//percorre as colunas
if(colunas != null && !colunas.isEmpty()){
for(Iterator it2 = colunas.iterator(); it2.hasNext();){
ObjetoEstrutura atb = (ObjetoEstrutura) it2.next();
String valor = "";
//String valor = this.getValorAtributoItemEstrutura(iett, atb.iGetNome(), atb.iGetNomeFk());
if("nivelPlanejamento".equals(atb.iGetNome())){
String niveis = "";
if(iett.getItemEstruturaNivelIettns() != null && !iett.getItemEstruturaNivelIettns().isEmpty()){
Iterator itNiveis = iett.getItemEstruturaNivelIettns().iterator();
while(itNiveis.hasNext()){
SisAtributoSatb nivel = (SisAtributoSatb) itNiveis.next();
niveis += nivel.getDescricaoSatb() + "; ";
}
niveis = niveis.substring(0, niveis.lastIndexOf(";"));
}
valor = niveis;
} else if (atb.iGetGrupoAtributosLivres() != null) {
Iterator itIettSatbs = iett.getItemEstruturaSisAtributoIettSatbs().iterator();
String informacaoIettSatb = "";
while (itIettSatbs.hasNext()) {
ItemEstruturaSisAtributoIettSatb itemEstruturaSisAtributoIettSatb = (ItemEstruturaSisAtributoIettSatb) itIettSatbs.next();
if (itemEstruturaSisAtributoIettSatb.getSisAtributoSatb().getSisGrupoAtributoSga().equals(atb.iGetGrupoAtributosLivres())){
if (atb.iGetGrupoAtributosLivres().getSisTipoExibicGrupoSteg().getCodSteg().equals(new Long(Input.TEXT)) ||
atb.iGetGrupoAtributosLivres().getSisTipoExibicGrupoSteg().getCodSteg().equals(new Long(Input.TEXTAREA)) ||
atb.iGetGrupoAtributosLivres().getSisTipoExibicGrupoSteg().getCodSteg().equals(new Long(Input.MULTITEXTO)) ||
atb.iGetGrupoAtributosLivres().getSisTipoExibicGrupoSteg().getCodSteg().equals(new Long(Input.VALIDACAO)) ) {
informacaoIettSatb = informacaoIettSatb + itemEstruturaSisAtributoIettSatb.getInformacao() + "; ";
} else if (!atb.iGetGrupoAtributosLivres().getSisTipoExibicGrupoSteg().getCodSteg().equals(new Long(Input.IMAGEM))) {
//se for do tipo imagem n�o faz nada, deixa em branco.
informacaoIettSatb = informacaoIettSatb + itemEstruturaSisAtributoIettSatb.getSisAtributoSatb().getDescricaoSatb() + "; ";
}
}
}
if (informacaoIettSatb.length() > 0){
informacaoIettSatb = informacaoIettSatb.substring(0, informacaoIettSatb.length() - 2);
}
valor = informacaoIettSatb;
} else {
valor = this.getValorAtributoItemEstrutura(iett, atb.iGetNome(), atb.iGetNomeFk());
}
Date data = Data.parseDate(valor, "dd/MM/yyyy");
if(data != null){ //� campo data!
//Conseguiu converter para objeto Date!!!
int d = Data.getDia(data);
int m = Data.getMes(data) + 1;
int a = Data.getAno(data);
String dia = (d < 10) ? "0" + String.valueOf(d) : String.valueOf(d);
String mes = (m < 10) ? "0" + String.valueOf(m) : String.valueOf(m);
String ano = String.valueOf(a);
valor = ano + mes + dia;
}
campo += this.completarParaOrdenacao(valor, tamanho);
}
}
else {
campo = this.completarParaOrdenacao(iett.getNomeIett(), tamanho);
}
ordem.setCampoOrdenar(Util.retiraAcentuacao(campo.toLowerCase()));
listaOrdem.add(ordem);
}
}
//Ordenando pelo campo de ordena��o
Collections.sort(listaOrdem, new Comparator(){
public int compare(Object arg0, Object arg1) {
OrdenacaoIett o1 = (OrdenacaoIett) arg0;
OrdenacaoIett o2 = (OrdenacaoIett) arg1;
return o1.getCampoOrdenar().compareTo(o2.getCampoOrdenar());
}
});
for(OrdenacaoIett o : listaOrdem){
lista.add(o.getIett());
}
return lista;
}
/**
* Retorna o tamanho m�ximo da string dos valores de uma lista de campos numa lista de itens.
*
* @author aleixo
* @since 26/06/2007
* @param colunas
* @param itens
* @return
* @throws ECARException
*/
public int getTamanhoMaximoCampo(List colunas, Set itens) throws ECARException{
int tam = 0;
for(Iterator it = itens.iterator(); it.hasNext();){
ItemEstruturaIett item = (ItemEstruturaIett) it.next();
if(colunas != null && !colunas.isEmpty()){
for(Iterator it2 = colunas.iterator(); it2.hasNext();){
ObjetoEstrutura atb = (ObjetoEstrutura) it2.next();
String valor = this.getValorAtributoItemEstrutura(item, atb.iGetNome(), atb.iGetNomeFk());
if(valor != null){
if(valor.length() > tam){
tam = valor.length();
}
}
}
}
else {
String valor = item.getNomeIett();
if(valor != null){
if(valor.length() > tam){
tam = valor.length();
}
}
}
}
return tam;
}
/**
*
* @param lItens
* @param indConclusao
* @return List
*/
public List getItensIndConclusao(List lItens, String indConclusao)
{
ArrayList<ItemEstruturaIett> lItensIndConclusao = new ArrayList<ItemEstruturaIett>();
Iterator itLista = lItens.iterator();
if ("T".equals(indConclusao))
return lItens;
else{
while (itLista.hasNext())
{
ItemEstruturaIett item = (ItemEstruturaIett) itLista.next();
if ("C".equals(indConclusao))
{
if (item.getSituacaoSit() != null && "S".equals(item.getSituacaoSit().getIndConcluidoSit())) {
lItensIndConclusao.add(item);
}
}
else
{
if (item.getSituacaoSit() == null || !"S".equals(item.getSituacaoSit().getIndConcluidoSit().toString())) {
lItensIndConclusao.add(item);
}
}
}
}
return lItensIndConclusao;
}
/**
* Select para descobrir os itens selecion�veis.
* Item Selecion�vel � o que:
* (1) Possui ind_monitoramento = 'S' caso a sele��o seja por itens EM MONITORAMENTO
* ou possui �rg�o Responavel 1 ou 2 igual ao �rg�ao escolhido em um sele��o POR �RG�O e
* (2) Possui alguma fun��o de acompanhamento que ind_emite_posicao = 'S' ou informa_andamento = 'S'
*
* OU
*
* (3) Possui quantidade Prevista Cadstrada e
* (4) O item ainda nao terminou (data atual <= data de termino)
*
* ALGORITMO:
* X = itens do select;
* Z = { };
* para cada i em X {
* L = i sem os filhos + ascendentes de i sem os filhos (caso j� nao tenha limpado os filhos);
* aux = L.primeiroDaLista;
* ultimo = null;
* enquanto ( aux != null ) {
* filhos = aux.getFilhos();
* se ( !filhos.contains( ultimo ) ){
* filhos.add(ultimo)
* aux.setFilhos(filhos);
* }
* ultimo = aux;
* aux = aux.getPai();
* }
* se (! Z.cotains(ultimo) )
* Z.add(ultimo);
* }
* return X, Z
*
* Mostra em tela todos de Z
* Item � selecionavel se est� contido em X. <br>
*
* @author N/C, rogerio
* @since N/C
* @version 0.2, 19/03/2007
* @param OrgaoOrg orgao
* @param AcompReferenciaAref acompReferencia
* @param List listNiveis
* @param String indMonitoramento
* @return List
* @throws ECARException
*/
private List getItensSelecionaveisGeracaoPeriodoReferencia( OrgaoOrg orgao,
AcompReferenciaAref acompReferencia,
List listNiveis,
String indMonitoramento,
boolean acessoSomenteUsuariosOrgaos
) throws ECARException {
try{
StringBuilder query = new StringBuilder("select distinct item from ItemEstruturaIett as item")
.append(" join item.itemEstUsutpfuacIettutfas as itemFuncao");
query.append(" left join item.itemEstrtIndResulIettrs as indResultados");
query.append(" where ");
query.append(" item.indAtivoIett = 'S' AND ");
//se a estrutura do item estiver ativa
query.append(" item.estruturaEtt.indAtivoEtt = 'S' AND ");
query.append(" (itemFuncao.tipoFuncAcompTpfa.indInformaAndamentoTpfa='S' ");
query.append(" OR itemFuncao.tipoFuncAcompTpfa.indEmitePosicaoTpfa='S')");
//FIXME: N�o funcionou no Hibernate 3
//query.append(" AND (item.situacaoSit is null ");
//query.append(" OR (item.situacaoSit is not null AND item.situacaoSit.indConcluidoSit != 'S'))");;
if(!"".equals(indMonitoramento)) {
if(("N").equals(indMonitoramento.toUpperCase())){
query.append(" AND (item.indMonitoramentoIett = :indMonitoramento OR item.indMonitoramentoIett is null)");
}
else
query.append(" AND item.indMonitoramentoIett = :indMonitoramento");
}
List listaCodSatb = new ArrayList();
if(listNiveis != null && listNiveis.size() > 0) {
query.append(" AND (");
//int cont = 0;
Iterator itNiveis = listNiveis.iterator();
while(itNiveis.hasNext()){
SisAtributoSatb nivel = (SisAtributoSatb) itNiveis.next();
listaCodSatb.add(nivel.getCodSatb());
//query.append("niveis = " + nivel.getCodSatb().toString());
//if((cont + 1) < listNiveis.size()) {
//query.append(" OR ");
//}
//cont++;
}
query.append("item.itemEstruturaNivelIettns.codSatb in (:listaNiveis) ");
query.append(") ");
}
//Por falta de documenta��o da condi��o abaixo,
//foi alterado o c�digo para funcionar corretamente quando n�o for separado por org�o
if (acompReferencia.getTipoAcompanhamentoTa().getIndSepararOrgaoTa().equals(Dominios.SIM)){
if(orgao != null){
query.append(" AND item.orgaoOrgByCodOrgaoResponsavel1Iett.codOrg = :codOrg");
}else {
// if(orgao == null) E (tipoAcompanhamentoSeparadoPorOrgao == SIM) E (referencia S� com itens SEM INFORMACAO)
if((acompReferencia.getTipoAcompanhamentoTa().getIndSepararOrgaoTa() != null &&
acompReferencia.getTipoAcompanhamentoTa().getIndSepararOrgaoTa().equals(Dominios.SIM) &&
acompReferencia.getIndInformacaoOrgaoAref() != null && acompReferencia.getIndInformacaoOrgaoAref().equals("N"))
//ou se a op��o for todos, inclui os itens sem informa��o
||!acessoSomenteUsuariosOrgaos) {
query.append(" AND item.orgaoOrgByCodOrgaoResponsavel1Iett.codOrg is null");
}
}
}
Query queryItens = this.getSession().createQuery(query.toString());
if(!"".equals(indMonitoramento)) {
queryItens.setString("indMonitoramento", indMonitoramento);
}
if(orgao != null){
queryItens.setLong("codOrg", orgao.getCodOrg().longValue());
}
if(!listaCodSatb.isEmpty()) {
queryItens.setParameterList("listaNiveis", listaCodSatb);
}
List itens = queryItens.list();
for (Iterator itItens = itens.iterator(); itItens.hasNext();) {
ItemEstruturaIett iett = (ItemEstruturaIett) itItens.next();
if(iett.getSituacaoSit() != null
&& ("S".equals(iett.getSituacaoSit().getIndConcluidoSit())
|| "S".equals(iett.getSituacaoSit().getIndSemAcompanhamentoSit()))) {
itItens.remove();
} else {
// verificar o pai do item (Mantis: 7507)
ItemEstruturaIett itemPai = iett.getItemEstruturaIett();
if(itemPai != null
&& (itemPai.getSituacaoSit() != null
&& ("S".equals(itemPai.getSituacaoSit().getIndConcluidoSit())
|| "S".equals(itemPai.getSituacaoSit().getIndSemAcompanhamentoSit())))) {
itItens.remove();
}
}
}
//Mantis 5257: Filtrar os itens conforme associa��o de fun��o de acompanhamento (obrigat�ria/opcional) e tipo de acompanhamento.
//Gerar acompanhamento para as fun��es obrigat�rias e opcionais se o item possuir a(s) fun��o(�es) obrigat�ria(s)
//de acordo com o tipo de acompanhamento
List<TipoFuncAcompTpfa> funcaoAcompanhamentoObrigatoria = new ArrayList<TipoFuncAcompTpfa>();
List<TipoFuncAcompTpfa> funcaoAcompanhamentoOpcional = new ArrayList<TipoFuncAcompTpfa>();
TipoAcompanhamentoTa tipoAcompanhamento = (TipoAcompanhamentoTa)buscar(TipoAcompanhamentoTa.class, acompReferencia.getTipoAcompanhamentoTa().getCodTa());
if(tipoAcompanhamento != null) {
for (Iterator it = tipoAcompanhamento.getTipoAcompFuncAcompTafcs().iterator(); it.hasNext();) {
TipoAcompFuncAcompTafc tafc = (TipoAcompFuncAcompTafc) it.next();
if("S".equalsIgnoreCase(tafc.getIndObrigatorio())) {
funcaoAcompanhamentoObrigatoria.add(tafc.getTipoFuncAcompTpfa());
}
else if("S".equalsIgnoreCase(tafc.getIndOpcional())) {
funcaoAcompanhamentoOpcional.add(tafc.getTipoFuncAcompTpfa());
}
}
}
if(!funcaoAcompanhamentoObrigatoria.isEmpty() || !funcaoAcompanhamentoOpcional.isEmpty()) {
Iterator itItens = itens.iterator();
while(itItens.hasNext()) {
ItemEstruturaIett iett = (ItemEstruturaIett) itItens.next();
List<TipoFuncAcompTpfa> tpfaIett = new ArrayList<TipoFuncAcompTpfa>();
if(iett.getItemEstUsutpfuacIettutfas() != null) {
Iterator it = iett.getItemEstUsutpfuacIettutfas().iterator();
while(it.hasNext()) {
ItemEstUsutpfuacIettutfa iettutfa = (ItemEstUsutpfuacIettutfa) it.next();
tpfaIett.add(iettutfa.getTipoFuncAcompTpfa());
}
}
if(!funcaoAcompanhamentoObrigatoria.isEmpty()) {
if(!tpfaIett.containsAll(funcaoAcompanhamentoObrigatoria)) {
itItens.remove();
}
// como o item possui todas as fun��es de acompanhamento obrigat�rias ignorar a regra de opcionais
continue;
}
if(!funcaoAcompanhamentoOpcional.isEmpty()) {
boolean validacaoOpcionalOk = false;
Iterator it = tpfaIett.iterator();
while(it.hasNext()) {
TipoFuncAcompTpfa tpfa = (TipoFuncAcompTpfa) it.next();
if(funcaoAcompanhamentoOpcional.contains(tpfa)) {
validacaoOpcionalOk = true;
break;
}
}
if(!validacaoOpcionalOk) {
itItens.remove();
}
}
}
}
if(acompReferencia.getCodAref() != null){
List itensBanco = new AcompReferenciaItemDao(request).getListaItensAcompanhamento(acompReferencia);
if(itensBanco != null){
Iterator it = itensBanco.iterator();
while(it.hasNext()){
ItemEstruturaIett itemBanco = (ItemEstruturaIett) it.next();
if(!itens.contains(itemBanco))
itens.add(itemBanco);
}
}
}
return itens;
} catch (HibernateException e){
this.logger.error(e);
throw new ECARException(e);
}
}
/**
* M�todo devolve duas listas para serem usadas na constru��o da tela de sele��o de Itens da Estrutura para Gera��o de
* Per�odo de Refer�ncia. A primiera com os itens que s�o selecion�veis, ou seja, permitem acompanhamento) e outra com
* os que devem ser mostrados em tela para a constru��o da hierarquia correta (inclui os selecionaveis). <br>
*
* @author N/C, rogerio
* @since N/C
* @version 0.2, 19/03/2007
* @param orgao
* @param acompReferencia
* @param tipoAcesso
* @param gruposUsuario
* @param listNiveis
* @return List[]
* @throws ECARException
*/
public List[] getItensGerarAcompanhamento( OrgaoOrg orgao,
AcompReferenciaAref acompReferencia,
Set gruposUsuario,
String tipoAcesso,
List listNiveis,
boolean acessoSomenteUsuariosOrgaos) throws ECARException {
ValidaPermissao validaPermissao = new ValidaPermissao();
List[] retorno = new List[2];
String indMonitoramento = "";
if("S".equals(acompReferencia.getTipoAcompanhamentoTa().getIndMonitoramentoTa())
&& "N".equals(acompReferencia.getTipoAcompanhamentoTa().getIndNaoMonitoramentoTa())) {
indMonitoramento = "S";
}
else if("N".equals(acompReferencia.getTipoAcompanhamentoTa().getIndMonitoramentoTa())
&& "S".equals(acompReferencia.getTipoAcompanhamentoTa().getIndNaoMonitoramentoTa())) {
indMonitoramento = "N";
}
//M�todo exclui da lista de selecion�veis o itens que o usu�rio n�o tem acesso
List selecionaveis = getItensSelecionaveisGeracaoPeriodoReferencia(orgao, acompReferencia, listNiveis, indMonitoramento, acessoSomenteUsuariosOrgaos);
selecionaveis = this.getItensSelecionaveisFiltradosPorAtributo(selecionaveis, acompReferencia.getTipoAcompanhamentoTa());
retorno[0] = getItensOrdenados(selecionaveis, acompReferencia.getTipoAcompanhamentoTa());
retorno[1] = selecionaveis;
return retorno;
}
/**
* Ordena uma lista de objetos item estrutura, fazendo com que os itens no mesmo nivel da
* hierarquia fiquem organizados alfabeticamente
* @param itens
*/
public void ordenaListaItemEstrutura(List itens){
Collections.sort(itens,
new Comparator() {
public int compare(Object o1, Object o2) {
ItemEstruturaIett item1 = (ItemEstruturaIett) o1;
ItemEstruturaIett item2 = (ItemEstruturaIett) o2;
if(getAscendenteMaximo(item1).equals(getAscendenteMaximo(item2))){
if(item1.getNivelIett().intValue() == item2.getNivelIett().intValue()){
return item1.getNomeIett().compareToIgnoreCase(item2.getNomeIett());
} else{
return item1.getNivelIett().intValue() - item2.getNivelIett().intValue();
}
} else {
if(item1.getNivelIett().intValue() == item2.getNivelIett().intValue()){
return item1.getNomeIett().compareToIgnoreCase(item2.getNomeIett());
} else {
return getAscendenteMaximo(item1).getNomeIett().compareToIgnoreCase(getAscendenteMaximo(item2).getNomeIett());
}
}
}
}
);
}
/**
* Recebe uma lista de itens e adiciona na lista outros itens de modo a completar a hierarquia necess�ria para
* apresenta��o da �rvore de itens em tela
* Se itemPai for utilizado, � montada a �rvore at� seu n�vel. Caso n�o seja necess�rio passar itemPai = null
* @param itens
* @param itemPai
* @return
* @throws ECARException
*/
public ArrayList getArvoreItens(List<ItemEstruturaIett> itens, ItemEstruturaIett itemPai) throws ECARException{
Set<ItemEstruturaIett> retorno = new LinkedHashSet<ItemEstruturaIett>();
for( ItemEstruturaIett item: itens ){
List<ItemEstruturaIett> ascendentes = new ArrayList<ItemEstruturaIett>();
if(itemPai != null) {
ascendentes.addAll(getAscendentes(item, itemPai));
} else {
ascendentes.addAll(getAscendentes(item));
}
ascendentes.add(item);
retorno.addAll(ascendentes);
}
return new ArrayList<ItemEstruturaIett>(retorno);
}
public ArrayList getArvoreItensFromAris(List<AcompReferenciaItemAri> itens, ItemEstruturaIett itemPai) throws ECARException{
Set<ItemEstruturaIett> retorno = new LinkedHashSet<ItemEstruturaIett>();
for( AcompReferenciaItemAri item: itens ){
List<ItemEstruturaIett> ascendentes = new ArrayList<ItemEstruturaIett>();
if(itemPai != null) {
ascendentes.addAll(getAscendentes(item.getItemEstruturaIett(), itemPai));
} else {
ascendentes.addAll(getAscendentes(item.getItemEstruturaIett()));
}
ascendentes.add(item.getItemEstruturaIett());
retorno.addAll(ascendentes);
}
return new ArrayList<ItemEstruturaIett>(retorno);
}
/**
*
* @param itens
* @param itemPai
* @return List
* @throws ECARException
*/
public List getArvoreItensPesquisaEstrutura(List itens, ItemEstruturaIett itemPai) throws ECARException{
List itensTemp = new ArrayList(itens);
Set retorno = new HashSet();
Iterator it = itens.iterator();
while(it.hasNext()){
ItemEstruturaIett item = (ItemEstruturaIett) it.next();
/*
* Foi utilizado um refresh no item, pois quando utilizado com a pesquisa na estrutura
* depois de passada a lista para montar a �rvore, gerava erro de lazy,
* alguns filhos j� n�o estavam persistentes.
*/
try{
this.session.refresh(item);
} catch(HibernateException e){
this.logger.error(e);
throw new ECARException(e);
}
List ascendentes = new ArrayList();
if(itemPai != null) {
ascendentes.addAll(getAscendentes(item, itemPai));
} else {
ascendentes.addAll(getAscendentes(item));
}
ascendentes.add(item);
retorno.addAll(ascendentes);
}
List itensParaExibicao = this.getItensOrdenadosPorSiglaIett(new ArrayList(retorno));
boolean remover = true;
while(remover) {
remover = false;
int maiorNivelSemOcorrencia = 0;
Iterator itTodosItens = itensParaExibicao.iterator();
while(itTodosItens.hasNext()){
ItemEstruturaIett iett = (ItemEstruturaIett) itTodosItens.next();
int nivel = iett.getNivelIett().intValue();
if(nivel > maiorNivelSemOcorrencia) {
if(!itensTemp.contains(iett)) {
maiorNivelSemOcorrencia = nivel;
}
}
}
// remover os itens do �ltimo n�vel que n�o apresentam a ocorr�ncia
itTodosItens = itensParaExibicao.iterator();
while(itTodosItens.hasNext()){
ItemEstruturaIett iett = (ItemEstruturaIett) itTodosItens.next();
if(iett.getNivelIett().intValue() == maiorNivelSemOcorrencia) {
if(!itensTemp.contains(iett)) {
boolean possuiFilhoComOcorrencia = false;
Iterator itDescendentes = getDescendentes(iett, true).iterator();
while(itDescendentes.hasNext()){
ItemEstruturaIett iettFilho = (ItemEstruturaIett) itDescendentes.next();
if(itensTemp.contains(iettFilho)) {
possuiFilhoComOcorrencia = true;
break;
}
}
if(!possuiFilhoComOcorrencia) {
itTodosItens.remove();
remover = true;
}
}
}
}
}
return itensParaExibicao;
}
/**
* Devolve uma lista ordenada de nomes das imagens de nivel de planejamento.
* @author felipev
* @param item Item da estrutura
* @return List lista de Strings que representam o nome da imagem
*/
public List getNomeImgsNivelPlanejamentoItem(ItemEstruturaIett item){
List retorno = new ArrayList();
List niveisAcesso = this.getNivelAcesso(item);
if(niveisAcesso != null){
Iterator itNiveis = niveisAcesso.iterator();
while(itNiveis.hasNext()){
SisAtributoSatb nivel = (SisAtributoSatb) itNiveis.next();
/*
* comentado por causa do bug 880
*
* retorno.add("icon_" + Util.retiraAcentuacao(nivel.getDescricaoSatb().toLowerCase()) + ".png");
*/
retorno.add(nivel.getAtribInfCompSatb()); // o nome da imagem est� aqui
}
}
return retorno;
}
/**
* Devolve uma lista ordenada de nomes das imagens de nivel de planejamento, agrupadas.<br>
* Os nomes est�o encapsulados utilizando o bean NomeImgsNivelPlanejamentoBean.
*
* @author garten, aleixo
* @since N/I
* @version 0.2 - 21/05/2007; 0.1 - N/I
* @param item Item da estrutura
* @return List lista de NomeImgsNivelPlanejamentoBean que cont�m o nome e o title da imagem
*/
public List getNomeImgsNivelPlanejamentoItemAgrupado(ItemEstruturaIett item) {
/*
* Especifica��o como consta no bug #880
*
* Procedimentos da rotina que mostra a imagem no relat�rio de acompanhamento:
* 1. Para cada registro de item da estrutura selecionar todos os atributos do nivel de planejamento relacionados;
* 2. Ordenar os atributos pelos 2 primeiros d�gitos dentro de cada item
* 3. Agrupar pelo primeiro d�gito;
* 4. Montar o nome da imagem (#nome) concatenando os demais caracteres no campo de informa��es complementares (xxxxx)
* 5. Prever: Estrat�gico + T�tico, Estrat�gico + Operacional, T�tico + Operacional e ainda Estrat�gico + T�tico + Operacional.
* 6. Montar os nomes das imagens com os caracteres "icon_", mais o #nome, mais os caracteres ".PNG".
*
*/
/*
* algoritmo
*
* enquanto existir niveis de planejamento
* controlar os grupos. se trocar de grupo, guarda o nome da imagem na lista
* nome da imagem <- peda�o do nome contido em inf. complementares ex. 11est.png (est)
* fim-enquanto
*
*/
List retorno = new ArrayList();
try {
List niveisAcesso = this.getNivelAcesso(item);
if (niveisAcesso != null && !niveisAcesso.isEmpty()) {
String grupoAnterior = null;
String grupoAtual = null;
StringBuilder nomeImagem = null;
StringBuilder titleImagem = null;
String title = "";
int ultimaVirgula = 0;
int tamanho = 0;
for(Iterator it = niveisAcesso.iterator(); it.hasNext();){
SisAtributoSatb atributo = (SisAtributoSatb) it.next();
grupoAtual = atributo.getAtribInfCompSatb().substring(5, 6); // icon_x
if(!grupoAtual.equals(grupoAnterior)){
if(grupoAnterior != null){
title = String.valueOf(titleImagem.toString()).trim();
ultimaVirgula = title.lastIndexOf(',');
tamanho = title.length() - 1;
if(ultimaVirgula == tamanho){
title = title.substring(0, ultimaVirgula);
}
NomeImgsNivelPlanejamentoBean nomeImgBean = new NomeImgsNivelPlanejamentoBean(nomeImagem.append(".png").toString(), title);
retorno.add(nomeImgBean);
}
grupoAnterior = grupoAtual;
nomeImagem = new StringBuilder("icon");
titleImagem = new StringBuilder();
}
nomeImagem.append("_");
nomeImagem.append(atributo.getAtribInfCompSatb().substring(7, atributo.getAtribInfCompSatb().indexOf('.'))); //{est | ope | tat | ...}
titleImagem.append(atributo.getDescricaoSatb()).append(", ");
}
if(nomeImagem != null && titleImagem != null) {
title = String.valueOf(titleImagem.toString()).trim();
ultimaVirgula = title.lastIndexOf(',');
tamanho = title.length() - 1;
if(ultimaVirgula == tamanho){
title = title.substring(0, ultimaVirgula);
}
NomeImgsNivelPlanejamentoBean nomeImgBean = new NomeImgsNivelPlanejamentoBean(nomeImagem.append(".png").toString(), title);
retorno.add(nomeImgBean);
}
else {
NomeImgsNivelPlanejamentoBean nomeImgBean = new NomeImgsNivelPlanejamentoBean("", "");
retorno.add(nomeImgBean);
}
}
}
catch(Exception e) {
//retorno.add("erro.png");
NomeImgsNivelPlanejamentoBean nomeImgBean = new NomeImgsNivelPlanejamentoBean("erro.png", "");
retorno.add(nomeImgBean);
// a exception foi tratada aqui para n�o ocorrer problema ao mostrar a imagem
this.logger.error("N�o poss�vel montar o nome da imagem: " + e.getMessage());
}
return retorno;
}
/**
* Pesquisa na Estrutura, o m�todo realiza a pesquisa em v�rias fun��es
* do Item, somando todos os resultados encontrados num HashMap,
* indicando em quais fun��es foi encontrado o par�metro de pesquisa.
* @param request
* @param codUsu - c�digo do usu�rio logado
* @param application
* @return
* @throws ECARException
*/
public HashMap pesquisarNaEstrutura(HttpServletRequest request, Long codUsu,
ServletContext application) throws ECARException{
HashMap itensMap = new HashMap();
Mensagem properties = new Mensagem(application);
//String opcaoPesquisa = Pagina.getParamStr(request, "opcaoPesquisa");
String palavraChave = Pagina.getParamStr(request, "palavraChave").trim();
/* Pesquisa nas fun��es da estrutura */
/*
* Sempre vai pesquisar na estrutura, pq a parte da pesquisa de informa��es
* foi retirada da tela, referente ao Bug - 621.
*/
//if("E".equals(opcaoPesquisa)){
/* A data tamb�m foi ignorada na tela de pesquisa, portanto na pesquisa abaixo
* eu simplesmente passo como NULL para que na pesquisa a data seja ignorada.
*/
//Date data = Pagina.getParamDataBanco(request, "estData");
String[] estruturas = request.getParameterValues("estruturaEtt");
String todos = Pagina.getParamStr(request, "estTodos");
//itensMap = montaMapPesquisaEstrutura(palavraChave, data, estruturas, todos, codUsu, properties);
itensMap = montaMapPesquisaEstrutura(request, palavraChave, null, estruturas, todos, codUsu, properties);
//}
/* Pesquisa nas informa��es do portal
* --> Foi retirada da tela. Fica o Coment�rio para posterior informa��o.
*
if("I".equals(opcaoPesquisa)){
Date dataIni = Pagina.getParamDataBanco(request, "infDataInicial");
Date dataFim = Pagina.getParamDataBanco(request, "infDataFinal");
String[] informacoes = request.getParameterValues("informacoes");
String todos = Pagina.getParamStr(request, "infTodos");
itensMap = montaMapPesquisaInformacoes(palavraChave, dataIni, dataFim, informacoes, todos);
}*/
Iterator it = itensMap.keySet().iterator();
while(it.hasNext()){
ItemEstruturaIett item = (ItemEstruturaIett) it.next();
try{
session.refresh(item);
} catch(HibernateException e){
this.logger.error(e);
throw new ECARException(e);
}
}
return itensMap;
}
/**
* M�todo que recebe todos os resultados das pesquisas j� utilizando-se de um map
* e apenas adicionando a partir da primeira
* @param palavraChave
* @param data
* @param estruturas
* @param todos
* @return
* @throws ECARException
*/
private HashMap montaMapPesquisaEstrutura(HttpServletRequest request, String palavraChave, Date data,
String[] estruturas, String todos, Long codUsu, Mensagem properties) throws ECARException{
HashMap itensMap = new HashMap();
/* Strings que formar�o o select para cada funcao */
String select = "select item from ItemEstruturaIett as item ";
select = select + " left join fetch item.itemEstruturaIetts ";
String where = "";
boolean flag = false;
if(estruturas.length > 0){
if(!"todos".equals(todos)){
where = " where item.estruturaEtt.codEtt in (";
flag = true;
for(int i = 0; i < estruturas.length; i++){
where = where + estruturas[i];
if ((i+1) < estruturas.length)
where = where + ",";
}
where = where + ")";
}
}
if(flag) {
where = where + " and item.indAtivoIett = 'S' ";
} else {
where = where + " where item.indAtivoIett = 'S' ";
}
boolean pesquisaAvancada = ("A".equals(Pagina.getParamStr(request, "tipoPesquisa"))) ? true : false;
/* Inicio das pesquisas montando o MAP a partir da lista (resultado da pesquisa) */
if(pesquisaAvancada) {
//A��o
atualizaMapItens(request, itensMap, pesquisaEstruturaAcao(select, where, palavraChave), properties.getMensagem("item.funcao.acao"), "");
//Anexos
atualizaMapItens(request, itensMap, pesquisaEstruturaAnexo(select, where, palavraChave), properties.getMensagem("item.funcao.anexo"), "");
//Benefici�rios
atualizaMapItens(request, itensMap, pesquisaEstruturaBeneficiario(select, where, palavraChave), properties.getMensagem("item.funcao.beneficiario"), "");
//Crit�rios
atualizaMapItens(request, itensMap, pesquisaEstruturaCriterio(select, where, palavraChave), properties.getMensagem("item.funcao.criterio"), "");
//Dados B�sicos
atualizaMapItens(request, itensMap, pesquisaEstruturaDadosBasicos(select, where, palavraChave, data, pesquisaAvancada), "", "Dados B�sicos");
//Entidades
atualizaMapItens(request, itensMap, pesquisaEstruturaEntidade(select, where, palavraChave, data), properties.getMensagem("item.funcao.entidade"), "");
//Fonte de Rescurso e Recurso
atualizaMapItens(request, itensMap, pesquisaEstruturaFonteRecurso(select, where, palavraChave), properties.getMensagem("item.funcao.fonteRecurso"), "");
//Localiza��o
atualizaMapItens(request, itensMap, pesquisaEstruturaLocalizacao(select, where, palavraChave), properties.getMensagem("item.funcao.localizacao"), "");
//Marcadores
atualizaMapItens(request, itensMap, pesquisaEstruturaMarcador(select, where, palavraChave, codUsu, pesquisaAvancada), "", "Marcadores");
//Pontos Cr�ticos
atualizaMapItens(request, itensMap, pesquisaEstruturaPontoCritico(select, where, palavraChave), properties.getMensagem("item.funcao.pontoCritico"), "");
} else {
//Dados B�sicos
atualizaMapItens(request, itensMap, pesquisaEstruturaDadosBasicos(select, where, palavraChave, data, pesquisaAvancada), "", "Dados B�sicos");
}
/* fim das pesquisas *************************************************************/
return itensMap;
}
/**
* M�todo que recebe o MAP e atualiza a partir da lista passada da pesquisa
* Detalhe, se nomeFixo != "", utiliza m�todo que busca o nome da fun��o no banco
* sen�o utiliza o nomeFixo
* @param itensMap
* @param lista
* @param funcao
* @param nomeFixo
*/
private void atualizaMapItens(HttpServletRequest request, HashMap itensMap, List lista, String funcao, String nomeFixo) throws ECARException{
ValidaPermissao validaPermissao = new ValidaPermissao();
if(lista.size() > 0){
Iterator it = lista.iterator();
// corre��o do bug #1575
// Obtem o bean de seguranca para verificar se o usu�rio tem acesso a um determinado item, utilizando as
// fun��es definidas na classe de permiss�es.
// Se o usu�rio puder acessar o item, ele � inclu�do na lista, cc n�o.
// Essa abordagem parece melhor do que testar os itens apenas na p�gina, pois pode ocorrer de gastar tempo
// incluindo itens na lista sem considerar permiss�es e depois n�o poder mostrar os itens porque o usu�rio n�o tem acesso.
SegurancaECAR seguranca = (SegurancaECAR) request.getSession().getAttribute("seguranca");
while (it.hasNext()) {
ItemEstruturaIett item = (ItemEstruturaIett) it.next();
// somente inclui o item na lista se o usu�rio tem permissoes
validaPermissao.permissoesItem(item, seguranca.getUsuario(), seguranca.getGruposAcesso());
if (validaPermissao.permissaoConsultarItem()) {
Set colecao = new HashSet();
ItemFuncaoLink funcaoLink = new ItemFuncaoLink();
if(!"".equals(nomeFixo)){
funcaoLink.setNome(nomeFixo);
FuncaoDao funcaoDao = new FuncaoDao(request );
FuncaoFun funcaoDadosGerais = funcaoDao.getFuncaoDadosGerais();
if("Dados B�sicos".equals(nomeFixo))
funcaoLink.setLink("../dadosGerais/frm_con.jsp?codIett=" + item.getCodIett().toString()
+ "&codEttSelecionado=" + item.getEstruturaEtt().getCodEtt().toString()
+ "&codAba=" + funcaoDadosGerais.getCodFun().toString()
+ "&ultimoIdLinhaDetalhado=" + "iett" + item.getCodIett() + "_pai_ett" + item.getEstruturaEtt().getCodEtt());
else{
/* TODO Definir link de marcadores na pesquisa de estrutura*/
funcaoLink.setNome("marcadores");
funcaoLink.setLink("codIett=" + item.getCodIett().toString());
}
//"marcadores=" + item.getCodIett().toString()
//+ "&ultimoIdLinhaDetalhado=" + "iett" + item.getCodIett() + "_pai_ett" + item.getEstruturaEtt().getCodEtt());
}else{
EstruturaFuncaoEttf estruturaFuncao = new EstruturaFuncaoEttf();
estruturaFuncao = (EstruturaFuncaoEttf) new EstruturaFuncaoDao(request).getLabelFuncao(item.getEstruturaEtt(), Long.valueOf(funcao));
if (estruturaFuncao != null){
funcaoLink.setNome(estruturaFuncao.getLabelEttf());
funcaoLink.setLink("../" + estruturaFuncao.getFuncaoFun().getLinkFuncaoFun()
+ "?codAba=" + estruturaFuncao.getFuncaoFun().getCodFun() + "&codIett="
+ item.getCodIett()
+ "&ultimoIdLinhaDetalhado=" + "iett" + item.getCodIett() + "_pai_ett" + item.getEstruturaEtt().getCodEtt());
}
else{
funcaoLink.setNome("Dados B�sicos");
funcaoLink.setLink("../dadosGerais/frm_con.jsp?codIett=" + item.getCodIett().toString()
+ "&ultimoIdLinhaDetalhado=" + "iett" + item.getCodIett() + "_pai_ett" + item.getEstruturaEtt().getCodEtt());
}
}
if(!itensMap.containsKey(item)){
colecao.add(funcaoLink);
itensMap.put(item,colecao);
}else{
colecao.addAll( (Collection) itensMap.get(item));
colecao.add(funcaoLink);
itensMap.put(item,colecao);
}
}
}
}
}
/**
* Realiza a pesquisa na Estrutura do item em itemEstrutAcaoIetta
* @param itensMap
* @param select
* @param where
* @param palavraChave
* @throws ECARException
*/
private List pesquisaEstruturaAcao(String select, String where,
String palavraChave) throws ECARException{
try{
String joinFuncao = " left join item.itemEstrutAcaoIettas as acao";
String whereFuncao = "";
if(!"".equals(where))
whereFuncao = " and";
else
whereFuncao = " where";
whereFuncao = whereFuncao + " lower( acao.descricaoIetta ) like :palavraChave and acao.indAtivoIetta = 'S' ";
Query query = this.getSession().createQuery(select + joinFuncao + where + whereFuncao);
query.setString("palavraChave", "%" + palavraChave.toLowerCase() + "%");
return query.list();
} catch(HibernateException e){
this.logger.error(e);
throw new ECARException();
}
}
/**
* Realiza a pesquisa na Estrutura do item em itemEstrutUploadIettup
* @param itensMap
* @param select
* @param where
* @param palavraChave
* @throws ECARException
*/
private List pesquisaEstruturaAnexo(String select, String where,
String palavraChave) throws ECARException{
try{
String joinFuncao = " left join item.itemEstrutUploadIettups as anexo";
String whereFuncao = "";
if(!"".equals(where))
whereFuncao = " and";
else
whereFuncao = " where";
whereFuncao = whereFuncao + " ( lower( anexo.nomeOriginalIettup ) like :palavraChave or";
whereFuncao = whereFuncao + " lower( anexo.descricaoIettup ) like :palavraChave ) and anexo.indAtivoIettup = 'S' ";
Query query = this.getSession().createQuery(select + joinFuncao + where + whereFuncao);
query.setString("palavraChave", "%" + palavraChave.toLowerCase() + "%");
return query.list();
} catch(HibernateException e){
this.logger.error(e);
throw new ECARException();
}
}
/**
* Realiza a pesquisa na Estrutura do item em itemEstrtBenefIettb
* @param itensMap
* @param select
* @param where
* @param palavraChave
* @throws ECARException
*/
private List pesquisaEstruturaBeneficiario(String select, String where,
String palavraChave) throws ECARException{
try{
String joinFuncao = " left join item.itemEstrtBenefIettbs as beneficiario";
String whereFuncao = "";
if(!"".equals(where))
whereFuncao = " and";
else
whereFuncao = " where";
whereFuncao = whereFuncao + " ( lower( beneficiario.comentarioIettb ) like :palavraChave or";
whereFuncao = whereFuncao + " lower( beneficiario.beneficiarioBnf.nomeBnf ) like :palavraChave )";
Query query = this.getSession().createQuery(select + joinFuncao + where + whereFuncao);
query.setString("palavraChave", "%" + palavraChave.toLowerCase() + "%");
return query.list();
} catch(HibernateException e){
this.logger.error(e);
throw new ECARException();
}
}
/**
* Realiza a pesquisa na Estrutura do item em itemEstrutCriterioIettc
* @param itensMap
* @param select
* @param where
* @param palavraChave
* @throws ECARException
*/
private List pesquisaEstruturaCriterio(String select, String where,
String palavraChave) throws ECARException{
try{
String joinFuncao = " left join item.itemEstrutCriterioIettcs as criterio";
String whereFuncao = "";
if(!"".equals(where))
whereFuncao = " and";
else
whereFuncao = " where";
whereFuncao = whereFuncao + " lower( criterio.criterioCri.descricaoCri ) like :palavraChave";
Query query = this.getSession().createQuery(select + joinFuncao + where + whereFuncao);
query.setString("palavraChave", "%" + palavraChave.toLowerCase() + "%");
return query.list();
} catch(HibernateException e){
this.logger.error(e);
throw new ECARException();
}
}
/**
* Realiza a pesquisa na Estrutura do item em
* @param itensMap
* @param select
* @param where
* @param palavraChave
* @throws ECARException
*/
private List pesquisaEstruturaDadosBasicos(String select, String where,
String palavraChave, Date data, boolean pesquisaAvancada) throws ECARException{
try{
String joinFuncao = " left join item.areaAre as area";
joinFuncao = joinFuncao + " left join item.subAreaSare as subArea";
joinFuncao = joinFuncao + " left join item.orgaoOrgByCodOrgaoResponsavel1Iett as orgao1";
joinFuncao = joinFuncao + " left join item.orgaoOrgByCodOrgaoResponsavel2Iett as orgao2";
if(pesquisaAvancada){
joinFuncao = joinFuncao + " left join item.itemEstrutUsuarioIettusesByCodIett as editorLeitor";
}
joinFuncao = joinFuncao + " left join item.itemEstUsutpfuacIettutfas as funcaoAcomp";
joinFuncao = joinFuncao + " left join funcaoAcomp.usuarioUsu as usuario";
String whereFuncao = "";
if(!"".equals(where))
whereFuncao = " and";
else
whereFuncao = " where";
whereFuncao = whereFuncao + " ( lower( item.nomeIett ) like :palavraChave or";
whereFuncao = whereFuncao + " lower( item.siglaIett ) like :palavraChave or";
whereFuncao = whereFuncao + " lower( item.descricaoIett ) like :palavraChave or";
//whereFuncao = whereFuncao + " lower( item.unidadeMedia ) like :palavraChave or";
whereFuncao = whereFuncao + " lower( item.objetivoGeralIett ) like :palavraChave or";
whereFuncao = whereFuncao + " lower( item.objetivoEspecificoIett ) like :palavraChave or";
whereFuncao = whereFuncao + " lower( item.origemIett ) like :palavraChave or";
whereFuncao = whereFuncao + " lower( item.beneficiosIett ) like :palavraChave or";
/* Area */
whereFuncao = whereFuncao + " lower( area.nomeAre ) like :palavraChave or";
/* Sub-Area */
whereFuncao = whereFuncao + " lower( subArea.nomeSare ) like :palavraChave or";
/* �rg�o resp 1*/
whereFuncao = whereFuncao + " lower( orgao1.descricaoOrg ) like :palavraChave or";
whereFuncao = whereFuncao + " lower( orgao1.siglaOrg ) like :palavraChave or";
/* �rg�o resp 2*/
whereFuncao = whereFuncao + " lower( orgao2.descricaoOrg ) like :palavraChave or";
whereFuncao = whereFuncao + " lower( orgao2.siglaOrg ) like :palavraChave";
if(pesquisaAvancada){
/* Editor Leitor*/
whereFuncao = whereFuncao + " or lower( editorLeitor.usuarioUsu.nomeUsu ) like :palavraChave";
}
/* Fun��o de Acompanhamento */
whereFuncao = whereFuncao + " or lower( usuario.nomeUsu ) like :palavraChave";
if(data != null){
whereFuncao = whereFuncao + " or ( item.dataInicioIett <= :data";
whereFuncao = whereFuncao + " and item.dataTerminoIett >= :data )";
whereFuncao = whereFuncao + " or item.dataInicioMonitoramentoIett = :data";
}
//Incluir somente ativos
whereFuncao = whereFuncao + " and area.indAtivoAre = 'S'";
whereFuncao = whereFuncao + " and subArea.indAtivoSare = 'S'";
whereFuncao = whereFuncao + " and orgao1.indAtivoOrg = 'S'";
whereFuncao = whereFuncao + " and orgao2.indAtivoOrg = 'S'";
whereFuncao = whereFuncao + " )";
Query query = this.getSession().createQuery(select + joinFuncao + where + whereFuncao);
query.setString("palavraChave", "%" + palavraChave.toLowerCase() + "%");
if(data != null){
query.setDate("data", data);
}
return query.list();
} catch(HibernateException e){
this.logger.error(e);
throw new ECARException();
}
}
/**
* Realiza a pesquisa na Estrutura do item em ItemEstrutEntidadeIette
* @param itensMap
* @param select
* @param where
* @param palavraChave
* @throws ECARException
*/
private List pesquisaEstruturaEntidade(String select, String where,
String palavraChave, Date data) throws ECARException{
try{
String joinFuncao = " left join item.itemEstrutEntidadeIettes as entidade";
String whereFuncao = "";
if(!"".equals(where))
whereFuncao = " and";
else
whereFuncao = " where";
whereFuncao = whereFuncao + " ( lower( entidade.descricaoIette ) like :palavraChave or";
whereFuncao = whereFuncao + " lower( entidade.entidadeEnt.nomeEnt ) like :palavraChave or";
whereFuncao = whereFuncao + " lower( entidade.entidadeEnt.siglaEnt ) like :palavraChave";
if(data != null){
whereFuncao = whereFuncao + " or ( entidade.dataInicioIette <= :data";
whereFuncao = whereFuncao + " and entidade.dataFimIette >= :data )";
}
whereFuncao = whereFuncao + " )";
Query query = this.getSession().createQuery(select + joinFuncao + where + whereFuncao);
query.setString("palavraChave", "%" + palavraChave.toLowerCase() + "%");
if(data!= null){
query.setDate("data", data);
}
return query.list();
} catch(HibernateException e){
this.logger.error(e);
throw new ECARException();
}
}
/**
* Realiza a pesquisa na Estrutura do item em
* EfIettFonteTotEfieft -> ItemFonteRecurso
* EfItemEstPrevisaoEfieps -> ItemRecurso
* @param itensMap
* @param select
* @param where
* @param palavraChave
* @throws ECARException
*/
private List pesquisaEstruturaFonteRecurso(String select, String where,
String palavraChave) throws ECARException{
try{
String joinFuncao = " left join item.efIettFonteTotEfiefts as fonteRecurso";
joinFuncao = joinFuncao + " left join item.efItemEstPrevisaoEfieps as recurso";
String whereFuncao = "";
if(!"".equals(where))
whereFuncao = " and";
else
whereFuncao = " where";
whereFuncao = whereFuncao + " ( lower( fonteRecurso.fonteRecursoFonr.nomeFonr ) like :palavraChave or";
whereFuncao = whereFuncao + " lower( recurso.recursoRec.nomeRec ) like :palavraChave or";
whereFuncao = whereFuncao + " lower( recurso.recursoRec.siglaRec ) like :palavraChave ) and";
whereFuncao = whereFuncao + " fonteRecurso.indAtivoEfieft = 'S' and ";
whereFuncao = whereFuncao + " recurso.indAtivoEfiep = 'S' ";
Query query = this.getSession().createQuery(select + joinFuncao + where + whereFuncao);
query.setString("palavraChave", "%" + palavraChave.toLowerCase() + "%");
return query.list();
} catch(HibernateException e){
this.logger.error(e);
throw new ECARException();
}
}
/**
* Realiza a pesquisa na Estrutura do item em ItemEstrutLocalIettl
* @param itensMap
* @param select
* @param where
* @param palavraChave
* @throws ECARException
*/
private List pesquisaEstruturaLocalizacao(String select, String where,
String palavraChave) throws ECARException{
try{
String joinFuncao = " left join item.itemEstrutLocalIettls as local";
String whereFuncao = "";
if(!"".equals(where))
whereFuncao = " and";
else
whereFuncao = " where";
whereFuncao = whereFuncao + " ( lower( local.localItemLit.identificacaoLit ) like :palavraChave or";
whereFuncao = whereFuncao + " lower( local.localItemLit.localGrupoLgp.identificacaoLgp ) like :palavraChave )";
Query query = this.getSession().createQuery(select + joinFuncao + where + whereFuncao);
query.setString("palavraChave", "%" + palavraChave.toLowerCase() + "%");
return query.list();
} catch(HibernateException e){
this.logger.error(e);
throw new ECARException();
}
}
/**
* Realiza a pesquisa na Estrutura do item em ItemEstrutLocalIettl
* @param itensMap
* @param select
* @param where
* @param palavraChave
* @throws ECARException
*/
private List pesquisaEstruturaMarcador(String select, String where,
String palavraChave, Long codUsu, boolean pesquisaAvancada) throws ECARException{
try{
String joinFuncao = " left join item.itemEstrutMarcadorIettms as marcador";
if(pesquisaAvancada){
joinFuncao = joinFuncao + " left join marcador.usuarioUsu as usuario";
}
String whereFuncao = "";
if(!"".equals(where))
whereFuncao = " and";
else
whereFuncao = " where";
whereFuncao = whereFuncao + " lower( marcador.descricaoIettm ) like :palavraChave";
if(pesquisaAvancada){
whereFuncao = whereFuncao + " and usuario.codUsu = :codUsu";
}
Query query = this.getSession().createQuery(select + joinFuncao + where + whereFuncao);
query.setString("palavraChave", "%" + palavraChave.toLowerCase() + "%");
if(pesquisaAvancada){
query.setLong("codUsu", codUsu.longValue());
}
return query.list();
} catch(HibernateException e){
this.logger.error(e);
throw new ECARException();
}
}
/**
* Realiza a pesquisa na Estrutura do item em ItemEstrutLocalIettl
* @param itensMap
* @param select
* @param where
* @param palavraChave
* @throws ECARException
*/
private List pesquisaEstruturaPontoCritico(String select, String where,
String palavraChave) throws ECARException{
try{
String joinFuncao = " left join item.pontoCriticoPtcs as pontoCritico";
joinFuncao = joinFuncao + " left join pontoCritico.apontamentoApts as apontamento";
String whereFuncao = "";
if(!"".equals(where))
whereFuncao = " and";
else
whereFuncao = " where";
whereFuncao = whereFuncao + " ( lower( pontoCritico.descricaoPtc ) like :palavraChave or";
whereFuncao = whereFuncao + " lower( pontoCritico.descricaoSolucaoPtc ) like :palavraChave or";
whereFuncao = whereFuncao + " lower( apontamento.textoApt ) like :palavraChave ) and ";
whereFuncao = whereFuncao + " pontoCritico.indAtivoPtc = 'S'";
Query query = this.getSession().createQuery(select + joinFuncao + where + whereFuncao);
query.setString("palavraChave", "%" + palavraChave.toLowerCase() + "%");
return query.list();
} catch(HibernateException e){
this.logger.error(e);
throw new ECARException();
}
}
/**
* Altera um item estrutura quando clicar em Ativar/Retirar Monitoramento
* @param request
* @param usuarioLogado
* @param historico
* @return ItemEstruturaIett
* @throws ECARException
*/
public ItemEstruturaIett alterarMonitoramento(HttpServletRequest request, UsuarioUsu usuarioLogado, HistoricoIett historico) throws ECARException {
Transaction tx = null;
HistoricoItemEstruturaIett historicoItemEstruturaIett = new HistoricoItemEstruturaIett();
try{
ArrayList objetos = new ArrayList();
super.inicializarLogBean();
tx = session.beginTransaction();
ItemEstruturaIett itemEstrutura = (ItemEstruturaIett) buscar(ItemEstruturaIett.class, Long.valueOf(Pagina.getParamStr(request, "codIett")));
itemEstrutura.getItemEstUsutpfuacIettutfas().size();
String indMonitoramentoAnterior = itemEstrutura.getIndMonitoramentoIett();
ItemEstruturaIett old = (ItemEstruturaIett) itemEstrutura.clone();
/***Historico***/
historico.gerarHistorico(old);
/***Historico***/
itemEstrutura.setIndMonitoramentoIett(Pagina.getParamStr(request, "indMonitoramentoIett"));
itemEstrutura.setUsuarioUsuByCodUsuUltManutIett(usuarioLogado);
itemEstrutura.setDataUltManutencaoIett(Data.getDataAtual());
// se o usuario escolheu ativar/desativar todos os itens filhos
if("S".equals(Pagina.getParamStr(request, "ativarRetirarMonitoramentoItensFilho"))){
if(indMonitoramentoAnterior != null && !indMonitoramentoAnterior.equals(itemEstrutura.getIndMonitoramentoIett())){
this.propagarMonitoramento(itemEstrutura, historico);
}
}
session.update(itemEstrutura);
objetos.add(itemEstrutura);
historicoItemEstruturaIett.carregar(itemEstrutura);
gerarHistorico(historicoItemEstruturaIett, Historico.ALTERAR);
tx.commit();
if(super.logBean != null) {
super.logBean.setCodigoTransacao(Data.getHoraAtual(false));
super.logBean.setOperacao("ALT");
Iterator itObj = objetos.iterator();
while(itObj.hasNext()) {
super.logBean.setObj(itObj.next());
super.loggerAuditoria.info(logBean.toString());
}
}
return itemEstrutura;
} catch (HibernateException e) {
e.printStackTrace();
if (tx != null)
try {
tx.rollback();
} catch (HibernateException r) {
this.logger.error(r);
throw new ECARException("erro.hibernateException");
}
this.logger.error(e);
throw new ECARException("erro.hibernateException");
}
}
/**
* Altera um item estrutura quando clicar em Liberar/Bloquear Planejamento
* @param request
* @param usuarioLogado
* @param historico
* @return ItemEstruturaIett
* @throws ECARException
*/
public ItemEstruturaIett alterarPlanejamento(HttpServletRequest request, UsuarioUsu usuarioLogado, HistoricoIett historico) throws ECARException {
Transaction tx = null;
HistoricoItemEstruturaIett historicoItemEstruturaIett = new HistoricoItemEstruturaIett();
try{
ArrayList objetos = new ArrayList();
super.inicializarLogBean();
tx = session.beginTransaction();
ItemEstruturaIett itemEstrutura = (ItemEstruturaIett) buscar(ItemEstruturaIett.class, Long.valueOf(Pagina.getParamStr(request, "codIett")));
itemEstrutura.getItemEstUsutpfuacIettutfas().size();
String indBloqPlanejamentoAnterior = itemEstrutura.getIndBloqPlanejamentoIett();
ItemEstruturaIett old = (ItemEstruturaIett) itemEstrutura.clone();
/***Historico***/
historico.gerarHistorico(old);
/***Historico***/
itemEstrutura.setIndBloqPlanejamentoIett(Pagina.getParamStr(request, "indBloqPlanejamentoIett"));
// se o usuario escolheu bloquear/desbloquear todos os itens filhos
if("S".equals(Pagina.getParamStr(request, "bloquearDesbloquearPlanejamentoItensFilho"))){
if(indBloqPlanejamentoAnterior != null && !indBloqPlanejamentoAnterior.equals(itemEstrutura.getIndBloqPlanejamentoIett())) {
this.propagarPlanejamento(itemEstrutura, historico);
}
}
session.update(itemEstrutura);
objetos.add(itemEstrutura);
historicoItemEstruturaIett.carregar(itemEstrutura);
gerarHistorico(historicoItemEstruturaIett, Historico.ALTERAR);
tx.commit();
if(super.logBean != null) {
super.logBean.setCodigoTransacao(Data.getHoraAtual(false));
super.logBean.setOperacao("ALT");
Iterator itObj = objetos.iterator();
while(itObj.hasNext()) {
super.logBean.setObj(itObj.next());
super.loggerAuditoria.info(logBean.toString());
}
}
return itemEstrutura;
} catch (HibernateException e) {
if (tx != null)
try {
tx.rollback();
} catch (HibernateException r) {
this.logger.error(r);
throw new ECARException("erro.hibernateException");
}
this.logger.error(e);
throw new ECARException("erro.hibernateException");
}
}
/**
* Propagar Liberar/Bloquear Planejamento para os itens filhos de um item (indBloqPlanejamentoIett)
* @param itemEstruturaAtual ItemEstruturaIett contendo os dados a serem propagados
*/
private void propagarPlanejamento(ItemEstruturaIett itemEstruturaAtual, HistoricoIett historico) throws ECARException {
HistoricoItemEstruturaIett historicoItemEstruturaIett = null;
try{
List iettFilhos = this.getDescendentes(itemEstruturaAtual, false);
for (Iterator it = iettFilhos.iterator(); it.hasNext();) {
ItemEstruturaIett itemEstruturaFilho = (ItemEstruturaIett) it.next();
itemEstruturaFilho.getItemEstUsutpfuacIettutfas().size();
ItemEstruturaIett old = (ItemEstruturaIett) itemEstruturaFilho.clone();
/***Historico***/
historico.gerarHistorico(old);
/***Historico***/
itemEstruturaFilho.setIndBloqPlanejamentoIett(itemEstruturaAtual.getIndBloqPlanejamentoIett());
itemEstruturaFilho.setUsuarioUsuByCodUsuUltManutIett(itemEstruturaAtual.getUsuarioUsuByCodUsuUltManutIett());
itemEstruturaFilho.setDataUltManutencaoIett(Data.getDataAtual());
historicoItemEstruturaIett = new HistoricoItemEstruturaIett();
historicoItemEstruturaIett.carregar(itemEstruturaFilho);
gerarHistorico(historicoItemEstruturaIett, Historico.ALTERAR);
}
} catch (Exception e) {
this.logger.error(e);
throw new ECARException("erro.hibernateException");
}
}
/**
* Propagar Ativar/Retirar Monitoramento para os itens filhos de um item (indMonitoramentoIett)
* @param itemEstruturaAtual ItemEstruturaIett contendo os dados a serem propagados
*/
private void propagarMonitoramento(ItemEstruturaIett itemEstruturaAtual, HistoricoIett historico) throws ECARException {
HistoricoItemEstruturaIett historicoItemEstruturaIett = null;
try{
List iettFilhos = this.getDescendentes(itemEstruturaAtual, false);
for (Iterator it = iettFilhos.iterator(); it.hasNext();) {
ItemEstruturaIett itemEstruturaFilho = (ItemEstruturaIett) it.next();
itemEstruturaFilho.getItemEstUsutpfuacIettutfas().size();
ItemEstruturaIett old = (ItemEstruturaIett) itemEstruturaFilho.clone();
/***Historico***/
historico.gerarHistorico(old);
/***Historico***/
itemEstruturaFilho.setIndMonitoramentoIett(itemEstruturaAtual.getIndMonitoramentoIett());
itemEstruturaFilho.setUsuarioUsuByCodUsuUltManutIett(itemEstruturaAtual.getUsuarioUsuByCodUsuUltManutIett());
itemEstruturaFilho.setDataUltManutencaoIett(Data.getDataAtual());
historicoItemEstruturaIett = new HistoricoItemEstruturaIett();
historicoItemEstruturaIett.carregar(itemEstruturaFilho);
gerarHistorico(historicoItemEstruturaIett, Historico.ALTERAR);
}
} catch (Exception e) {
this.logger.error(e);
throw new ECARException("erro.hibernateException");
}
}
/**
* Ordenar uma lista de itens pelo campo SiglaIett (utilizado para visualiza��o como n�mero do item), para cada n�vel da estrutura
* Obs: Se a sigla for nula ser� ordenado pelo nome do item
*
* <b>Importante: Este m�todo s� deve ser usado para ordenar os itens do relat�rio do PPA.
* Para ordenar outros itens, utilize o m�todo getItensOrdenados();</b>
* @param itens
* @return List de itens ordenado pelo campo SiglaIett
* @throws ECARException
*/
/*
* Este m�todo s� � usado para os itens do Relat�rio de Ap�ndices do PPA.
*/
public List getItensOrdenadosPorSiglaIett(List itens) throws ECARException {
List listRetorno = new ArrayList();
List listOrdenacaoIett = new ArrayList();
Iterator it = itens.iterator();
while(it.hasNext()) {
ItemEstruturaIett iett = (ItemEstruturaIett) it.next();
OrdenacaoIett ord = new OrdenacaoIett();
ord.setIett(iett);
List ascendentes = new ArrayList(this.getAscendentes(iett));
if(ascendentes != null && ascendentes.size() > 0) {
String niveis = "";
Iterator itAux = ascendentes.iterator();
while (itAux.hasNext()) {
ItemEstruturaIett iettAux = (ItemEstruturaIett) itAux.next();
if(iettAux.getSiglaIett() != null) {
niveis += iettAux.getSiglaIett();
}
else {
niveis += iettAux.getNomeIett();
}
}
if(iett.getSiglaIett() != null) {
ord.setCampoOrdenar(niveis + iett.getSiglaIett());
}
else {
ord.setCampoOrdenar(niveis + iett.getNomeIett());
}
}
else {
if(iett.getSiglaIett() != null) {
ord.setCampoOrdenar(iett.getSiglaIett());
}
else {
ord.setCampoOrdenar(iett.getNomeIett());
}
}
if(ord.getCampoOrdenar() == null) {
ord.setCampoOrdenar("");
}
listOrdenacaoIett.add(ord);
}
Collections.sort(listOrdenacaoIett,
new Comparator() {
public int compare(Object o1, Object o2) {
OrdenacaoIett ord1 = (OrdenacaoIett) o1;
OrdenacaoIett ord2 = (OrdenacaoIett) o2;
return ord1.getCampoOrdenar().compareToIgnoreCase(ord2.getCampoOrdenar());
}
}
);
it = listOrdenacaoIett.iterator();
while(it.hasNext()){
OrdenacaoIett ord = (OrdenacaoIett) it.next();
listRetorno.add(ord.getIett());
}
return listRetorno;
}
/**
* Ordena os itens de acordo com o que foi definido nas configura��es de tipo de Acompanhamento.
*
* @param itens
* @param tipoAcomp
* @return List
* @throws ECARException
*/
public List getItensOrdenados(List itens, TipoAcompanhamentoTa tipoAcomp,boolean montarHierarquia) throws ECARException {
List listRetorno = new ArrayList();
EstruturaAtributoDao estruturaAtributoDao = new EstruturaAtributoDao(null);
/*
* 1) Pegar qual os campos de ordena��o que � apresentado em cada estrutura.
* Ordenar campos da estrutura (EstruturaAtributo) pela
* sequencia de apresenta��o (seqApresListagemTelaEttat) e pegar o primeiro
* campo que possuir Listagem Impressa Rela��o (indRelacaoImpressaEttat) = "S".
* Se uma estrutura n�o estiver apresentada neste filtro informado, assume que
* o Primeiro Atributo Valido desta estrutura � o CodIett.
*/
List estruturasAtributos = estruturaAtributoDao.getAtributosValidoEstruturas(tipoAcomp);
//Descubro o maior length dos campos dos itens para preencher com ZEROS para ordena��o.
int tamanho = this.getTamanhoMaximoAtributoEstruturaItem(estruturasAtributos, itens, tipoAcomp);
for(Iterator it = itens.iterator(); it.hasNext();){
ItemEstruturaIett iett = (ItemEstruturaIett) it.next();
if(iett.getIndAtivoIett() != null && !Dominios.SIM.equals(iett.getIndAtivoIett())){
it.remove();
}
}
// montar a �rvore completa de itens
List listItensComPais = null;
Iterator itItens = null;
//verifica se � necess�rio montar hierarquia.
if (montarHierarquia) {
listItensComPais = new ArrayList(this.getArvoreItens(itens, null));
itItens = listItensComPais.iterator();
} else {
itItens = itens.iterator();
}
// montar os objetos OrdenacaoIett
List listNiveis = new ArrayList();
List listOrdenacaoIett = new ArrayList();
List<EstruturaEtt> listEstruturas = new ArrayList<EstruturaEtt>();
while(itItens.hasNext()) {
ItemEstruturaIett iett = (ItemEstruturaIett) itItens.next();
if(iett.getIndAtivoIett() != null && !Dominios.SIM.equals(iett.getIndAtivoIett())){
continue;
}
OrdenacaoIett ord = new OrdenacaoIett();
ord.setIett(iett);
if(!listNiveis.contains(iett.getNivelIett())) {
listNiveis.add(iett.getNivelIett());
}
if (!listEstruturas.contains(iett.getEstruturaEtt())){
listEstruturas.add(iett.getEstruturaEtt());
}
ord.setCampoOrdenar(this.getValorAtributoEstruturaItem(estruturasAtributos, iett, tamanho, tipoAcomp));
if(ord.getCampoOrdenar() == null) {
ord.setCampoOrdenar("");
}
listOrdenacaoIett.add(ord);
}
// ordenar a lista de OrdenacaoIett, aplicando regra de ordenamento
Collections.sort(listOrdenacaoIett,
new Comparator() {
public int compare(Object o1, Object o2) {
OrdenacaoIett ord1 = (OrdenacaoIett) o1;
OrdenacaoIett ord2 = (OrdenacaoIett) o2;
return Util.retiraAcentuacao(ord1.getCampoOrdenar().toLowerCase().trim()).compareToIgnoreCase(Util.retiraAcentuacao(ord2.getCampoOrdenar()).toLowerCase().trim());
}
}
);
// ordenar a lista de n�veis: 1, 2, 3, ... n
Collections.sort(listNiveis,
new Comparator() {
public int compare(Object o1, Object o2) {
Integer ord1 = (Integer) o1;
Integer ord2 = (Integer) o2;
return ord1.compareTo(ord2);
}
}
);
// ordenar a lista de estruturas por label
Collections.sort(listEstruturas,
new Comparator() {
public int compare(Object o1, Object o2) {
EstruturaEtt ord1 = (EstruturaEtt) o1;
EstruturaEtt ord2 = (EstruturaEtt) o2;
return ord1.getNomeEtt().compareTo(ord2.getNomeEtt());
}
}
);
// Gerar uma lista de itens para cada n�vel
List listOrdenacaoPorNivel = new ArrayList();
Iterator itNiveis = listNiveis.iterator();
Iterator<EstruturaEtt> itEstruturas = listEstruturas.iterator();
while(itNiveis.hasNext()) {
Integer nivel = (Integer) itNiveis.next();
OrdenacaoPorNivel opn = new OrdenacaoPorNivel();
opn.setNivel(nivel);
opn.setOrdenacaoIett(new ArrayList());
itEstruturas = listEstruturas.iterator();
//varre cada estrutura dos itens da listagem
while (itEstruturas.hasNext()){
EstruturaEtt estrutura = itEstruturas.next();
itItens = listOrdenacaoIett.iterator();
//varre todos os itens da listagem e virifica se eles s�o do n�vel corrente e da estrutura corrente
while(itItens.hasNext()) {
OrdenacaoIett ord = (OrdenacaoIett)itItens.next();
if(nivel.equals(ord.getIett().getNivelIett()) && estrutura.equals(ord.getIett().getEstruturaEtt())) {
opn.getOrdenacaoIett().add(ord);
}
}
}
if (!listOrdenacaoPorNivel.contains(opn)){
listOrdenacaoPorNivel.add(opn);
}
}
// ordenar a lista de OrdenacaoPorNivel, aplicando regra de ordenamento
// itNiveis = listOrdenacaoPorNivel.iterator();
// while(itNiveis.hasNext()) {
// OrdenacaoPorNivel opn = (OrdenacaoPorNivel) itNiveis.next();
//
// //Ordena primeiro por nome da estrutura estrutura
// Collections.sort(opn.getOrdenacaoIett(),
// new Comparator() {
// public int compare(Object o1, Object o2) {
// OrdenacaoIett ord1 = (OrdenacaoIett) o1;
// OrdenacaoIett ord2 = (OrdenacaoIett) o2;
//
// return Util.retiraAcentuacao(ord1.getIett().getEstruturaEtt().getLabelEtt().toLowerCase().trim()).compareToIgnoreCase(
// Util.retiraAcentuacao(ord2.getIett().getEstruturaEtt().getLabelEtt()).toLowerCase().trim());
// }
// }
// );
// }
Iterator it = null;
//verifica se � necess�rio montar hierarquia.
if (montarHierarquia) {
// organizar os itens de acordo com a hierarquia de pai/filho/neto/bisneto/etc a partir dos itens do primeiro n�vel
List itensOrganizados = new ArrayList();
if(!listOrdenacaoPorNivel.isEmpty()) {
OrdenacaoPorNivel opn = (OrdenacaoPorNivel)listOrdenacaoPorNivel.get(0);
itNiveis = opn.getOrdenacaoIett().iterator();
while(itNiveis.hasNext()) {
OrdenacaoIett ord = (OrdenacaoIett)itNiveis.next();
List listIettAux = getItemFilhoOrdenacaoPorNivel(ord.getIett(), listOrdenacaoPorNivel);
itensOrganizados.addAll(listIettAux);
}
}
it = itensOrganizados.iterator();
} else {//Sen�o for necess�rio montar hierarquia, utiliza a lista(listOrdenacaoPorNivel) que j� est� ordenada.
/*
* Extrai do objeto bean de ordena��o os itens que ser�o exibidos.
*/
List<ItemEstruturaIett> listaItensTemp = new ArrayList<ItemEstruturaIett>();
itNiveis = listOrdenacaoPorNivel.iterator();
//itera na lista ordenada
while(itNiveis.hasNext()) {
OrdenacaoPorNivel opn = (OrdenacaoPorNivel) itNiveis.next();
//Obtem a lista beans(OrdenacaoIett) por nivel.
Iterator itInnerItens = opn.getOrdenacaoIett().iterator();
while(itInnerItens.hasNext()) {
//obtem o bean(OrdenacaoIett) que encapsula o objeto de neg�cio(ItemEstruturaIett)
OrdenacaoIett ordenacaoIett = (OrdenacaoIett) itInnerItens.next();
listaItensTemp.add(ordenacaoIett.getIett());
}
}
it = listaItensTemp.iterator();
}
while(it.hasNext()){
ItemEstruturaIett iett = (ItemEstruturaIett) it.next();
AtributoEstruturaListagemItens atEstListagem = new AtributoEstruturaListagemItens();
atEstListagem.setDescricao(estruturaAtributoDao.getDescricaoItemByAtributo(iett, tipoAcomp));
atEstListagem.setItem(iett);
listRetorno.add(atEstListagem);
}
return listRetorno;
}
/**
* Obter pr�ximo item filho de um item e seus netos/bisnetos/etc a partir de uma lista de OrdenacaoPorNivel
* @param iett
* @param listOrdenacaoPorNivel
* @return List de Iett
* @throws ECARException
*/
private List getItemFilhoOrdenacaoPorNivel(ItemEstruturaIett iett, List listOrdenacaoPorNivel) throws ECARException {
List retorno = new ArrayList();
retorno.add(iett);
Iterator it = listOrdenacaoPorNivel.iterator();
while(it.hasNext()){
OrdenacaoPorNivel opn = (OrdenacaoPorNivel) it.next();
Iterator itItens = opn.getOrdenacaoIett().iterator();
while(itItens.hasNext()){
OrdenacaoIett ord = (OrdenacaoIett) itItens.next();
if(iett.equals(ord.getIett().getItemEstruturaIett())) {
retorno.addAll(getItemFilhoOrdenacaoPorNivel(ord.getIett(), listOrdenacaoPorNivel));
}
}
}
return retorno;
}
/**
* completa para ordena��o
* @param valor
* @param tamanho
* @return String
*/
private String completarParaOrdenacao(String valor, int tamanho){
String completar = "E";
try{
Long dummy = Long.valueOf(valor); //se conseguiu transformar, � n�mero - completar zeros � esquerda
}
catch (NumberFormatException e) {
// ATEN��O: N�o � neces�rio lancar exce��o aqui
// n�o conseguiu transformar, n�o � n�mero - completar zeros � direita
completar = "D";
}
return Util.completarCaracteres(valor, "0", tamanho, completar);
}
/**
* Retorna o valor do atributo da estrutura.
* @param atributosEstruturas
* @param iett
* @return
* @throws ECARException
*/
private String getValorAtributoEstruturaItem(List atributosEstruturas, ItemEstruturaIett iett, int tamanho, TipoAcompanhamentoTa ta) throws ECARException{
StringBuilder retorno = new StringBuilder("");
//flag que aponta se um tipo de acompanhamento espec�fico tem algum atributo configurado para a determinada estrutura
boolean temItemConfigurado = false;
if(atributosEstruturas != null && !atributosEstruturas.isEmpty()){
Iterator it = atributosEstruturas.iterator();
while(it.hasNext()){
AtributoEstruturaBean aeBean = (AtributoEstruturaBean) it.next();
// if(iett.getEstruturaEtt().getIndAtivoEtt().equals("S") && iett.getEstruturaEtt().equals(aeBean.getEstrutura())){
if (iett.getEstruturaEtt().equals(aeBean.getEstrutura())){
temItemConfigurado = true;
String campo = this.getValorAtributoItemEstrutura(iett, aeBean.getAtributo().getAtributosAtb().getNomeAtb(), aeBean.getAtributo().getAtributosAtb().getNomeFkAtb()).trim();
//Retorna os campos com atributos livre configurados
if (campo.equals("") && aeBean.getAtributo().getAtributosAtb()!= null && aeBean.getAtributo().getAtributosAtb().getSisGrupoAtributoSga()!= null ){
List<SisAtributoSatb> listSisAtributo = this.getSisAtributosIett(iett, aeBean.getAtributo().getAtributosAtb().getSisGrupoAtributoSga().getCodSga());
if (listSisAtributo != null && listSisAtributo.size() > 0){
campo = listSisAtributo.get(0).getDescricaoSatb();
}
}
// campo = aeBean.getAtributo().getAtributosAtb().getSisGrupoAtributoSga().getDescricaoSga();
/*
* Verifica��o ref mantis 9959:
* Se for um campo que consiga converter para data,
* ent�o deve-se gerar uma string com yyyyMMdd
* para que a ordena��o fique correta.
*
* Se n�o conseguir converter para data, � outro tipo de campo. Ent�o fica como est�.
*/
Date data = Data.parseDate(campo, "dd/MM/yyyy");
if(data != null){ //� campo data!
//Conseguiu converter para objeto Date!!!
int d = Data.getDia(data);
int m = Data.getMes(data) + 1;
int a = Data.getAno(data);
String dia = (d < 10) ? "0" + String.valueOf(d) : String.valueOf(d);
String mes = (m < 10) ? "0" + String.valueOf(m) : String.valueOf(m);
String ano = String.valueOf(a);
campo = ano + mes + dia;
}
retorno.append(this.completarParaOrdenacao(campo, tamanho));
}
}
}
else
{
StringBuilder msg = new StringBuilder("N�o foi poss�vel obter a configura��o de atributo na estrutura.");
if(ta != null) {
msg.append(" Tipo de acompanhamento: " + ta.getDescricaoTa() + ".");
}
msg.append(" Efetue a configura��o da Estrutura: " + iett.getEstruturaEtt().getNomeEtt());
throw new ECARException(msg.toString());
}
if (!temItemConfigurado)
{
StringBuilder msg = new StringBuilder("N�o foi poss�vel obter a configura��o de atributo na estrutura.");
if(ta != null) {
msg.append(" Tipo de acompanhamento: " + ta.getDescricaoTa() + ".");
}
msg.append(" Efetue a configura��o da Estrutura: " + iett.getEstruturaEtt().getNomeEtt());
throw new ECARException(msg.toString());
}
boolean estruturaAbaixoNivelGeracao = true;
if(ta!=null){
estruturaAbaixoNivelGeracao = verificaNivelHierarquicoEstrutura(ta.getEstruturaNivelGeracaoTa(), iett.getEstruturaEtt());
}
if(estruturaAbaixoNivelGeracao && "".equals(retorno.toString()) && iett.getEstruturaEtt().getIndAtivoEtt().equals("S")) {
//Se n�o houver configura��o, lan�ar exce��o!!!!!!!!!!!!!!!!
/* StringBuilder msg = new StringBuilder("N�o foi poss�vel obter a configura��o de atributo na estrutura.");
if(ta != null) {
msg.append(" Tipo de acompanhamento: " + ta.getDescricaoTa() + ".");
}
msg.append(" Efetue a configura��o da Estrutura: " + iett.getEstruturaEtt().getNomeEtt());*/
StringBuilder msg = new StringBuilder("N�o foi poss�vel gerar o per�odo. Existem itens sem valores informados para o campo configurado para apresenta��o.");
throw new ECARException(msg.toString());
} else {
return retorno.toString();
}
}
/**
*
* Verifica se uma estrutura pertence ao n�vel hier�rquico de outra, que representa uma configura��o no tipo de acompanhamento.
* Retorna verdadeiro caso essa configura��o n�o esteja apontando nenhuma estrutura como n�vel.
*
* @param estruturaNivel
* @param estruturaItem
* @return boolean
* @throws ECARException
*/
public boolean verificaNivelHierarquicoEstrutura(EstruturaEtt estruturaNivel, EstruturaEtt estruturaItem) throws ECARException{
boolean estruturaAbaixoNivelGeracao = true;
EstruturaDao estruturaDao = new EstruturaDao(request);
if (estruturaNivel != null){
estruturaAbaixoNivelGeracao = false;
EstruturaEtt estruturaTa = (EstruturaEtt)estruturaDao.buscar(EstruturaEtt.class, estruturaNivel.getCodEtt());
List descendentesEstruturaTa = estruturaDao.getDescendentes(estruturaTa);
List ascendentesEstruturaTa = estruturaDao.getAscendentes(estruturaTa);
//Verifica se a estrutura do item est� abaixo do n�vel hier�rquico da estrutura estabelecida para gera��o de per�odos no Tipo de Acompanhamento
if (estruturaItem.equals(estruturaNivel) || descendentesEstruturaTa.contains(estruturaItem) || ascendentesEstruturaTa.contains(estruturaItem)){
estruturaAbaixoNivelGeracao = true;
}
}
return estruturaAbaixoNivelGeracao;
}
/**
* Percorre a lista de itens verificando qual o atributo tem o maior length para
* ser usado no m�todo de ordena��o.
* @param estruturasAtributos
* @param itens
* @param ta
* @return
* @throws ECARException
*/
private int getTamanhoMaximoAtributoEstruturaItem(List estruturasAtributos, List itens, TipoAcompanhamentoTa ta) throws ECARException {
int retorno = 0;
for (Iterator iter = itens.iterator(); iter.hasNext();) {
ItemEstruturaIett iett = (ItemEstruturaIett) iter.next();
String strAux = this.getValorAtributoEstruturaItem(estruturasAtributos, iett, -1, ta);
if(strAux.length() > retorno){
retorno = strAux.length();
}
}
return retorno;
}
/*
private int getTamanhoMaximoAtributoEstruturaItem(List estruturasAtributos, List itens) throws ECARException{
Iterator it = itens.iterator();
int retorno = 0;
while(it.hasNext()) {
ItemEstruturaIett iett = (ItemEstruturaIett) it.next();
List ascendentes = new ArrayList(this.getAscendentes(iett));
if(ascendentes != null && ascendentes.size() > 0) {
Iterator itAux = ascendentes.iterator();
while (itAux.hasNext()) {
ItemEstruturaIett iettAux = (ItemEstruturaIett) itAux.next();
String strAux = this.getValorAtributoEstruturaItem(estruturasAtributos, iettAux);
if(strAux.length() > retorno){
retorno = strAux.length();
}
}
}
else {
String strAux = this.getValorAtributoEstruturaItem(estruturasAtributos, iett);
if(strAux.length() > retorno){
retorno = strAux.length();
}
}
}
return retorno;
}
*/
/**
* Verifica se o item possui uma determinada situacao
* nas listas de c�digos de situacoes.
*
* @param itemEstrutura
* @param idSituacoes
* @return boolean
* @throws ECARException
*/
public boolean verificarSituacao(ItemEstruturaIett itemEstrutura, List idSituacoes) throws ECARException{
if(itemEstrutura != null && itemEstrutura.getSituacaoSit() != null
&& idSituacoes != null && idSituacoes.size() > 0){
for (Iterator itSituacoes = idSituacoes.iterator(); itSituacoes.hasNext();) {
String codSit = (String) itSituacoes.next();
if(codSit.equals(itemEstrutura.getSituacaoSit().getCodSit().toString()))
return true;
}
}
return false;
}
/**
* Filtra uma lista de ItemEstruturaIetts
*
* @param listaIett
* @param codOrgao
* @param criteriosCom
* @param criteriosSem
* @param situacoes
* @param revisao - utilize "S" para filtrar s� os itens que possuem revis�o
* @param submitPPA - utilize "S" para filtrar s� os itens que possuem PPA
* @return List
* @throws ECARException
*/
public List filtrarRelatorioItemEstrutura (List listaIett, Long codOrgao, List criteriosCom, List criteriosSem, List situacoes, String revisao, String submitPPA) throws ECARException{
ItemEstruturaCriterioDao itemCriterioDao = new ItemEstruturaCriterioDao(request);
SisAtributoDao sisAtributoDao = new SisAtributoDao(request);
Iterator itIetts = listaIett.iterator();
while(itIetts.hasNext()){
ItemEstruturaIett iett = (ItemEstruturaIett) itIetts.next();
/*Verificando itens com revis�o...*/
if("S".equals(revisao)){
if(!(iett.getItemEstruturarevisaoIettrevs() != null && iett.getItemEstruturarevisaoIettrevs().size() > 0)){
itIetts.remove();
continue;
}
}
/*Verificando itens com PPA*/
if("S".equals(submitPPA)){
boolean possuiNivelPPA = false;
List niveisPlanejamento = getNivelAcessoById(iett);
Iterator itNiveis = niveisPlanejamento.iterator();
while(itNiveis.hasNext()){
Long codSatb = (Long) itNiveis.next();
SisAtributoSatb nivel = (SisAtributoSatb) sisAtributoDao.buscar(SisAtributoSatb.class, codSatb);
if(nivel != null && "PPA".equals(nivel.getDescricaoSatb())){//N�o foi usado o codSatb para testar devido �s diferen�as de c�digos em Produ��o e Desenvolvimento
possuiNivelPPA = true;
break;
}
}
if(!possuiNivelPPA){
itIetts.remove();
continue;
}
}
/*Verificando �rg�os...*/
if(codOrgao != null){
if(iett.getOrgaoOrgByCodOrgaoResponsavel1Iett() != null){
if(!codOrgao.equals(iett.getOrgaoOrgByCodOrgaoResponsavel1Iett().getCodOrg())){
itIetts.remove();
continue;
}
}
}
/*Verificando Crit�rios...*/
if((criteriosCom != null && criteriosCom.size() > 0) || (criteriosSem != null && criteriosSem.size() > 0)){
if(!itemCriterioDao.verificarCriterio(iett, criteriosCom, criteriosSem)){
itIetts.remove();
continue;
}
}
/*Verificando Situa��es...*/
if(situacoes != null && situacoes.size() > 0){
if(!this.verificarSituacao(iett, situacoes)){
itIetts.remove();
continue;
}
}
}
return listaIett;
}
/**
* Retorna itens filtrados pela listagem de criterios
* @param itens
* @param idCriteriosCom
* @param idCriteriosSem
* @return
* @throws ECARException
*/
public List filtrarItensPorCriterio(ArrayList<ItemEstruturaIettPPA> itens, ArrayList<String> idCriteriosCom, ArrayList<String> idCriteriosSem) throws ECARException{
final ItemEstruturaCriterioDao itemCriterioDao = new ItemEstruturaCriterioDao(request);
List tmp = itens;
for (Iterator iter = tmp.iterator(); iter.hasNext();) {
ItemEstruturaIett item = (ItemEstruturaIett) iter.next();
if(!itemCriterioDao.verificarCriterio(item, idCriteriosCom, idCriteriosSem)){
iter.remove();
continue;
}
}
return tmp;
}
/**
* Retorna uma Lista de todos os ItemEstruraRevisaoIettrev de um ItemEstruturaIett
* ordenados por Data
*
* @param codIett
* @return
* @throws ECARException
*/
public List getItemEstruturaRevisaoIettrevOrderByData(Long codIett) throws ECARException{
try{
StringBuilder qry = new StringBuilder("select iettRev")
.append(" from ItemEstruturarevisaoIettrev as iettRev")
.append(" where iettRev.itemEstruturaIettrev.codIett = :codigo")
.append(" order by iettRev.dataInclusaoIettrev");
Query q = this.session.createQuery(qry.toString());
q.setLong("codigo", codIett.longValue());
return q.list();
}
catch (HibernateException e){
this.logger.error(e);
throw new ECARException("erro.hibernateException");
}
}
/**
* Recupera Itens de programa para o relatorio PPA
* @param periodoIni Data de inicio para geracao do relatorio
* @param periodoFim Data de termino para geracao do relatorio
* @return Listagem de Itens de Programa <ItemEstruturaIett>
* @throws ECARException
*/
public List getItensPPA(String periodoIni, String periodoFim ) throws ECARException {
try{
SisAtributoDao sisAtributoDao = new SisAtributoDao(request);
List retorno = new ArrayList();
StringBuilder qry = new StringBuilder("from ItemEstruturaIett as iett")
.append(" where ")
//" iett.nivelIett = :nivelProduto and" +
.append(" iett.dataInicioIett >= :dataIni")
.append(" and iett.indAtivoIett = 'S'")
.append(" and (iett.dataTerminoIett is null or iett.dataTerminoIett <= :dataFim)");
Query q = this.session.createQuery(qry.toString());
Date dataIni = Data.parseDate("01/01/" + periodoIni);
Date dataFim = Data.parseDate("31/12/" + periodoFim);
//q.setInteger("nivelProduto", 4);
q.setDate("dataIni", dataIni);
q.setDate("dataFim", dataFim);
List itens = new ArrayList(q.list());
if(itens != null && itens.size() > 0){
Iterator itRet = itens.iterator();
while(itRet.hasNext()){
ItemEstruturaIett iett = (ItemEstruturaIett) itRet.next();
boolean possuiNivelPPA = false;
List niveisPlanejamento = getNivelAcessoById(iett);
Iterator itNiveis = niveisPlanejamento.iterator();
while(itNiveis.hasNext()){
Long codSatb = (Long) itNiveis.next();
SisAtributoSatb nivel = (SisAtributoSatb) sisAtributoDao.buscar(SisAtributoSatb.class, codSatb);
// N�o foi usado o codSatb para testar devido �s diferen�as de
// c�digos em Produ��o e Desenvolvimento
if(nivel != null && "PPA".equals(nivel.getDescricaoSatb())){
possuiNivelPPA = true;
break;
}
}
if(possuiNivelPPA){
retorno.add(iett);
}
}
}
return getItensOrdenadosPorSiglaIett(getArvoreItens(retorno, null));
}
catch (HibernateException e){
this.logger.error(e);
throw new ECARException("erro.hibernateException");
}
}
/**
* Retorna uma lista de ItemEstruturaIett ordenados pelos c�digos dos pais e cujos pais est�o contidos na lista passada por par�metro
*
* @param codEstrutura
* @param codItensPais
* @return List de ItemEstruturaIett
* @throws ECARException
*/
public List getItensByEstruturaOrdenadosPorItemPai(Long codEstrutura, List codItensPais) throws ECARException {
try{
StringBuilder qry = new StringBuilder("from ItemEstruturaIett as iett")
.append(" where ")
.append(" iett.indAtivoIett = 'S' and ")
.append(" iett.estruturaEtt.codEtt = :codEtt and (");
Iterator codItensPaisIt = codItensPais.iterator();
while (codItensPaisIt.hasNext()){
Long codPai = (Long) codItensPaisIt.next();
qry.append(" iett.itemEstruturaIett.codIett = " + codPai + " or");
}
StringBuilder newQry = new StringBuilder(qry.substring(0, qry.length()-2));
newQry.append(")");
newQry.append(" order by iett.itemEstruturaIett.codIett, iett.nomeIett");
Query q = this.session.createQuery(newQry.toString());
q.setLong("codEtt", codEstrutura.longValue());
return q.list();
}
catch (HibernateException e){
this.logger.error(e);
throw new ECARException("erro.hibernateException");
}
}
public List getItensAtivosByEstrutura(Long codEstrutura) throws ECARException {
try{
StringBuilder qry = new StringBuilder("from ItemEstruturaIett as iett")
.append(" where ")
.append(" iett.indAtivoIett = 'S' and ")
.append(" iett.estruturaEtt.codEtt = :codEtt");
Query q = this.session.createQuery(qry.toString());
q.setLong("codEtt", codEstrutura.longValue());
return q.list();
}
catch (HibernateException e){
this.logger.error(e);
throw new ECARException("erro.hibernateException");
}
}
/**
* Retorna uma lista de ItemEstruturaIett ordenados pelos c�digos dos pais
*
* @param itens
* @return List de ItemEstruturaIett
* @throws ECARException
*/
public List<ItemEstruturaIett> getItensOrdenadosPorItemPai(Set itens) throws ECARException {
try{
StringBuilder qry = new StringBuilder("from ItemEstruturaIett as iett")
.append(" where ")
.append(" iett.indAtivoIett = 'S' and ")
.append(" iett.codIett in (:listCodIett) ");
qry.append(" order by iett.itemEstruturaIett.codIett, iett.nomeIett");
Query q = this.session.createQuery(qry.toString());
List<Long> listaCodigosIett = new ArrayList<Long>();
for (Iterator iter = itens.iterator(); iter.hasNext();) {
ItemEstruturaIett item = (ItemEstruturaIett) iter.next();
listaCodigosIett.add(item.getCodIett());
}
q.setParameterList("listCodIett", listaCodigosIett);
return q.list();
}
catch (HibernateException e){
this.logger.error(e);
throw new ECARException("erro.hibernateException");
}
}
/**
*
* @param codEstrutura
* @return
* @throws ECARException
*/
public List getItensByEstrutura(Long codEstrutura) throws ECARException {
try{
StringBuilder qry = new StringBuilder("from ItemEstruturaIett as iett")
.append(" where ")
.append(" iett.indAtivoIett = 'S' and ")
.append(" iett.estruturaEtt.codEtt = :codEtt")
.append(" order by iett.itemEstruturaIett.codIett, iett.nomeIett");
Query q = this.session.createQuery(qry.toString());
q.setLong("codEtt", codEstrutura.longValue());
return q.list();
}
catch (HibernateException e){
this.logger.error(e);
throw new ECARException("erro.hibernateException");
}
}
/**
*
* @param codEstrutura
* @return
* @throws ECARException
*/
public List getItensByEstruturaPPA(Long codEstrutura) throws ECARException {
try{
StringBuilder qry = new StringBuilder("from ItemEstruturaIettPPA as iett")
.append(" where ")
.append(" iett.indAtivoIett = 'S' and ")
.append(" iett.estruturaEtt.codEtt = :codEtt")
.append(" order by iett.nomeIett ");
Query q = this.session.createQuery(qry.toString());
q.setLong("codEtt", codEstrutura.longValue());
return q.list();
}
catch (HibernateException e){
this.logger.error(e);
throw new ECARException("erro.hibernateException");
}
}
/**
* Listar somente itens com revis�o.
* @param tipoApendice
* @param periodoIni
* @param periodoFim
* @return List
* @throws ECARException
*/
/*
* Este m�todo s� � usado nos Relat�rio dos Ap�ndices do PPA
*/
public List getArvoreItensIettComRevisao(String tipoApendice, String periodoIni, String periodoFim) throws ECARException {
try{
SisAtributoDao sisAtributoDao = new SisAtributoDao(request);
List retorno = new ArrayList();
StringBuilder qry = new StringBuilder("from ItemEstruturaIett as iett")
.append(" where ")
//" iett.nivelIett = :nivelProduto and" +
.append(" iett.indAtivoIett = 'S'")
.append(" and iett.dataInicioIett >= :dataIni")
.append(" and (iett.dataTerminoIett is null or iett.dataTerminoIett <= :dataFim)");
Query q = this.session.createQuery(qry.toString());
Date dataIni = Data.parseDate("01/01/" + periodoIni);
Date dataFim = Data.parseDate("31/12/" + periodoFim);
//q.setInteger("nivelProduto", 4);
q.setDate("dataIni", dataIni);
q.setDate("dataFim", dataFim);
List itens = new ArrayList(q.list());
if(itens != null && itens.size() > 0){
Iterator itRet = itens.iterator();
while(itRet.hasNext()){
ItemEstruturaIett iett = (ItemEstruturaIett) itRet.next();
boolean possuiNivelPPA = false;
List niveisPlanejamento = getNivelAcessoById(iett);
Iterator itNiveis = niveisPlanejamento.iterator();
while(itNiveis.hasNext()){
Long codSatb = (Long) itNiveis.next();
SisAtributoSatb nivel = (SisAtributoSatb) sisAtributoDao.buscar(SisAtributoSatb.class, codSatb);
if(nivel != null && "PPA".equals(nivel.getDescricaoSatb())){//N�o foi usado o codSatb para testar devido �s diferen�as de c�digos em Produ��o e Desenvolvimento
possuiNivelPPA = true;
break;
}
}
if(possuiNivelPPA){
retorno.add(iett);
}
}
}
/* Esta parte foi comentada pois, ref. mantis 5042, o sistema
* buscar� todos os campos na estrutura normal dos itens do eCAr,
segmentoCategoria.setSegmentoCategTpAcessSgts(new HashSet());
if(!segmentoCategoria.getSegmentoCategTpAcessSgts().contains(atributo)){
segmentoCategoria.getSegmentoCategTpAcessSgts().add(atributo);
}
* ignorando portanto a tabela revis�o.
*
List itens = new ArrayList(q.list());
if(itens != null && itens.size() > 0){
Iterator itRet = itens.iterator();
while(itRet.hasNext()){
ItemEstruturaIett iett = (ItemEstruturaIett) itRet.next();
List itensRev = new ArrayList(iett.getItemEstruturarevisaoIettrevs());
Iterator itRev = itensRev.iterator();
while(itRev.hasNext()){
ItemEstruturarevisaoIettrev iettRev = (ItemEstruturarevisaoIettrev) itRev.next();
if("apendice2".equals(tipoApendice)){
//if("I".equals(iettRev.getSituacaoIettrev()) || "A".equals(iettRev.getSituacaoIettrev())){
if(!"E".equals(iettRev.getSituacaoIettrev())){
retorno.add(iett);
break;arg0
}
}
else if("apendice3".equals(tipoApendice)){
if("E".equals(iettRev.getSituacaoIettrev())){
retorno.add(iett);
break;
}
}
}
}
}*/
return getItensOrdenadosPorSiglaIett(getArvoreItens(retorno, null));
}
catch (HibernateException e){
this.logger.error(e);
throw new ECARException("erro.hibernateException");
}
}
/**
* Retorna lista de Itens da Estrutura de acordo com a data dataTerminoIett, dataInicioIett, dataR1, dataR2, dataR3, dataR4, dataR5. <br>
* @author rogerio
* @version 0.1, 09/02/2007
* @param dataLimiteStr
* @return List
* @throws ECARException
*/
public List listarItemEstruturaPorDataLimite(String dataLimiteStr) throws ECARException {
List list = null;
try {
Query query = session.createQuery(
" from ItemEstruturaIett " +
" where indAtivoIett = 'S' and dataTerminoIett = :data or dataInicioIett = :data " +
" or dataR1 = :data or dataR2 = :data or dataR3 = :data " +
" or dataR4 = :data or dataR5 = :data ");
Date data = Data.parseDate(dataLimiteStr);
query.setDate("data", data);
list = query.list();
} catch( HibernateException e ) {
this.logger.error(e);
throw new ECARException("erro.hibernateException");
}
return list;
} // fim listarItemEstruturaPorDataLimite
/**
* Retorna lista de Itens da Estrutura de um determinado n�vel
* @author cristiano
* @version 0.1, 13/02/2007
* @param nivel
* @return List
* @throws ECARException
*/
public List listarItemEstruturaPorNivel(int nivel) throws ECARException {
Query query = session.createQuery(" from ItemEstruturaIett where nivelIett = :nivel and indAtivoIett = 'S'");
query.setInteger("nivel", nivel);
return query.list();
}
/**
* M�todo que verifica se um item possui itens filhos com indicador de etapas de
* n�vel superior na estrutura.
*
* @author aleixo
* @version 0.2 - 26/03/2007, 0.1 - 21/03/2007
* @param item
* @return boolean
*/
public boolean verificaItemPossuiEtapas(ItemEstruturaIett item){
return !this.getEtapasIett(item).isEmpty();
}
/**
* Retorna uma lista com as etapas de um item.<br>
* Etapas de um item s�o os itens filhos de um item que possuem indicador de etapa de n�vel superior
* na estrutura.
*
* @author aleixo
* @version 0.1, 22/03/2007
* @param item
* @return List
*/
public List getEtapasIett(ItemEstruturaIett item){
List<ItemEstruturaIett> retorno = new ArrayList<ItemEstruturaIett>();
if(item.getItemEstruturaIetts() != null){
/*Aqui, pegar somente as etapas que s�o filhos de 1� gera��o do item
* (somentes os filhos do item), ignorando os outros
* descendentes do item (.getDescendentes()), como filhos dos filhos,
* ou filhos dos filhos dos filhos, etc...;
*/
for (Iterator itEtapas = item.getItemEstruturaIetts().iterator(); itEtapas.hasNext();) {
ItemEstruturaIett iettFilho = (ItemEstruturaIett) itEtapas.next();
if("S".equals(iettFilho.getEstruturaEtt().getIndEtapaNivelSuperiorEtt())){
retorno.add(iettFilho);
}
}
}
return retorno;
}
/**
* Retorna uma lista de {@link ItemWebServiceBean} para os WebSerices, utilizando SQL Nativo.
*
* @author aleixo
* @version 0.1 - 05/04/2007
* @param codigos
* @param buscarFilhos
* @param buscarEstrutura
* @return List
*/
public List getIettToWebService(Long[] codigos, boolean buscarFilhos, boolean buscarEstrutura){
List<ItemWebServiceBean> retorno = new ArrayList<ItemWebServiceBean>();
try{
if(codigos == null || (codigos != null && codigos.length < 1))
return retorno;
//Seleciono os itens pedidos no banco de dados.
StringBuilder select = new StringBuilder();
select.append("select item.cod_iett, ");
select.append("item.nome_iett, ");
select.append("item.ind_ativo_iett, ");
select.append("item.data_inicio_iett, ");
select.append("item.data_termino_iett, ");
select.append("orgao.descricao_org, ");
select.append("orgao.sigla_org ");
select.append("from tb_item_estrutura_iett item ");
//Utilizando "left join" para que exiba os dados, mesmo que n�o exista a rela��o orgao -> item
select.append(" left join tb_orgao_org orgao");
select.append(" on orgao.cod_org = item.cod_orgao_responsavel1_iett");
if(buscarEstrutura){
select.append(" where item.cod_ett ");
}
else {
select.append(" where item.cod_iett ");
}
select.append(" in (");
//Montando lista de codigos com virgulas para ser usado na cl�usula IN do select.
String cods = "";
int ultimaPosicao = codigos.length - 1;
for(int i = 0; i < codigos.length; i++){
Long codigo = codigos[i];
cods += codigo.toString();
if(i != ultimaPosicao){
cods += ", ";
}
}
select.append(cods + ")" );
SQLQuery q = this.session.createSQLQuery(select.toString());
List objects = q.list();
//Com a lista obtida, percorro a lista para popular os beans... retornar
Iterator itObj = objects.iterator();
while(itObj.hasNext()){
Object[] item = (Object[]) itObj.next();
/*
* item � um array de Object, onde:
*
* posi��o | Conteudo
* ----------------------------------------
* 0 | codIett
* 1 | nomeIett
* 2 | indAtivoIett
* 3 | dataInicioIett
* 4 | dataTerminoIett
* 5 | nomeCliente
* 6 | siglaCliente
*/
ItemWebServiceBean iwsBean = new ItemWebServiceBean();
Long codItem = item[0] != null ? Long.valueOf(item[0].toString()) : null;
String nomeItem = item[1] != null ? item[1].toString() : null;
String indAtivo = item[2] != null ? item[2].toString() : null;
Date dataInicial = null;
if(item[3] != null)
dataInicial = Data.parseDate(item[3].toString(), "yyyy-mm-dd hh:mm:ss.S");
Date dataFinal = null;
if(item[4] != null)
dataFinal = Data.parseDate(item[4].toString(), "yyyy-mm-dd hh:mm:ss.S");
//Setando dados referentes ao item
iwsBean.setCodItem(codItem);
iwsBean.setNomeItem(nomeItem);
iwsBean.setIndAtivo(indAtivo);
iwsBean.setDataInicial(dataInicial);
iwsBean.setDataFinal(dataFinal);
//Setando dados referentes ao Org�o/Cliente
String nomeCliente = item[5] != null ? item[5].toString() : null;
String siglaCliente = item[6] != null ? item[6].toString() : null;
iwsBean.setNomeCliente(nomeCliente);
iwsBean.setSiglaCliente(siglaCliente);
//Setando cole��o de itens filhos
ArrayList filhos = new ArrayList();
if(buscarFilhos && codItem != null){
List codFilhos = this.getItensFilhosWebService(codItem);
Iterator itFilhos = codFilhos.iterator();
Long[] codigosFilhos = new Long[codFilhos.size()];
int i = 0;
while(itFilhos.hasNext()){
Object codFilho = (Object) itFilhos.next();
if(codFilho != null){
Long codFilhoLong = Long.valueOf(codFilho.toString());
codigosFilhos[i] = codFilhoLong;
i++;
}
}
/*
* Para os filhos, passo buscaEstrutura = false, para que busque os
* filhos pelos c�digos dos filhos, e n�o pelo c�digo da estrutura dos filhos.
*/
filhos.addAll(this.getIettToWebService(codigosFilhos, buscarFilhos, false));
}
iwsBean.setItensFilhos(filhos);
//Setando dados referentes ao n�vel de planejamento/Fase
ArrayList<IndicativoItemWebServiceBean> indicativos = new ArrayList<IndicativoItemWebServiceBean>();
List codNiveis = this.getNivelIettWebService(codItem);
Iterator itCodNiveis = codNiveis.iterator();
while(itCodNiveis.hasNext()){
Object[] o = (Object[]) itCodNiveis.next();
IndicativoItemWebServiceBean indicativoBean = new IndicativoItemWebServiceBean();
indicativoBean.setCodIndicativo((o[0] != null) ? Long.valueOf(o[0].toString()) : null);
indicativoBean.setDescricaoIndicativo((o[1] != null) ? o[1].toString() : null);
indicativos.add(indicativoBean);
}
iwsBean.setIndicativoItem(indicativos);
retorno.add(iwsBean);
}
}
catch (Exception e){
e.printStackTrace();
}
return retorno;
}
/**
* Retorna os c�digos dos itens filhos de um item, utilizando SQL Nativo.
*
* @author aleixo
* @version 0.1 - 09/04/2007
* @param Long codIett - c�digo do item
* @return List
*/
private List getItensFilhosWebService(Long codIett){
StringBuilder select = new StringBuilder();
select.append("select cod_iett from tb_item_estrutura_iett ");
select.append(" where cod_iett_pai = " + codIett.toString());
SQLQuery q = this.session.createSQLQuery(select.toString());
List objects = q.list();
if(objects != null && !objects.isEmpty())
return objects;
return new ArrayList();
}
/**
* Retorna uma lista o c�digo e a descri��o do n�vel de planejamento/fase., utilizando SQL Nativo<br>
* c�digo = posi��o [0]<br>
* descri��o = posicao [1].
*
* @author aleixo
* @version 0.1 - 09/04/2007
* @param Long codIett - c�digo do item.
* @return List
*/
private ArrayList getNivelIettWebService(Long codIett){
StringBuilder select = new StringBuilder();
select.append("select atb.cod_satb, atb.descricao_satb from tb_item_estrutura_nivel_iettn nivel, tb_sis_atributo_satb atb ");
select.append(" where nivel.cod_iett = " + codIett.toString());
select.append(" and atb.cod_satb = nivel.cod_atb");
SQLQuery q = this.session.createSQLQuery(select.toString());
ArrayList objects = (ArrayList)q.list();
if(objects != null && !objects.isEmpty())
return objects;
return new ArrayList();
}
/**
* Retorna uma lista de itens ItemWSMinBean, que cont�m apenas o c�digo (sigla) e a descri��o (nome) de cada item.<br>
* Se codigo != null: Retorna dados de apenas um item.
* Se codigo == null ou vazio: Retorna dados de todos os itens.
*
* Se nivel != null: Filtra itens de determinado(s) n�vel(is) de estrutura(s).
* Se nivel == null ou vazio: Considera todos os n�veis de estrutura.
* @author aleixo
* @since 29/05/2007
* @param codigo
* @param niveis
* @return List
*/
public List listIettToWSMin(String codigo, Long[] niveis){
List<ItemWSMinBean> retorno = new ArrayList<ItemWSMinBean>();
//Seleciono os itens pedidos no banco de dados.
StringBuilder select = new StringBuilder();
select.append("select item.sigla_iett, item.nome_iett ");
select.append("from tb_item_estrutura_iett item ");
boolean where = false;
if(codigo != null && !"".equals(codigo.trim())){
where = true;
select.append(" where item.sigla_iett = :codigo");
}
if(niveis != null && niveis.length > 0){
select.append(!where ? " where " : " and ");
select.append(" item.cod_ett in (");
String strNiveis = "";
int ultimaPosicao = niveis.length - 1;
for(int i = 0; i < niveis.length; i++){
Long nivel = niveis[i];
strNiveis += nivel.toString();
if(i != ultimaPosicao){
strNiveis += ", ";
}
}
select.append(strNiveis + ")");
}
select.append(" order by item.sigla_iett");
SQLQuery q = this.session.createSQLQuery(select.toString());
if(codigo != null && !"".equals(codigo.trim())){
q.setString("codigo", codigo);
}
List objects = q.list();
if(objects != null && !objects.isEmpty()){
for(Iterator it = objects.iterator(); it.hasNext();){
Object[] o = (Object[]) it.next();
/*
* item � um array de Object, onde:
*
* posi��o | Conteudo
* ----------------------------------------
* 0 | siglaIett
* 1 | nomeIett
*/
ItemWSMinBean item = new ItemWSMinBean();
item.setCodItem((o[0] != null) ? o[0].toString() : "");
item.setNomeItem((o[1] != null) ? o[1].toString() : "");
retorno.add(item);
}
}
return retorno;
}
/**
* Retorna um item de determinada sigla em uma estrutura.<br>
* Caso estrutura seja nula, a pesquisa � feita em todas as estruturas.
*
* @author aleixo
* @since 27/07/2007
* @param sigla
* @param estrutura
* @return ItemEstruturaIett
* @throws ECARException
*/
public ItemEstruturaIett getIettBySigla(String sigla, EstruturaEtt estrutura) throws ECARException{
try{
StringBuilder s = new StringBuilder();
s.append("select iett from ItemEstruturaIett iett where iett.siglaIett = :sigla and iett.indAtivoIett = 'S'");
if(estrutura != null){
s.append(" and iett.estruturaEtt.codEtt = :estrutura");
}
Query q = this.session.createQuery(s.toString());
q.setString("sigla", sigla);
if(estrutura != null){
q.setLong("estrutura", estrutura.getCodEtt().longValue());
}
q.setMaxResults(1);
Object o = q.uniqueResult();
return (o != null) ? (ItemEstruturaIett) o : null;
}catch (Exception e) {
this.logger.error(e);
throw new ECARException(e);
}
}
/**
* Retorna os Itens de Estrutura que podem ser selecionados de acordo com a Sala de Situa��o.<br>
*
* @author
* @since
* @param listaItensSelecionaveis
* @param ta Tipo de Acompanhamento onde est� definido Sala de Situa��o
* @return List Lista com os itens de estrutura selecion�veis filtrados pela Sala de Situa��o
* @throws ECARException
*/
public List getItensSelecionaveisFiltradosPorAtributo(List listaItensSelecionaveis, TipoAcompanhamentoTa ta) throws ECARException {
List listaRetorno = new ArrayList();
List listaIettPai = new ArrayList();
EstruturaAtributoDao estruturaAtributoDao = new EstruturaAtributoDao(request);
ConfiguracaoDao configuracaoDao = new ConfiguracaoDao(request);
try {
boolean tipoAcompPossuiNivelPlanejamento = false;
if (ta.getSisAtributoSatbs() != null && ta.getSisAtributoSatbs().size() > 0){
Iterator itSisAtributosTa = ta.getSisAtributoSatbs().iterator();
while (itSisAtributosTa.hasNext()){
SisAtributoSatb sisAtributo = (SisAtributoSatb) itSisAtributosTa.next();
//Se for nivel de planejamento
if (sisAtributo.getSisGrupoAtributoSga().equals(configuracaoDao.getConfiguracao().getSisGrupoAtributoSgaByCodSgaGrAtrNvPlan())){
tipoAcompPossuiNivelPlanejamento = true;
break;
}
}
}
if(listaItensSelecionaveis != null && listaItensSelecionaveis.size() > 0 && tipoAcompPossuiNivelPlanejamento) {
// if (ta.getSisAtributoSatbs() != null && ta.getSisAtributoSatbs().size() > 0){
//
// Iterator itSisAtributosTA = ta.getSisAtributoSatbs().iterator();
//
// ConfiguracaoDao configuracaoDao = new ConfiguracaoDao(null);
// boolean tipoAcompPossuiNivelPlanejamento = false;
//
// while (itSisAtributosTA.hasNext()){
//
// SisAtributoSatb sisAtb = (SisAtributoSatb) itSisAtributosTA.next();
//
// if (sisAtb.getSisGrupoAtributoSga().equals(configuracaoDao.getConfiguracao().getSisGrupoAtributoSgaByCodSgaGrAtrNvPlan())){
// tipoAcompPossuiNivelPlanejamento = true;
// break;
// }
// }
// if (tipoAcompPossuiNivelPlanejamento){
Iterator itListaItensSelecionaveis = listaItensSelecionaveis.iterator();
//percorre a lista de itens selecionaveis
while(itListaItensSelecionaveis.hasNext()) {
//AtributoEstruturaListagemItens atbList = (AtributoEstruturaListagemItens) itListaItensSelecionaveis.next();
ItemEstruturaIett iett = (ItemEstruturaIett) itListaItensSelecionaveis.next();
if(verificaNivelHierarquicoEstrutura(ta.getEstruturaNivelGeracaoTa(), iett.getEstruturaEtt()) && iett.getItemEstruturaNivelIettns() != null && iett.getItemEstruturaNivelIettns().size()>0) {
Iterator itListaAtributoItemEstrutura = iett.getItemEstruturaNivelIettns().iterator();
//percorre a lista de atributos de cada item de estrutura
while(itListaAtributoItemEstrutura.hasNext()){
SisAtributoSatb nivel = (SisAtributoSatb) itListaAtributoItemEstrutura.next();
if(nivel.getSisGrupoAtributoSga().equals(configuracaoDao.getConfiguracao().getSisGrupoAtributoSgaByCodSgaGrAtrNvPlan()) &&
ta.getSisAtributoSatbs().contains(nivel)) {
if (iett.getItemEstruturaIett() != null && !listaIettPai.contains(iett.getItemEstruturaIett())) {
Iterator itListaRetorno = listaRetorno.iterator();
boolean achou = false;
while (itListaRetorno.hasNext()){
ItemEstruturaIett iettRetorno = (ItemEstruturaIett) itListaRetorno.next();
if (iettRetorno.equals(iett.getItemEstruturaIett())){
achou = true;
}
}
if (!achou){
listaRetorno.add(iett.getItemEstruturaIett());
listaIettPai.add(iett.getItemEstruturaIett());
}
}
listaRetorno.add(iett);
}
}
}
} // fim do while
return listaRetorno;
}// fim do if
else{
Iterator itItensSelecionaveis = listaItensSelecionaveis.iterator();
List itensSelecionaveis = new ArrayList();
while (itItensSelecionaveis.hasNext()){
ItemEstruturaIett iett = (ItemEstruturaIett) itItensSelecionaveis.next();
//Verifica se o item
if (verificaNivelHierarquicoEstrutura(ta.getEstruturaNivelGeracaoTa(), iett.getEstruturaEtt())){
itensSelecionaveis.add(iett);
}
}
return itensSelecionaveis;
}
// return listaRetorno;
} catch (Exception e) {
this.logger.error(e);
throw new ECARException(e);
}
}
/**
* Ordena os itens de acordo com o que foi definido nas configura��es de tipo de Acompanhamento,
* montando a hierarquia dos itens.
* @param itens
* @param tipoAcomp
* @return List
* @throws ECARException
* @author Jos� Andr�
*/
public List getItensOrdenados(List itens, TipoAcompanhamentoTa tipoAcomp) throws ECARException {
return getItensOrdenados(itens, tipoAcomp, true);
}
/**
* Retorna os SisAtributos do grupo e do Iett passados.<br>
*
* @author
* @since 27/07/2008
* @param iett
* @param codSisGrupoAtributo
* @return List
*/
public List getSisAtributosIett(ItemEstruturaIett iett, Long codSisGrupoAtributo){
List listaRetorno = new ArrayList();
if (iett.getItemEstruturaSisAtributoIettSatbs() != null){
Iterator it = iett.getItemEstruturaSisAtributoIettSatbs().iterator();
while (it.hasNext()){
ItemEstruturaSisAtributoIettSatb iettSatb = (ItemEstruturaSisAtributoIettSatb) it.next();
if (iettSatb.getSisAtributoSatb().getSisGrupoAtributoSga().getCodSga().equals(codSisGrupoAtributo)){
listaRetorno.add(iettSatb.getSisAtributoSatb());
}
}
}
return listaRetorno;
}
/**
* Retorna os ItemEstruturaSisAtributoIettSatbs do grupo e do Iett passados.<br>
*
* @author
* @since 27/07/2008
* @param iett
* @param codSisGrupoAtributo
* @return List
*/
public List getItemEstruturaSisAtributoIettSatbsIett(ItemEstruturaIett iett, Long codSisGrupoAtributo){
List listaRetorno = new ArrayList();
if (iett.getItemEstruturaSisAtributoIettSatbs() != null){
Iterator it = iett.getItemEstruturaSisAtributoIettSatbs().iterator();
while (it.hasNext()){
ItemEstruturaSisAtributoIettSatb iettSatb = (ItemEstruturaSisAtributoIettSatb) it.next();
if (iettSatb.getSisAtributoSatb().getSisGrupoAtributoSga().getCodSga().equals(codSisGrupoAtributo)){
listaRetorno.add(iettSatb);
}
}
}
return listaRetorno;
}
/**
* Extrai de uma colection ordenada os filhos imediatos do itemEstrutura passado.
* @param itemEstrutura
* @param colecaoItens
* @return Lista com os descendentes imediatos
*/
public List<AtributoEstruturaListagemItens> recuperaDescendentesImediatos(ItemEstruturaIett itemEstrutura, List<AtributoEstruturaListagemItens> colecaoItens){
List<AtributoEstruturaListagemItens> retornoList = new ArrayList<AtributoEstruturaListagemItens>();
AtributoEstruturaListagemItens atEstListagem = null;
ItemEstruturaIett item = null;
Iterator colecaoItensIt = colecaoItens.iterator();
while(colecaoItensIt.hasNext()){
atEstListagem = (AtributoEstruturaListagemItens)colecaoItensIt.next();
item = atEstListagem.getItem();
if(item.getCodIett().equals(itemEstrutura.getCodIett())){
while(colecaoItensIt.hasNext()){
atEstListagem = (AtributoEstruturaListagemItens)colecaoItensIt.next();
item = atEstListagem.getItem();
if(item.getNivelIett() == itemEstrutura.getNivelIett()+1)
retornoList.add(atEstListagem);
if(item.getNivelIett() <= itemEstrutura.getNivelIett())
break;
}
break;
}
}
return retornoList;
}
/**
* Verifica em uma colection ordenada se determinado itemEstrutura passado tem filhos.
* @param itemEstrutura
* @param colecaoItens
* @return Lista com os descendentes imediatos
*/
public boolean existeDescendentesImediatos(ItemEstruturaIett itemEstrutura, List<AtributoEstruturaListagemItens> colecaoItens){
boolean retorno = false;
AtributoEstruturaListagemItens atEstListagem = null;
ItemEstruturaIett item = null;
Iterator colecaoItensIt = colecaoItens.iterator();
while(colecaoItensIt.hasNext()){
atEstListagem = (AtributoEstruturaListagemItens)colecaoItensIt.next();
item = atEstListagem.getItem();
if(item.getCodIett().equals(itemEstrutura.getCodIett())){
if(colecaoItensIt.hasNext()){
atEstListagem = (AtributoEstruturaListagemItens)colecaoItensIt.next();
item = atEstListagem.getItem();
if(item.getNivelIett() == itemEstrutura.getNivelIett()+1)
retorno = true;
}
break;
}
}
return retorno;
}
/**
* Verificar se o usuario eh funcao de acompanhamento com permissao de editar o campo mesmo que
* ele esteja bloqueado para planejamento
* @param itemEstrutura
* @param atributo
* @param usuario
* @param gruposAcesso
* @return
*/
public boolean podeEditarAtributoBloqueadoNaEstrutura(ItemEstruturaIett itemEstrutura, ObjetoEstrutura atributo , UsuarioUsu usuario, Set gruposAcesso) {
List funcoesAcompanhamenoDoUsuario = null;
try {
funcoesAcompanhamenoDoUsuario = new TipoFuncAcompDao (null).getFuncoesAcompNaEstruturaDoUsuario( itemEstrutura , usuario, gruposAcesso);
Set liberadoParaFuncoesAcompanhamento = atributo.iGetLibTipoFuncAcompTpfas();
for (Iterator<TipoFuncAcompTpfa> itFuncaosAcompDoUsuario= funcoesAcompanhamenoDoUsuario.iterator(); itFuncaosAcompDoUsuario.hasNext();){
TipoFuncAcompTpfa funcaoAcompDoUsuario = (TipoFuncAcompTpfa) itFuncaosAcompDoUsuario.next();
if (liberadoParaFuncoesAcompanhamento!= null && liberadoParaFuncoesAcompanhamento.contains(funcaoAcompDoUsuario) ){
return true; // pode editar o campo
}
}
} catch (ECARException e) {
e.printStackTrace();
}
return false;
}
private boolean podeEditarAtributoBloqueadoNaEstrutura(ItemEstruturaIett itemEstrutura, ObjetoEstrutura atributo , List funcoesAcompanhamenoDoUsuario ) {
Set liberadoParaFuncoesAcompanhamento = atributo.iGetLibTipoFuncAcompTpfas();
for (Iterator<TipoFuncAcompTpfa> itFuncaosAcompDoUsuario= funcoesAcompanhamenoDoUsuario.iterator(); itFuncaosAcompDoUsuario.hasNext();){
TipoFuncAcompTpfa funcaoAcompDoUsuario = (TipoFuncAcompTpfa) itFuncaosAcompDoUsuario.next();
if (liberadoParaFuncoesAcompanhamento!= null && liberadoParaFuncoesAcompanhamento.contains(funcaoAcompDoUsuario) ){
return true; // pode editar o campo
}
}
return false;
}
/**
*
* @param inicio
* @param fim
* @param tipoHistorico
* @param codigos
* @return
*/
@SuppressWarnings("empty-statement")
public List<HistoricoXml> listaHistorico(Date inicio, Date fim, String[] tipoHistorico, String[] codigos) {
Historico<HistoricoItemEstruturaIett, ItemEstruturaIett> historico = new Historico<HistoricoItemEstruturaIett, ItemEstruturaIett>() {};
try {
return historico.listaHistorico(null, inicio, fim, tipoHistorico, codigos);
}
catch (Exception e) {
e.printStackTrace();
};
return null;
}
/**
*
* @param inicio
* @param fim
* @param tipoHistorico
* @param codigos
* @return
*/
@SuppressWarnings("empty-statement")
public List<HistoricoItemEstruturaIett> listaObjetoHistorico(Date inicio, Date fim, String[] tipoHistorico, String[] codigos) {
Historico<HistoricoItemEstruturaIett, ItemEstruturaIett> historico = new Historico<HistoricoItemEstruturaIett, ItemEstruturaIett>() {};
try {
return historico.listaObjetoHistorico(null, inicio, fim, tipoHistorico, codigos);
}
catch (Exception e) {
e.printStackTrace();
};
return null;
}
/**
* Ordena uma lista de itens de estrutura pelo titulo a ser apresentado na arvore ajax
* N�o considera a hierarquia.
*
*
* @param itens - Lista de itens de estrutura a serem ordenados
*/
public void ordenaListaItensListaModelo(List itens) throws ECARException {
Collections.sort(itens,
new Comparator() {
public int compare(Object o1, Object o2) {
ItemEstruturaIett item1 = (ItemEstruturaIett) o1;
ItemEstruturaIett item2 = (ItemEstruturaIett) o2;
EstruturaDao estruturaDao = new EstruturaDao(null);
EstruturaEtt estruturaItem1;
EstruturaEtt estruturaItem2;
String key1 = "";
String key2 = "";
try {
estruturaItem1 = (EstruturaEtt)estruturaDao.buscar(EstruturaEtt.class, item1.getEstruturaEtt().getCodEtt());
//no metodo abaixo item.getEstruturaEtt() causa um null pointer, por isso precisamos da linha acima
key1 = new ItemEstruturaDao(request).criaColunaConteudoColunaArvoreAjax(item1, estruturaItem1);
estruturaItem2 = (EstruturaEtt)estruturaDao.buscar(EstruturaEtt.class, item2.getEstruturaEtt().getCodEtt());
//no metodo abaixo item.getEstruturaEtt() causa um null pointer, por isso precisamos da linha acima
key2 = new ItemEstruturaDao(request).criaColunaConteudoColunaArvoreAjax(item2, estruturaItem2);
} catch (ECARException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return key1.compareToIgnoreCase(key2);
}
}
);
}
/**
* Pesquisa todos os itens de Estrutura que s�o modelo e possuam o nome enviado como par�metro nas estruturas marcadas
*
* @param item - Item pai- usado na recursividade para buscar seus filhos
* @param estrutura - Usado como parametro para o primeiro n�vel de busca nesse algoritmo recursivo
* @param nomePesquisa - Filtro de nome indicado pelo usu�rio
* @param indCopiar - Indicador da p�gina de criar item a partir de modelo. Se diferente de <b>todaEstrutura</b>
* apenas busca itens no nivel da estrutura informada. Caso seja igual a "todaEstrutura" fazer a
* busca pelos itens filhos que tamb�m s�o modelo
* @param seguranca
* @return
* @throws ECARException
*/public List getListaItensModelo(ItemEstruturaIett item, EstruturaEtt estrutura, String nomePesquisa, String indCopiar, SegurancaECAR seguranca) throws ECARException{
List lista = new ArrayList();
Criteria select = session.createCriteria(ItemEstruturaIett.class);
if (estrutura!= null){
select.add(Restrictions.eq("estruturaEtt", estrutura));
}
if (item!=null){
select.add(Restrictions.eq("itemEstruturaIett", item));
}
if (nomePesquisa != null && !nomePesquisa.equals(Dominios.STRING_VAZIA)) {
select.add(Restrictions.ilike("nomeIett", "%"+nomePesquisa+"%"));
}
List pais = select
.add(Restrictions.eq("indModeloIett",Dominios.SIM))
.add(Restrictions.eq("indAtivoIett",Dominios.SIM))
.addOrder(Order.asc("nomeIett")).list();
//ordena pelos campos apresentados na arvore ajax
ordenaListaItensListaModelo(pais);
//Verifica permiss�es de acesso
ValidaPermissao validaPermissao = new ValidaPermissao();
if (indCopiar!=null && indCopiar.equals("todaEstrutura")) {
Iterator it = pais.iterator();
while (it.hasNext()){
item = (ItemEstruturaIett) it.next();
validaPermissao.permissoesItem(item, seguranca.getUsuario(), seguranca.getGruposAcesso());
if (validaPermissao.permissaoConsultarItem()){
lista.add(item);
lista.addAll(this.getListaItensModelo(item, null, null, "todaEstrutura", seguranca));
}
}
} else {
lista=pais;
}
Iterator itItens = lista.iterator();
while (itItens.hasNext()){
item = (ItemEstruturaIett) itItens.next();
validaPermissao.permissoesItem(item, seguranca.getUsuario(), seguranca.getGruposAcesso());
if (!validaPermissao.permissaoConsultarItem()){
itItens.remove();
}
}
return lista;
}
/**
*
* @param chaveHistorico
* @return
*/
@SuppressWarnings("empty-statement")
public HistoricoItemEstruturaIett getHistorico(Long chaveHistorico){
Historico<HistoricoItemEstruturaIett, ItemEstruturaIett> historico = new Historico<HistoricoItemEstruturaIett, ItemEstruturaIett>(){};
try {
return historico.getObjetoSerializado(chaveHistorico);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
;
return null;
}
/**
*
* Pesquisa todos os itens de Estrutura que possuam o nome enviado como par�metro nas estruturas marcadas
*
* @param estruturasSelecionadas
* @param nomeItemPesquisar
* @param seguranca
* @return
* @throws ECARException
*/
public List pesquisarItemNaEstrutura(String[] estruturasSelecionadas,String nomeItemPesquisar,SegurancaECAR seguranca) throws ECARException {
List<Integer> lista = new ArrayList<Integer>();
StringBuffer query = new StringBuffer();
Map<EstruturaEtt,List<ItemEstruturaIett>> map = new HashMap<EstruturaEtt, List<ItemEstruturaIett>>();
List<ItemEstruturaIett> itensEstrutura;
for (int i = 0; i < estruturasSelecionadas.length; i++) {
if (estruturasSelecionadas[i] != null) {
Integer codigoEstrutura = Integer.parseInt(estruturasSelecionadas[i]);
lista.add(codigoEstrutura);
}
}
query.append("select itemEstrutura from ItemEstruturaIett itemEstrutura");
query.append(" inner join itemEstrutura.estruturaEtt estrutura ");
query.append(" where itemEstrutura.indAtivoIett = 'S' and");
query.append(" estrutura.codEtt in (:grupo)");
if (nomeItemPesquisar != null && !nomeItemPesquisar.equals(Dominios.STRING_VAZIA)) {
query.append(" and Lower(itemEstrutura.nomeIett) like :nome ");
}
query.append(" order by itemEstrutura.nomeIett ");
try{
Query _obj = this.getSession().createQuery(query.toString());
_obj.setParameterList("grupo", lista, new IntegerType());
if (nomeItemPesquisar != null && !nomeItemPesquisar.equals(Dominios.STRING_VAZIA)) {
_obj.setString("nome", "%" + nomeItemPesquisar.toLowerCase() + "%");
}
itensEstrutura = _obj.list();
} catch(HibernateException e){
this.logger.error(e);
throw new ECARException(e);
}
return itensEstrutura;
}
/**
* Retorna as Estruturas virtuais cujo o item est� associado.
* @param item
* @return
*/
public Set pesquisarEstruturasVirtuaisAssociadas (ItemEstruturaIett item){
if (!getSession().contains(item)) {
item = (ItemEstruturaIett) getSession().load(ItemEstruturaIett.class,item.getCodIett());
}
Hibernate.initialize(item.getEstruturasVirtual());
return item.getEstruturasVirtual();
}
/**
* Gera uma lista com os n�s da �rvore que formam o caminho entre o item superior e o item inferior.
* A lista come�a com o identificador do item superior e termina com o identificador do item inferior.
* O formato do codItemInferior, codItemSuperior, codPaiEstrutura e dos itens da lista de retorno obedecem
* o seguinte padr�o:
* Se for um itemEstrutura -> "iett<codIett>"
* Se for uma estrutura -> "ett<codEtt>"
* @param codItemInferior - item inferior da �rvore
* @param codItemSuperior - item superior da �rvore
* @param codPaiEstrutura - atributo opcional, s� � usado quando "codItemInferior" � uma estrutura
* @param codEstruturaFilhaVirtualExpandida - atributo opcional, s� � usado quando a estrutura for "filha" de uma estrutura virtual
* @return
*/
public List geraCaminhoArvoreCadastro(String codItemInferior, String codItemSuperior, String codPaiEstrutura, String codEstruturaFilhaVirtualExpandida){
ArrayList<String> caminho = new ArrayList<String>();
try {
//no caso do filho ser um item estrutura
if(codItemInferior.startsWith("iett")){
ItemEstruturaIett itemEstrutura = null;
String codIett = "";
ItemEstruturaDao itemDao = new ItemEstruturaDao(null);
codIett = codItemInferior.substring(4, codItemInferior.length());
itemEstrutura = (ItemEstruturaIett) itemDao.buscar(ItemEstruturaIett.class, new Long(codIett));
do {
//salva o c�digo do pr�prio item
caminho.add("iett" + itemEstrutura.getCodIett());
if(codItemSuperior.startsWith("iett") && codItemSuperior.substring(4, codItemSuperior.length()).equals(itemEstrutura.getCodIett().toString())){
break;
}
//salva o c�digo da estrutura a que ele pertence
caminho.add("ett" + itemEstrutura.getEstruturaEtt().getCodEtt());
if(codItemSuperior.startsWith("ett") && codItemSuperior.substring(3, codItemSuperior.length()).equals(itemEstrutura.getEstruturaEtt().getCodEtt().toString())){
break;
}
itemEstrutura = itemEstrutura.getItemEstruturaIett();
} while (itemEstrutura != null);
}
//no caso do filho ser uma estrutura
else if(codItemInferior.startsWith("ett")){
EstruturaDao estruturaDao = new EstruturaDao(null);
String codEtt = codItemInferior.substring(3, codItemInferior.length());
EstruturaEtt estrutura = (EstruturaEtt) estruturaDao.buscar(EstruturaEtt.class, new Long(codEtt));
caminho.add("ett" + estrutura.getCodEtt());
if(codPaiEstrutura != null && !codPaiEstrutura.equals("iett") ){
ItemEstruturaIett itemEstrutura = null;
String codIett = "";
ItemEstruturaDao itemDao = new ItemEstruturaDao(null);
codIett = codPaiEstrutura.substring(4, codPaiEstrutura.length());
itemEstrutura = (ItemEstruturaIett) itemDao.buscar(ItemEstruturaIett.class, new Long(codIett));
do {
//salva o c�digo do pr�prio item
caminho.add("iett" + itemEstrutura.getCodIett());
if(codItemSuperior.startsWith("iett") && codItemSuperior.substring(4, codItemSuperior.length()).equals(itemEstrutura.getCodIett().toString())){
break;
}
//salva o c�digo da estrutura a que ele pertence
caminho.add("ett" + itemEstrutura.getEstruturaEtt().getCodEtt());
if(codItemSuperior.startsWith("ett") && codItemSuperior.substring(3, codItemSuperior.length()).equals(itemEstrutura.getEstruturaEtt().getCodEtt().toString())){
break;
}
itemEstrutura = itemEstrutura.getItemEstruturaIett();
} while (itemEstrutura != null);
}
if(estrutura.isVirtual()) {
//salva o codigo dos itens aos quais a estrutura pertence
Map mapItensEstruturaVirtual = null;
ActionEstrutura action = new ActionEstrutura();
mapItensEstruturaVirtual = action.montarMapItensEstruturaVirtual(estrutura);
caminho.remove("ett" + estrutura.getCodEtt());
Iterator itEstruturas = mapItensEstruturaVirtual.keySet().iterator();
while(itEstruturas.hasNext()){
EstruturaEtt estruturaFilha = (EstruturaEtt) itEstruturas.next();
if(codEstruturaFilhaVirtualExpandida != null && codEstruturaFilhaVirtualExpandida.equals(estruturaFilha.getCodEtt().toString())){
List listaItensEstrutura = (List) mapItensEstruturaVirtual.get(estruturaFilha);
Iterator itLisItensEstrutura = listaItensEstrutura.iterator();
while(itLisItensEstrutura.hasNext()) {
ItemEstruturaIett item = (ItemEstruturaIett) itLisItensEstrutura.next();
caminho.add("iett" + item.getCodIett() + "_pai_" + "ett" + estrutura.getCodEtt());
}
caminho.add("ett" + estruturaFilha.getCodEtt() + "v");
break;
}
}
caminho.add("ett" + estrutura.getCodEtt());
}
}
} catch (Exception e) {
// N�o precisa levantar exce��o, s� retorna a lista vazia
caminho = new ArrayList<String>();
}
//inverte a lista
Collections.reverse(caminho);
return caminho;
}
/**
*
*
* @param estrutura - Estrura do primero nivel
* @param listItens - esta lista j� deve estar na ordem de apresenta��o.
* @return Map com a chave a estrutura e o valor o nivel da estrutura
*/
public Map<EstruturaEtt, Integer> montaMapEstruturaNivel(EstruturaEtt estrutura, List listItens){
Map mapEstruturasNivel = new HashMap<EstruturaEtt, Integer>();
int nivel;
Iterator itItens = listItens.iterator();
ItemEstruturaIett itemPrimeiroNivel=null;
ItemEstruturaIett itemAnterior=null;
mapEstruturasNivel.put(estrutura, new Integer(0));
while (itItens.hasNext()) {
ItemEstruturaIett item = (ItemEstruturaIett) itItens.next();
if (item.getEstruturaEtt().getCodEtt().equals(estrutura.getCodEtt())){
nivel=0;
itemPrimeiroNivel = item;
//Verifica se o item anterior � pai do item atual
} else if (mapEstruturasNivel.containsKey(item.getEstruturaEtt())){
nivel = ((Integer)mapEstruturasNivel.get(item.getEstruturaEtt())).intValue();
} else { // if ( itemAnterior.getCodIett().equals(item.getItemEstruturaIett().getCodIett() ) ) {
int nivelPai = ((Integer) mapEstruturasNivel.get(item.getItemEstruturaIett().getEstruturaEtt())).intValue();
nivel = ++nivelPai;
mapEstruturasNivel.put(item.getEstruturaEtt(), Integer.valueOf(nivel));
}
itemAnterior = item;
}// fim while
return mapEstruturasNivel;
}
/**
*
*
* @param mapItensFuncoes
* @param usuarioLogado
* @return
* @throws ECARException
*/
public ItemEstruturaIett criarCopiaItensFuncoes (Map mapItensFuncoes, UsuarioUsu usuarioLogado, ItemEstruturaIett itemEstruturaSelecionado) throws ECARException{
Transaction tx = null;
ArrayList objetos = new ArrayList();
ItemEstruturaIett itemPai = null; //Item do primeiro nivel, ser� exibido apos a opera��o
try{
super.inicializarLogBean();
tx = session.beginTransaction();
Iterator<ItemEstruturaIett> itItem = null; //Iterador com a chave do map contendo o conjunto de itens que se deseja copiar
ItemEstruturaIett item = null; //Item que se deseja criar a copia
List listFuncoes = null; //Lista das fun��es que se deseja copiar do item
boolean ehPaiMaster= true;
itItem = mapItensFuncoes.keySet().iterator();
//A transa��o � para come�ar aqui pois se der erro na copia de algum item a opera��o dever� ser abortada
//Esta estrutura representa a correspond�ncia entre o ItemEstrutura antigo e novo que foi inserido como modelo,
//para servir de suporte � associa��o do novo Item filho ao novo Item pai
Map itensInseridos = new LinkedMap();
while (itItem.hasNext()){
item = (ItemEstruturaIett)itItem.next();
listFuncoes = (List) mapItensFuncoes.get(item);
if (ehPaiMaster){
itemPai = copiarItemComoModelo(item, listFuncoes, itensInseridos, objetos, usuarioLogado, itemEstruturaSelecionado);
ehPaiMaster = false;
} else {
copiarItemComoModelo(item, listFuncoes, itensInseridos, objetos, usuarioLogado, itemEstruturaSelecionado);
}
}
tx.commit();
} catch (HibernateException e) {
itemPai = null;//opera��o abortada, n�o salvou nenhum pai
if (tx != null)
try {
tx.rollback();
} catch (HibernateException r) {
this.logger.error(r);
throw new ECARException("erro.hibernateException");
}
this.logger.error(e);
throw new ECARException("erro.hibernateException");
}
if(super.logBean != null) {
super.logBean.setCodigoTransacao(Data.getHoraAtual(false));
super.logBean.setOperacao("ALT");
Iterator itObj = objetos.iterator();
while(itObj.hasNext()) {
super.logBean.setObj(itObj.next());
super.loggerAuditoria.info(logBean.toString());
}
}
return itemPai;
}
/**
* Gera e retorna um novo �tem contendo os mesmos atributos e relacionamentos das fun��es passadas por
* par�metro, do ItemEstrutura passado como par�metro
*
* @param itemOrigem
* @param funcoes
* @param itensInseridos
* @param usuarioLogado
* @param objetos
* @return ItemEstruturaIett
* @throws ECARException
*/
public ItemEstruturaIett copiarItemComoModelo(ItemEstruturaIett itemOrigem, List funcoes, Map itensInseridos, List objetos, UsuarioUsu usuarioLogado, ItemEstruturaIett itemEstruturaSelecionado) throws ECARException{
ItemEstruturaIett novoItem = new ItemEstruturaIett();
//Seta a EstruturaEtt
novoItem.setEstruturaEtt(itemOrigem.getEstruturaEtt());
//Seta os atributos de Dados Gerais
copiarDadosGerais(itemOrigem, novoItem, usuarioLogado);
// Seta o pai do novo item, acessando o Map de correspond�ncia entre o pai antigo e o pai novo
if (itemOrigem.getItemEstruturaIett() != null){
if ((ItemEstruturaIett) itensInseridos.get( itemOrigem.getItemEstruturaIett()) != null){
ItemEstruturaIett itemPai = (ItemEstruturaIett) this.buscar(ItemEstruturaIett.class, ((ItemEstruturaIett) itensInseridos.get( itemOrigem.getItemEstruturaIett())).getCodIett());
novoItem.setItemEstruturaIett(itemPai);
}
//o pai n�o � um �tem ja inserido. Ser� igual ao pai do item de origem
if (novoItem.getItemEstruturaIett() == null){
//novoItem.setItemEstruturaIett(itemOrigem.getItemEstruturaIett());
novoItem.setItemEstruturaIett(itemEstruturaSelecionado);
}
}
novoItem.setItemEstUsutpfuacIettutfas(copiarFuncaoAcompanhamentoDadosGerais(itemOrigem, novoItem, usuarioLogado));
List filhos = new ArrayList();
if (novoItem.getItemEstUsutpfuacIettutfas() != null){
filhos.addAll(novoItem.getItemEstUsutpfuacIettutfas());
}
session.save(novoItem);
objetos.add(novoItem);
Set<ItemEstrutUsuarioIettus> permissoesObtidas = new ControlePermissao().getPermissoesItemEstruturaUsarModelo(novoItem, request);
//Salva os itens de permiss�es obtidos
for (ItemEstrutUsuarioIettus itemEstrutUser : permissoesObtidas) {
session.save(itemEstrutUser);
objetos.add(itemEstrutUser);
}
//Permiss�es de acesso para as fun��es de acompanhamento e fun��es de seu pai que est�o como manter no pr�ximo n�vel.
// gravar permiss�o para o usu�rio que criou o item
ItemEstrutUsuarioIettus itemEstrutUsuario = new ItemEstrutUsuarioIettus();
itemEstrutUsuario.setItemEstruturaIett(novoItem);
itemEstrutUsuario.setItemEstruturaIettOrigem(novoItem);
itemEstrutUsuario.setCodTpPermIettus(ControlePermissao.PERMISSAO_USUARIO);
itemEstrutUsuario.setUsuarioUsu(novoItem.getUsuarioUsuByCodUsuIncIett());
itemEstrutUsuario.setIndLeituraIettus("S");
itemEstrutUsuario.setIndEdicaoIettus("S");
itemEstrutUsuario.setIndExcluirIettus("S");
itemEstrutUsuario.setIndAtivMonitIettus("N");
itemEstrutUsuario.setIndDesatMonitIettus("N");
itemEstrutUsuario.setIndBloqPlanIettus("N");
itemEstrutUsuario.setIndDesblPlanIettus("N");
itemEstrutUsuario.setIndInfAndamentoIettus("N");
itemEstrutUsuario.setIndEmitePosIettus("N");
itemEstrutUsuario.setIndProxNivelIettus("N");
itemEstrutUsuario.setDataInclusaoIettus(Data.getDataAtual());
Iterator itFilhos = filhos.iterator();
while(itFilhos.hasNext()) {
PaiFilho object = (PaiFilho) itFilhos.next();
object.atribuirPKPai();
//salva os filhos
session.save(object);
objetos.add(object);
}
session.save(itemEstrutUsuario);
objetos.add(itemEstrutUsuario);
//Atributos livres
List atributosLivresDadosGerais = copiarAtributosLivresDadosGerais(itemOrigem, novoItem, usuarioLogado);
for(Iterator it = atributosLivresDadosGerais.iterator(); it.hasNext();){
ItemEstruturaSisAtributoIettSatb atbLivre = (ItemEstruturaSisAtributoIettSatb) it.next();
session.save(atbLivre);
objetos.add(atbLivre);
}
//Seta os atributos de outras fun��es
Iterator itFuncoes = funcoes.iterator();
while (itFuncoes.hasNext()){
FuncaoFun funcao = (FuncaoFun) itFuncoes.next();
String nomeFuncao = funcao.getNomeFun();
if (nomeFuncao.equals(FuncaoDao.NOME_FUNCAO_AGENDA)){
novoItem.setAgendaAge(copiarAgendas(novoItem, itemOrigem.getAgendaAge(), usuarioLogado));
} //Editores leitores = permiss�o de acesso
//else if (nomeFuncao.equals(FuncaoDao.NOME_FUNCAO_EDITORES_LEITORES)){
//novoItem.setItemEstrutUsuarioIettusesByCodIett (copiarEditoresLeitores(itemOrigem, novoItem, itensInseridos, usuarioLogado));
//copiouPermissoes = true;
//}
else if (nomeFuncao.equals(FuncaoDao.NOME_FUNCAO_ASSOCIACAO_DEMANDAS)){
// novoItem.setItemRegdemandaIregds(copiarDemandasAssociadas(novoItem, itemOrigem.getItemRegdemandaIregds()));
copiarDemandasAssociadas(novoItem, itemOrigem.getItemRegdemandaIregds());
}
else if (nomeFuncao.equals(FuncaoDao.NOME_FUNCAO_BENEFICIARIO)){
novoItem.setItemEstrtBenefIettbs(copiarBeneficiarios(novoItem, itemOrigem.getItemEstrtBenefIettbs(), usuarioLogado));
}
else if (nomeFuncao.equals(FuncaoDao.NOME_FUNCAO_CATEGORIAS)){
novoItem.setItemEstrUplCategIettucs(copiarCategorias(novoItem, itemOrigem.getItemEstrUplCategIettucs(), usuarioLogado));
}
else if (nomeFuncao.equals(FuncaoDao.NOME_FUNCAO_CRITERIOS)){
novoItem.setItemEstrutCriterioIettcs(copiarCriterios(novoItem, itemOrigem.getItemEstrutCriterioIettcs(), usuarioLogado));
}
else if (nomeFuncao.equals(FuncaoDao.NOME_FUNCAO_ENTIDADES)){
novoItem.setItemEstrutEntidadeIettes(copiarEntidades(novoItem, itemOrigem.getItemEstrutEntidadeIettes(), usuarioLogado));
}
else if (nomeFuncao.equals(FuncaoDao.NOME_FUNCAO_EVENTOS)){ //tamb�m conhecida como A��O e Di�rio de bordo
novoItem.setItemEstrutAcaoIettas(copiarEventos(novoItem, itemOrigem.getItemEstrutAcaoIettas(), usuarioLogado));
}
else if (nomeFuncao.equals(FuncaoDao.NOME_FUNCAO_LOCALIZACAO)){
novoItem.setItemEstrutLocalIettls(copiarLocalizacao(novoItem, itemOrigem.getItemEstrutLocalIettls(), usuarioLogado));
}
else if (nomeFuncao.equals(FuncaoDao.NOME_FUNCAO_METAS_INDICADORES )){
//Tamb�m conhecido como indicadores de resultados
novoItem.setItemEstrtIndResulIettrs(copiarMetasIndicadores(novoItem, itemOrigem.getItemEstrtIndResulIettrs(), usuarioLogado));
}
// else if (nomeFuncao.equals(FuncaoDao.NOME_FUNCAO_FONTES_RECURSOS)){ //tamb�m conhecida como A��O e Di�rio de bordo
//
// novoItem.setEfIettFonteTotEfiefts(copiarFonteRecursos(novoItem, itemOrigem.getEfIettFonteTotEfiefts()));
// }
else if (nomeFuncao.equals(FuncaoDao.NOME_FUNCAO_PONTOS_CRITICOS)){ //tamb�m conhecida como Restri��es
novoItem.setPontoCriticoPtcs(copiarPontosCriticos(novoItem, itemOrigem.getPontoCriticoPtcs(), usuarioLogado));
}
}
// if (!copiouPermissoes){
// copiarPermissoesFuncoesAcompanhamento(itemOrigem, novoItem, itensInseridos, usuarioLogado);
// }
session.update(novoItem);
//session.merge(novoItem);
HistoricoItemEstruturaIett hiett = new HistoricoItemEstruturaIett();
hiett.carregar(novoItem);
gerarHistorico(hiett, Historico.INCLUIR);
//atualiza Map de correspond�ncia entre itens antigos e novos
itensInseridos.put(itemOrigem, novoItem);
return novoItem;
}
/**
* Copia o valor de todos os atributos de dados gerais, incluindo atributos livres, do ItemEstrutura modelo
* para o novo ItemEstrutura a ser inclu�do
*
* @param itemOrigem
* @param novoItem
* @throws ECARException
*/
private void copiarDadosGerais(ItemEstruturaIett itemOrigem, ItemEstruturaIett novoItem, UsuarioUsu usuarioLogado) throws ECARException{
novoItem.setNomeIett(itemOrigem.getNomeIett());
novoItem.setValPrevistoFuturoIett(itemOrigem.getValPrevistoFuturoIett());
novoItem.setIndBloqPlanejamentoIett(itemOrigem.getIndBloqPlanejamentoIett());
novoItem.setBeneficiosIett(itemOrigem.getBeneficiosIett());
novoItem.setOrigemIett(itemOrigem.getOrigemIett());
novoItem.setObjetivoEspecificoIett(itemOrigem.getObjetivoEspecificoIett());
novoItem.setObjetivoGeralIett(itemOrigem.getObjetivoGeralIett());
novoItem.setIndMonitoramentoIett(itemOrigem.getIndMonitoramentoIett());
novoItem.setIndCriticaIett(itemOrigem.getIndCriticaIett());
novoItem.setDataInicioMonitoramentoIett(itemOrigem.getDataInicioMonitoramentoIett());
novoItem.setDataTerminoIett(itemOrigem.getDataTerminoIett());
novoItem.setDataInicioIett(itemOrigem.getDataInicioIett());
novoItem.setIndAtivoIett(itemOrigem.getIndAtivoIett());
novoItem.setDataUltManutencaoIett(Data.getDataAtual());
novoItem.setDataInclusaoIett(Data.getDataAtual());
novoItem.setDescricaoIett(itemOrigem.getDescricaoIett());
novoItem.setSiglaIett(itemOrigem.getSiglaIett());
novoItem.setDescricaoR5(itemOrigem.getDescricaoR5());
novoItem.setDescricaoR4(itemOrigem.getDescricaoR4());
novoItem.setDescricaoR3(itemOrigem.getDescricaoR3());
novoItem.setDescricaoR2(itemOrigem.getDescricaoR2());
novoItem.setDescricaoR1(itemOrigem.getDescricaoR1());
novoItem.setDataR5(itemOrigem.getDataR5());
novoItem.setDataR4(itemOrigem.getDataR4());
novoItem.setDataR3(itemOrigem.getDataR3());
novoItem.setDataR2(itemOrigem.getDataR2());
novoItem.setDataR1(itemOrigem.getDataR1());
novoItem.setNivelIett(itemOrigem.getNivelIett());
novoItem.setOrgaoOrgByCodOrgaoResponsavel1Iett(itemOrigem.getOrgaoOrgByCodOrgaoResponsavel1Iett());
novoItem.setOrgaoOrgByCodOrgaoResponsavel2Iett(itemOrigem.getOrgaoOrgByCodOrgaoResponsavel2Iett());
// novoItem.setItemEstruturaIett(itemOrigem.getItemEstruturaIett());
novoItem.setSubAreaSare(itemOrigem.getSubAreaSare());
novoItem.setAreaAre(itemOrigem.getAreaAre());
novoItem.setUsuarioUsuByCodUsuUltManutIett(usuarioLogado);
novoItem.setUsuarioUsuByCodUsuIncIett(usuarioLogado);
novoItem.setPeriodicidadePrdc(itemOrigem.getPeriodicidadePrdc());
novoItem.setUnidadeOrcamentariaUO(itemOrigem.getUnidadeOrcamentariaUO());
novoItem.setSituacaoSit(itemOrigem.getSituacaoSit());
if (itemOrigem.getItemEstruturaNivelIettns() != null && !itemOrigem.getItemEstruturaNivelIettns().isEmpty()){
novoItem.setItemEstruturaNivelIettns(new HashSet());
Iterator itItemEstruturaNivelIettns = itemOrigem.getItemEstruturaNivelIettns().iterator();
while (itItemEstruturaNivelIettns.hasNext()){
SisAtributoSatb sisAtributoSatb = (SisAtributoSatb) itItemEstruturaNivelIettns.next();
novoItem.getItemEstruturaNivelIettns().add( this.buscar(SisAtributoSatb.class, sisAtributoSatb.getCodSatb()));
}
} else {
novoItem.setItemEstruturaNivelIettns(null);
}
}
/**
* Associa os atributos livres associados ao item original para o item novo
*
* @param itemOrigem
* @param novoItem
* @return List de ItemEstruturaSisAtributoIettSatb
*/
private List copiarAtributosLivresDadosGerais(ItemEstruturaIett itemOrigem, ItemEstruturaIett novoItem, UsuarioUsu usuarioLogado) throws ECARException{
//C�PIA DOS ATRIBUTOS LIVRES
List atributosLivresDadosGerais = new ArrayList();
ActionSisAtributo action = new ActionSisAtributo();
FuncaoFun funcaoDadosGerais = new FuncaoFun();
funcaoDadosGerais.setNomeFun(FuncaoDao.NOME_FUNCAO_DADOS_GERAIS);
ConfiguracaoCfg configuracaoCfg = new ConfiguracaoDao(request).getConfiguracao();
List funcoes=null;
try {
funcoes = (new FuncaoDao(request)).pesquisar(funcaoDadosGerais, null);
if (funcoes!=null && funcoes.size()>0){
funcaoDadosGerais = (FuncaoFun)funcoes.get(0);
}
Iterator itItemEstruturaSisAtributos = itemOrigem.getItemEstruturaSisAtributoIettSatbs().iterator();
while (itItemEstruturaSisAtributos.hasNext()){
ItemEstruturaSisAtributoIettSatb itemEstruturaSisAtributoOrigem = (ItemEstruturaSisAtributoIettSatb) itItemEstruturaSisAtributos.next();
ItemEstruturaSisAtributoIettSatb itemEstruturaSisAtributoNovo = new ItemEstruturaSisAtributoIettSatb();
itemEstruturaSisAtributoNovo.setDataUltManutencao(Data.getDataAtual());
itemEstruturaSisAtributoNovo.setUsuarioUsu(usuarioLogado);
itemEstruturaSisAtributoNovo.setItemEstruturaIett(novoItem);
itemEstruturaSisAtributoNovo.setSisAtributoSatb(itemEstruturaSisAtributoOrigem.getSisAtributoSatb());
//Para atributos do tipo CAMPO_ID
if (itemEstruturaSisAtributoOrigem.getInformacao() != null && itemEstruturaSisAtributoOrigem.getSisAtributoSatb().getAtribInfCompSatb() !=null
&& (itemEstruturaSisAtributoOrigem.getSisAtributoSatb().getAtribInfCompSatb().equals(ConstantesECAR.VALIDACAO_ATRIBUTO_MASCARA)
|| itemEstruturaSisAtributoOrigem.getSisAtributoSatb().getAtribInfCompSatb().equals(ConstantesECAR.VALIDACAO_ATRIBUTO_MASCARA_EDITAVEL)
|| itemEstruturaSisAtributoOrigem.getSisAtributoSatb().getAtribInfCompSatb().equals(ConstantesECAR.VALIDACAO_ATRIBUTO_INCREMENTAL ))){
if (! itemEstruturaSisAtributoOrigem.getSisAtributoSatb().getAtribInfCompSatb().equals(ConstantesECAR.VALIDACAO_ATRIBUTO_INCREMENTAL ) ){
itemEstruturaSisAtributoNovo.setInformacao(action.geraConteudo(itemEstruturaSisAtributoOrigem.getSisAtributoSatb().getMascara()));
}
geraValorIncremental(itemEstruturaSisAtributoNovo, itemEstruturaSisAtributoNovo.getSisAtributoSatb(), funcaoDadosGerais, itemEstruturaSisAtributoNovo.getItemEstruturaIett().getEstruturaEtt(), null);
}else if(itemEstruturaSisAtributoOrigem.getInformacao() != null && itemEstruturaSisAtributoOrigem.getSisAtributoSatb().getSisGrupoAtributoSga().getSisTipoExibicGrupoSteg().getCodSteg().equals(new Long(Input.IMAGEM))){
String formato = "ddMMyyyyHHmmssSSS";
SimpleDateFormat formatter = new SimpleDateFormat(formato);
String dataGravacao = formatter.format(new Date());
String pathRaiz = configuracaoCfg.getRaizUpload();
String pathAnexo = configuracaoCfg.getUploadUsuarios();
String novaInformacao = itemEstruturaSisAtributoOrigem.getInformacao().substring
(0, itemEstruturaSisAtributoOrigem.getInformacao().lastIndexOf("/")+1) + dataGravacao + "--" +
itemEstruturaSisAtributoOrigem.getInformacao().substring(itemEstruturaSisAtributoOrigem.getInformacao().lastIndexOf("/")+1);
String informacaoOrigem = itemEstruturaSisAtributoOrigem.getInformacao().substring
(itemEstruturaSisAtributoOrigem.getInformacao().lastIndexOf("/")+1);
// String novaInformacao = dataGravacao + "--" + informacaoOrigem;
//Faz a copia do arquivo armazenado no servidor.
// copiaUpload.setNomeOriginalIettup(uploadOrigem.getNomeOriginalIettup());
// copiaUpload.setTamanhoIettup(uploadOrigem.getTamanhoIettup());
String arquivoOrigem = FileUpload.getPathFisico(pathRaiz, pathAnexo, informacaoOrigem);//itemEstruturaSisAtributoOrigem.getInformacao();
String arquivoDestino = FileUpload.getPathFisico(pathRaiz, pathAnexo, dataGravacao + "--" + informacaoOrigem);
itemEstruturaSisAtributoNovo.setInformacao(novaInformacao);
try {
FileUpload.copiarArquivo(arquivoOrigem, arquivoDestino);
} catch (IOException e) {
e.printStackTrace();
}
}
//Para atributos do tipo TEXT, TEXTAREA, MULTITEXTO, IMAGEM e VALIDA��O
else if (itemEstruturaSisAtributoOrigem.getInformacao() != null) {
itemEstruturaSisAtributoNovo.setInformacao(itemEstruturaSisAtributoOrigem.getInformacao());
}
itemEstruturaSisAtributoNovo.atribuirPKPai();
atributosLivresDadosGerais.add(itemEstruturaSisAtributoNovo);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ECARException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return atributosLivresDadosGerais;
}
/**
*
*
* @param itemOrigem
* @param novoItem
* @return List de
* @throws Exception
*/
private Set copiarFuncaoAcompanhamentoDadosGerais(ItemEstruturaIett itemOrigem, ItemEstruturaIett novoItem, UsuarioUsu usuarioLogado) {
//C�PIA DOS ATRIBUTOS LIVRES
Set itemEstUsuTpfaDadosGerais = new HashSet();
Iterator itItemEstUsuTpfas = itemOrigem.getItemEstUsutpfuacIettutfas().iterator();
try {
while (itItemEstUsuTpfas.hasNext()){
ItemEstUsutpfuacIettutfa itemEstUsuTpfaOrigem = (ItemEstUsutpfuacIettutfa ) itItemEstUsuTpfas.next();
ItemEstUsutpfuacIettutfa itemEstUsuTpfaNovo = new ItemEstUsutpfuacIettutfa();
Entidade.clonarPojo(itemEstUsuTpfaOrigem, itemEstUsuTpfaNovo);
itemEstUsuTpfaNovo.setDataUltManutencao(Data.getDataAtual());
itemEstUsuTpfaNovo.setItemEstruturaIett(novoItem);
//itemEstUsuTpfaNovo.atribuirPKPai();
//itemEstUsuTpfaNovo.setUsuarioUsu(usuarioLogado);
itemEstUsuTpfaNovo.setUsuManutencao(usuarioLogado);
itemEstUsuTpfaDadosGerais.add(itemEstUsuTpfaNovo);
//session.save(itemEstUsuTpfaNovo);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return itemEstUsuTpfaDadosGerais;
}
/**
* Gera e retorna uma c�pia da cole��o de agendas relacionada com um ItemEstrutura
*
* @param novoItem
* @param agendasOrigem
* @return Set de AgendaAge
*/
private Set copiarAgendas(ItemEstruturaIett novoItem, Set agendasOrigem, UsuarioUsu usuarioLogado){
Set agendas = new HashSet();
Iterator itAgendasORigem = agendasOrigem.iterator();
while (itAgendasORigem.hasNext()){
try{
AgendaAge agendaOrigem = (AgendaAge)itAgendasORigem.next();
AgendaAge copiaAgenda = new AgendaAge();
Entidade.clonarPojo(agendaOrigem, copiaAgenda);
copiaAgenda.setCodAge(null);
copiaAgenda.setItemEstruturaIett(novoItem);
copiaAgenda.setUsuarioUsu(usuarioLogado);
agendas.add(copiaAgenda);
session.save(copiaAgenda);
//DestaqueItemRelDtqirs
Iterator itDestaquesOrigem = agendaOrigem.getDestaqueItemRelDtqirs().iterator();
copiaAgenda.setDestaqueItemRelDtqirs(new HashSet());
while (itDestaquesOrigem.hasNext()){
DestaqueItemRelDtqir destaqueItemOrigem = (DestaqueItemRelDtqir)itDestaquesOrigem.next();
DestaqueItemRelDtqir destaqueItemNovo = new DestaqueItemRelDtqir();
Entidade.clonarPojo(destaqueItemOrigem, destaqueItemNovo);
destaqueItemNovo.setAgendaAge(copiaAgenda);
destaqueItemNovo.setCodDtqir(null);
copiaAgenda.getDestaqueItemRelDtqirs().add(destaqueItemNovo);
session.save(destaqueItemNovo);
}
//AgendaOcorrenciaAgeos
Iterator itOcorrenciasOrigem = copiaAgenda.getAgendaOcorrenciaAgeos().iterator();
copiaAgenda.setAgendaOcorrenciaAgeos(new HashSet());
while (itOcorrenciasOrigem.hasNext()){
AgendaOcorrenciaAgeo agendaOcorrenciaOrigem = (AgendaOcorrenciaAgeo)itOcorrenciasOrigem.next();
AgendaOcorrenciaAgeo agendaOcorrenciaNovo = new AgendaOcorrenciaAgeo();
Entidade.clonarPojo(agendaOcorrenciaOrigem, agendaOcorrenciaNovo);
agendaOcorrenciaNovo.setAgendaAge(copiaAgenda);
agendaOcorrenciaNovo.setCodAgeo(null);
copiaAgenda.getAgendaOcorrenciaAgeos().add(agendaOcorrenciaNovo);
session.save(agendaOcorrenciaNovo);
}
//AgendaEntidadesAgeent
Iterator itEntidadesOrigem = agendaOrigem.getAgendaEntidadesAgeent().iterator();
copiaAgenda.setAgendaEntidadesAgeent(new HashSet());
while (itEntidadesOrigem.hasNext()){
AgendaEntidadesAgeent agendaEntidadeOrigem = (AgendaEntidadesAgeent)itEntidadesOrigem.next();
AgendaEntidadesAgeent agendaEntidadeNovo = new AgendaEntidadesAgeent();
Entidade.clonarPojo(agendaEntidadeOrigem, agendaEntidadeNovo);
agendaEntidadeNovo.setAgendaAge(copiaAgenda);
agendaEntidadeNovo.atribuirPKPai();
agendaEntidadeNovo.setDataInclusaoAgeent(Data.getDataAtual());
agendaEntidadeNovo.setUsuarioUsuManutencao(usuarioLogado);
copiaAgenda.getAgendaEntidadesAgeent().add(agendaEntidadeNovo);
session.save(agendaEntidadeNovo);
}
}
catch (Exception e){
e.printStackTrace();
}
}
return agendas;
}
/**
* Gera e retorna uma c�pia da cole��o de Editores_Leitores
* (Permiss�o de Acesso) relacionada com um ItemEstrutura
*
* @param novoItem
* @param itensInseridos
* @param agendasOrigem
* @return Set de AgendaAge
*/
private Set copiarEditoresLeitores (ItemEstruturaIett itemOrigem, ItemEstruturaIett novoItem, Map itensInseridos, UsuarioUsu usuarioLogado){
Set permissoes = new HashSet();
Iterator itEditoresLeitoresOrigem = itemOrigem.getItemEstrutUsuarioIettusesByCodIett().iterator();
for (Iterator itIns = itensInseridos.keySet().iterator() ; itIns.hasNext();){
ItemEstruturaIett itemAntigo = (ItemEstruturaIett)itIns.next();
ItemEstruturaIett itemNovo = (ItemEstruturaIett)itensInseridos.get(itemAntigo);
}
while (itEditoresLeitoresOrigem.hasNext()){
try{
ItemEstrutUsuarioIettus editaLerUsuOrigem = (ItemEstrutUsuarioIettus)itEditoresLeitoresOrigem.next();
if (editaLerUsuOrigem.getCodTpPermIettus() != null &&
(editaLerUsuOrigem.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_USUARIO) ||
editaLerUsuOrigem.getCodTpPermIettus().equals(ControlePermissao.PERMISSAO_GRUPO))){
ItemEstrutUsuarioIettus copiaEditaLer = new ItemEstrutUsuarioIettus();
Entidade.clonarPojo(editaLerUsuOrigem, copiaEditaLer);
copiaEditaLer.setCodIettus(null);
copiaEditaLer.setItemEstruturaIett(novoItem);
copiaEditaLer.setDataInclusaoIettus(Data.getDataAtual());
// copiaEditaLer.setUsuarioUsu(usuarioLogado);
copiaEditaLer.setUsuManutencao(usuarioLogado);
if (copiaEditaLer.getItemEstruturaIettOrigem().getCodIett().equals(itemOrigem.getCodIett())){
copiaEditaLer.setItemEstruturaIettOrigem (novoItem);
} else if (itensInseridos.containsKey(copiaEditaLer.getItemEstruturaIettOrigem())){
ItemEstruturaIett iettNovo = (ItemEstruturaIett) itensInseridos.get(copiaEditaLer.getItemEstruturaIettOrigem());
copiaEditaLer.setItemEstruturaIettOrigem (iettNovo);
}
permissoes.add(copiaEditaLer);
session.save(copiaEditaLer);
}
} catch (Exception e){
e.printStackTrace();
}
}
return permissoes;
}
/**
* Gera e retorna uma c�pia da cole��o de Editores_Leitores EditoresLeitores que se
* referem a fun��es de acompanhamento apenas, relacionada com um ItemEstrutura
*
* @param novoItem
* @param itensInseridos
* @param agendasOrigem
* @return Set de ItemEstrutUsuarioIettus
*/
// private Set copiarPermissoesFuncoesAcompanhamento (ItemEstruturaIett itemOrigem, ItemEstruturaIett novoItem, Map itensInseridos, UsuarioUsu usuarioLogado){
//
// Set permissoes = new HashSet();
//
// Iterator itEditoresLeitoresOrigem = itemOrigem.getItemEstrutUsuarioIettusesByCodIett().iterator();
//
// for (Iterator itIns = itensInseridos.keySet().iterator() ; itIns.hasNext();){
// ItemEstruturaIett itemAntigo = (ItemEstruturaIett)itIns.next();
// ItemEstruturaIett itemNovo = (ItemEstruturaIett)itensInseridos.get(itemAntigo);
// }
//
// while (itEditoresLeitoresOrigem.hasNext()){
//
// try{
//
// ItemEstrutUsuarioIettus editaLerUsuOrigem = (ItemEstrutUsuarioIettus)itEditoresLeitoresOrigem.next();
//
// if (editaLerUsuOrigem.getTipoFuncAcompTpfa() != null){
//
// ItemEstrutUsuarioIettus copiaEditaLer = new ItemEstrutUsuarioIettus();
// Entidade.clonarPojo(editaLerUsuOrigem, copiaEditaLer);
// copiaEditaLer.setCodIettus(null);
// copiaEditaLer.setItemEstruturaIett(novoItem);
// copiaEditaLer.setDataInclusaoIettus(Data.getDataAtual());
// copiaEditaLer.setUsuarioUsu(usuarioLogado);
// copiaEditaLer.setUsuarioUsu(usuarioLogado);
//
// if (copiaEditaLer.getItemEstruturaIettOrigem().getCodIett().equals(itemOrigem.getCodIett())){
// copiaEditaLer.setItemEstruturaIettOrigem (novoItem);
// } else if (itensInseridos.containsKey(copiaEditaLer.getItemEstruturaIettOrigem())){
// ItemEstruturaIett iettNovo = (ItemEstruturaIett) itensInseridos.get(copiaEditaLer.getItemEstruturaIettOrigem());
// copiaEditaLer.setItemEstruturaIettOrigem (iettNovo);
// }
// permissoes.add(copiaEditaLer);
// session.save(copiaEditaLer);
// }
// }
// catch (Exception e){
// e.printStackTrace();
// }
// }
//
// return permissoes;
// }
private Set copiarDemandasAssociadas (ItemEstruturaIett novoItem, Set demandasAssociadasOrigem){
Set demandasAssociadas = new HashSet();
novoItem.setItemRegdemandaIregds(new HashSet());
Iterator itDemandasAssociadasOrigem = demandasAssociadasOrigem.iterator();
while (itDemandasAssociadasOrigem.hasNext()){
try{
RegDemandaRegd demandaAssociadaOrigem = (RegDemandaRegd)itDemandasAssociadasOrigem.next();
demandaAssociadaOrigem.getItemRegdemandaIregds().add(novoItem);
demandasAssociadas.add(demandaAssociadaOrigem);
}
catch (Exception e){
e.printStackTrace();
}
}
return demandasAssociadas;
}
private Set copiarBeneficiarios (ItemEstruturaIett novoItem, Set beneficiariosOrigem, UsuarioUsu usuarioLogado){
Iterator iterator = beneficiariosOrigem.iterator();
novoItem.setItemEstrtBenefIettbs(new HashSet());
while (iterator.hasNext()){
try{
ItemEstrtBenefIettb beneficiarioOrigem = (ItemEstrtBenefIettb)iterator.next();
ItemEstrtBenefIettb beneficiarioNovo = new ItemEstrtBenefIettb();
Entidade.clonarPojo(beneficiarioOrigem, beneficiarioNovo);
beneficiarioNovo.setItemEstruturaIett(novoItem);
beneficiarioNovo.atribuirPKPai();
beneficiarioNovo.setDataUltManutencaoIettb(Data.getDataAtual());
beneficiarioNovo.setUsuarioUsuManutencao(usuarioLogado);
novoItem.getItemEstrtBenefIettbs().add(beneficiarioNovo);
session.save(beneficiarioNovo);
}
catch (Exception e){
e.printStackTrace();
}
}
return novoItem.getItemEstrtBenefIettbs();
}
private Set copiarCategorias(ItemEstruturaIett novoItem, Set categoriasOrigem, UsuarioUsu usuarioLogado) throws ECARException{
Iterator itCategoriasOrigem = categoriasOrigem.iterator();
ConfiguracaoCfg configuracaoCfg = new ConfiguracaoDao(request).getConfiguracao();
while (itCategoriasOrigem.hasNext()){
try{
ItemEstrUplCategIettuc categoriaOrigem = (ItemEstrUplCategIettuc)itCategoriasOrigem.next();
ItemEstrUplCategIettuc categoriaNovo = new ItemEstrUplCategIettuc();
Entidade.clonarPojo(categoriaOrigem, categoriaNovo);
categoriaNovo.setCodIettuc(null);
categoriaNovo.setItemEstruturaIett(novoItem);
categoriaNovo.setDataInclusaoIettuc(Data.getDataAtual());
session.save(categoriaNovo);
//C�pia os itens anexos
//itemEstrutUploadIettup
//C�PIA DOS ARQUIVOS ANEXOS DO ITEM
Iterator itArquivosUpload = categoriaOrigem.getItemEstrutUploadIettups().iterator();
categoriaNovo.setItemEstrutUploadIettups(new HashSet());
while (itArquivosUpload.hasNext()){
try{
ItemEstrutUploadIettup uploadOrigem = (ItemEstrutUploadIettup)itArquivosUpload.next();
ItemEstrutUploadIettup copiaUpload = new ItemEstrutUploadIettup();
Entidade.clonarPojo(uploadOrigem, copiaUpload);
copiaUpload.setCodIettup(null);
copiaUpload.setItemEstruturaIett(novoItem);
copiaUpload.setItemEstrUplCategIettuc(categoriaNovo);
copiaUpload.setDataInclusaoIettup(Data.getDataAtual());
copiaUpload.setUsuarioUsu(usuarioLogado);
copiaUpload.setUsuarioUsuManutencao(usuarioLogado);
String formato = "ddMMyyyyHHmmssSSS";
SimpleDateFormat formatter = new SimpleDateFormat(formato);
String dataGravacao = formatter.format(new Date());
String pathRaiz = configuracaoCfg.getRaizUpload();//_msg.getPathUploadRaiz("path .upload.raiz");
String pathAnexo = configuracaoCfg.getUploadAnexos();
//Faz a copia do arquivo armazenado no servidor.
copiaUpload.setArquivoIettup(FileUpload.getPathFisico("", pathAnexo, dataGravacao+" - "+ uploadOrigem.getNomeOriginalIettup()));
copiaUpload.setNomeOriginalIettup(uploadOrigem.getNomeOriginalIettup());
copiaUpload.setTamanhoIettup(uploadOrigem.getTamanhoIettup());
String arquivoOrigem = pathRaiz + uploadOrigem.getArquivoIettup();
String arquivoDestino = FileUpload.getPathFisico(pathRaiz, pathAnexo, dataGravacao+" - "+copiaUpload.getNomeOriginalIettup());
try {
FileUpload.copiarArquivo(arquivoOrigem, arquivoDestino);
} catch (IOException e) {
e.printStackTrace();
}
session.save(copiaUpload);
categoriaNovo.getItemEstrutUploadIettups().add(copiaUpload);
}
catch (Exception e){
e.printStackTrace();
}
}
}
catch (Exception e){
e.printStackTrace();
}
}
return novoItem.getItemEstrUplCategIettucs();
}
private Set copiarCriterios( ItemEstruturaIett novoItem, Set criterios, UsuarioUsu usuarioLogado) {
Iterator itOrigem = criterios.iterator();
novoItem.setItemEstrutCriterioIettcs(new HashSet());
while (itOrigem.hasNext()){
try{
ItemEstrutCriterioIettc criterioOrigem = (ItemEstrutCriterioIettc)itOrigem.next();
ItemEstrutCriterioIettc criterioNovo = new ItemEstrutCriterioIettc();
Entidade.clonarPojo(criterioOrigem, criterioNovo);
//criterio.set CodIettus(null);
criterioNovo.setItemEstruturaIett(novoItem);
criterioNovo.setDataUltManutencao(Data.getDataAtual());
criterioNovo.setUsuManutencao(usuarioLogado);
criterioNovo.atribuirPK();
novoItem.getItemEstrutCriterioIettcs().add(criterioNovo);
session.save(criterioNovo);
}
catch (Exception e){
e.printStackTrace();
}
}
return novoItem.getItemEstrutCriterioIettcs();
}
private Set copiarEntidades( ItemEstruturaIett novoItem, Set entidades, UsuarioUsu usuarioLogado) {
// Set entidadesAdicionadas = new HashSet();
Iterator itOrigem = entidades.iterator();
novoItem.setItemEstrutEntidadeIettes(new HashSet());
while (itOrigem.hasNext()){
try{
ItemEstrutEntidadeIette entidadeOrigem = (ItemEstrutEntidadeIette)itOrigem.next();
ItemEstrutEntidadeIette entidadeNovo = new ItemEstrutEntidadeIette();
Entidade.clonarPojo(entidadeOrigem, entidadeNovo);
entidadeNovo.setItemEstruturaIett(novoItem);
entidadeNovo.setDataUltManutencaoIette(Data.getDataAtual());
entidadeNovo.setUsuarioUsuManutencao(usuarioLogado);
entidadeNovo.atribuirPK();
novoItem.getItemEstrutEntidadeIettes().add(entidadeNovo);
// entidadesAdicionadas.add(entidadeNovo);
session.save(entidadeNovo);
}
catch (Exception e){
e.printStackTrace();
}
}
return novoItem.getItemEstrutEntidadeIettes();
}
private Set copiarEventos(ItemEstruturaIett novoItem, Set acao, UsuarioUsu usuarioLogado) {
// Set acoesAdicionadas = new HashSet();
Iterator itOrigem = acao.iterator();
novoItem.setItemEstrutAcaoIettas(new HashSet());
while (itOrigem.hasNext()){
try{
ItemEstrutAcaoIetta acaoOrigem = (ItemEstrutAcaoIetta)itOrigem.next();
ItemEstrutAcaoIetta acaoNova = new ItemEstrutAcaoIetta();
Entidade.clonarPojo(acaoOrigem, acaoNova);
acaoNova.setCodIetta(null);
acaoNova.setItemEstruturaIett(novoItem);
acaoNova.setDataInclusaoIetta(Data.getDataAtual());
acaoNova.setUsuarioUsu(usuarioLogado);
acaoNova.setUsuarioUsuManutencao(usuarioLogado);
novoItem.getItemEstrutAcaoIettas().add(acaoNova);
// acoesAdicionadas.add(entidadeNovo);
session.save(acaoNova);
}
catch (Exception e){
e.printStackTrace();
}
}
return novoItem.getItemEstrutAcaoIettas();
}
private Set copiarFonteRecursos (ItemEstruturaIett novoItem, Set fonteRecursosOrigem){
Set fonteRecursos = new HashSet();
Iterator iterator = fonteRecursosOrigem.iterator();
novoItem.setEfIettFonteTotEfiefts(new HashSet());
while (iterator.hasNext()){
try{
EfIettFonteTotEfieft fonteRecursoOrigem = (EfIettFonteTotEfieft)iterator.next();
EfIettFonteTotEfieft fonteRecursoNovo = new EfIettFonteTotEfieft();
Entidade.clonarPojo(fonteRecursoOrigem, fonteRecursoNovo);
fonteRecursoNovo.setItemEstruturaIett(novoItem);
fonteRecursoNovo.atribuirPKPai();
novoItem.getEfIettFonteTotEfiefts().add(fonteRecursoNovo);
session.save(fonteRecursoNovo);
}
catch (Exception e){
e.printStackTrace();
}
}
return novoItem.getEfIettFonteTotEfiefts();
}
private Set copiarPontosCriticos(ItemEstruturaIett novoItem, Set pontosCriticosOrigem, UsuarioUsu usuarioLogado){
Iterator itPontosCriticosOrigem = pontosCriticosOrigem.iterator();
PontoCriticoDao ptcDao = new PontoCriticoDao(null);
ActionSisAtributo action = new ActionSisAtributo();
FuncaoFun funcaoPontoCritico = new FuncaoFun();
funcaoPontoCritico.setNomeFun(FuncaoDao.NOME_FUNCAO_PONTOS_CRITICOS);
List funcoes=null;
while (itPontosCriticosOrigem.hasNext()){
try{
funcoes = (new FuncaoDao(request)).pesquisar(funcaoPontoCritico, null);
if (funcoes!=null && funcoes.size()>0){
funcaoPontoCritico = (FuncaoFun)funcoes.get(0);
}
PontoCriticoPtc pontoCriticoOrigem = (PontoCriticoPtc)itPontosCriticosOrigem.next();
if (!pontoCriticoOrigem.getIndExcluidoPtc().equals("S")){
PontoCriticoPtc pontoCriticoNovo = new PontoCriticoPtc();
Entidade.clonarPojo(pontoCriticoOrigem, pontoCriticoNovo);
pontoCriticoNovo.setCodPtc(null);
pontoCriticoNovo.setItemEstruturaIett(novoItem);
pontoCriticoNovo.setDataUltManutencaoPtc(Data.getDataAtual());
pontoCriticoNovo.setUsuarioUsuInclusao(usuarioLogado);
pontoCriticoNovo.setUsuarioUsuByCodUsuUltManutPtc(usuarioLogado);
pontoCriticoNovo.setUsuarioUsu(pontoCriticoOrigem.getUsuarioUsu());
session.save(pontoCriticoNovo);
//C�PIA DOS ATRIBUTOS LIVRES
Set atributosLivresPontosCriticos = new HashSet();
Iterator itPontoCriticoSisAtributos = pontoCriticoOrigem.getPontoCriticoSisAtributoPtcSatbs().iterator();
while (itPontoCriticoSisAtributos.hasNext()){
PontoCriticoSisAtributoPtcSatb pontoCriticoSisAtributoOrigem = (PontoCriticoSisAtributoPtcSatb) itPontoCriticoSisAtributos.next();
PontoCriticoSisAtributoPtcSatb pontoCriticoSisAtributoNovo = new PontoCriticoSisAtributoPtcSatb();
pontoCriticoSisAtributoNovo.setDataUltManutencao(Data.getDataAtual());
// pontoCriticoSisAtributoNovo.setUsuarioUsu(usuarioLogado);
pontoCriticoSisAtributoNovo.setPontoCriticoPtc(pontoCriticoNovo);
pontoCriticoSisAtributoNovo.setSisAtributoSatb(pontoCriticoSisAtributoOrigem.getSisAtributoSatb());
pontoCriticoSisAtributoNovo.setUsuarioUsu(pontoCriticoSisAtributoOrigem.getUsuarioUsu());
//Para atributos do tipo CAMPO_ID
if (pontoCriticoSisAtributoOrigem.getInformacao() != null && pontoCriticoSisAtributoOrigem.getSisAtributoSatb().getAtribInfCompSatb() !=null
&& (pontoCriticoSisAtributoOrigem.getSisAtributoSatb().isAtributoContemMascara() || pontoCriticoSisAtributoOrigem.getSisAtributoSatb().isAtributoAutoIcremental())){
if (!pontoCriticoSisAtributoOrigem.getSisAtributoSatb().isAtributoAutoIcremental()){
pontoCriticoSisAtributoNovo.setInformacao(action.geraConteudo(pontoCriticoSisAtributoOrigem.getSisAtributoSatb().getMascara()));
}
geraValorIncremental(pontoCriticoSisAtributoNovo, pontoCriticoSisAtributoNovo.getSisAtributoSatb(), funcaoPontoCritico, pontoCriticoSisAtributoNovo.getPontoCriticoPtc().getItemEstruturaIett().getEstruturaEtt(), null);
//Para atributos do tipo TEXT, TEXTAREA, MULTITEXTO, IMAGEM e VALIDA��O
} else if (pontoCriticoSisAtributoOrigem.getInformacao() != null){
pontoCriticoSisAtributoNovo.setInformacao(pontoCriticoSisAtributoOrigem.getInformacao());
}
pontoCriticoSisAtributoNovo.atribuirPKPai();
// atributosLivresPontosCriticos.add(pontoCriticoSisAtributoNovo);
session.save(pontoCriticoSisAtributoNovo);
}
//C�PIA DOS APONTAMENTOS
Iterator itApontamentosOrigem = pontoCriticoOrigem.getApontamentoApts().iterator();
pontoCriticoNovo.setApontamentoApts(new HashSet());
while (itApontamentosOrigem.hasNext()){
try{
ApontamentoApt apontamentoOrigem = (ApontamentoApt)itApontamentosOrigem.next();
ApontamentoApt copiaApontamento = new ApontamentoApt();
Entidade.clonarPojo(apontamentoOrigem, copiaApontamento);
copiaApontamento.setCodApt(null);
copiaApontamento.setItemEstruturaIett(novoItem);
copiaApontamento.setPontoCriticoPtc(pontoCriticoNovo);
copiaApontamento.setDataInclusaoApt(Data.getDataAtual());
copiaApontamento.setUsuarioUsu(apontamentoOrigem.getUsuarioUsu());
session.save(copiaApontamento);
pontoCriticoNovo.getApontamentoApts().add(copiaApontamento);
}
catch (Exception e){
e.printStackTrace();
}
}
HistoricoPontoCriticoPtc hptc = new HistoricoPontoCriticoPtc();
hptc.carregar(pontoCriticoNovo);
ptcDao.gerarHistorico(hptc, Historico.INCLUIR, usuarioLogado);
}
}
catch (Exception e){
e.printStackTrace();
}
}
// return atributosLivresDadosGerais;
return novoItem.getPontoCriticoPtcs();
}
private Set copiarLocalizacao(ItemEstruturaIett novoItem, Set locaisItens, UsuarioUsu usuarioLogado) {
Iterator itOrigem = locaisItens.iterator();
novoItem.setItemEstrutLocalIettls(new HashSet());
while (itOrigem.hasNext()){
try{
ItemEstrutLocalIettl localOrigem = (ItemEstrutLocalIettl)itOrigem.next();
ItemEstrutLocalIettl localNovo = new ItemEstrutLocalIettl();
Entidade.clonarPojo(localOrigem, localNovo);
localNovo.setItemEstruturaIett(novoItem);
localNovo.setDataInclusaoIettl(Data.getDataAtual());
localNovo.setUsuarioUsuManutencao(usuarioLogado);
localNovo.atribuirPKPai();
novoItem.getItemEstrutLocalIettls().add(localNovo);
session.save(localNovo);
}
catch (Exception e){
e.printStackTrace();
}
}
return novoItem.getItemEstrutLocalIettls();
}
private Set copiarMetasIndicadores(ItemEstruturaIett novoItem, Set setMetasIndicadores, UsuarioUsu usuarioLogado) {
ItemEstrtIndResulIettr indResulOrigem = null;
ItemEstrtIndResulIettr indResulNovo = null;
Iterator iterator = null;
Date dataAtual = Data.getDataAtual();
Iterator itOrigem = setMetasIndicadores.iterator();
novoItem.setItemEstrtIndResulIettrs(new HashSet());
try{
while (itOrigem.hasNext()){
indResulNovo = new ItemEstrtIndResulIettr();
indResulOrigem = (ItemEstrtIndResulIettr)itOrigem.next();
//Est� dando problema de lazy no m�todo clonarPojo
//Como atualmente a equipe nao sabe para q serve esta propriedade e ela apresenta um erro de Lazy foi colocada como null
indResulOrigem.setItemEstruturaIettPPA(null);
Entidade.clonarPojo(indResulOrigem, indResulNovo);
indResulNovo.setCodIettir(null);
indResulNovo.setItemEstruturaIett(novoItem);
indResulNovo.setDataUltManutencao(dataAtual);
indResulNovo.setUsuarioUsuManutencao(usuarioLogado);
if (indResulNovo.getIndAtivoIettr().equals(Dominios.SIM)) {
novoItem.getItemEstrtIndResulIettrs().add(indResulNovo);
session.save(indResulNovo);
} else {
continue;
}
//ItemEstrutFisicoIettf
iterator = indResulOrigem.getItemEstrutFisicoIettfs().iterator();
indResulNovo.setItemEstrutFisicoIettfs(new HashSet());
while (iterator.hasNext()){
ItemEstrutFisicoIettf indResultFisicoOrigem = (ItemEstrutFisicoIettf)iterator.next();
ItemEstrutFisicoIettf indResultFisicoNovo = new ItemEstrutFisicoIettf();
Entidade.clonarPojo(indResultFisicoOrigem , indResultFisicoNovo);
indResultFisicoNovo.setDataUltManutencao(dataAtual);
indResultFisicoNovo.setItemEstrtIndResulIettr(indResulNovo);
//Mantis 0010128 - Qtd prevista n�o � mais informado por exerc�cio
//indResultFisicoNovo.atribuirPK();
session.save(indResultFisicoNovo);
indResulNovo.getItemEstrutFisicoIettfs().add(indResultFisicoNovo);
for(ItemEstrtIndResulLocalIettirl itemLocal:indResultFisicoOrigem.getItemEstrtIndResulLocalIettirls()){
ItemEstrtIndResulLocalIettirl itemOrigem = itemLocal;
ItemEstrtIndResulLocalIettirl itemNovo = new ItemEstrtIndResulLocalIettirl();
Entidade.clonarPojo(itemOrigem , itemNovo);
itemNovo.setDataInclusaoIettirl(dataAtual);
itemNovo.setItemEstrutFisicoIettf(indResultFisicoNovo);
session.save(itemNovo);
indResultFisicoNovo.getItemEstrtIndResulLocalIettirls().add(itemNovo);
}
}
//agora o previsto por local est� associa a um ItemEstrutFisicoIettf
//o c�digo abaixo n�o � mais necess�rio
// //ItemEstrtIndResulLocalIettirl
// iterator = indResulOrigem.getItemEstrtIndResulLocalIettirls().iterator();
// indResulNovo.setItemEstrtIndResulLocalIettirls(new HashSet());
//
// while (iterator.hasNext()){
// ItemEstrtIndResulLocalIettirl indResultLocalOrigem= (ItemEstrtIndResulLocalIettirl)iterator.next();
// ItemEstrtIndResulLocalIettirl indResultLocalNovo = new ItemEstrtIndResulLocalIettirl();
//
// Entidade.clonarPojo(indResultLocalOrigem , indResultLocalNovo);
// indResultLocalNovo.setCodIettirl(null);
// indResultLocalNovo.setDataInclusaoIettirl(dataAtual);
//
// //Mantis 0010128 - Qtd prevista n�o � mais informado por exerc�cio
// //Este m�todo precisa ser refeito. Previsto por local nao esta mais
// //associado diretamente com o indicador.
//
// //linha comentada:
// //indResultLocalNovo.setItemEsrtIndResulIettr(indResulNovo);
//
// session.save(indResultLocalNovo);
// indResulNovo.getItemEstrtIndResulLocalIettirls().add(indResultLocalNovo);
// }
//ItemEstrtIndResulCorIettrcor
iterator = indResulOrigem.getItemEstrtIndResulCorIettrcores().iterator();
indResulNovo.setItemEstrtIndResulCorIettrcores(new HashSet());
while (iterator.hasNext()){
ItemEstrtIndResulCorIettrcor indResultCorOrigem = (ItemEstrtIndResulCorIettrcor)iterator.next();
ItemEstrtIndResulCorIettrcor indResultCorNovo = new ItemEstrtIndResulCorIettrcor();
Entidade.clonarPojo( indResultCorOrigem, indResultCorNovo);
indResultCorNovo.setItemEstrtIndResulIettr(indResulNovo);
indResultCorNovo.atribuirPKPai();
session.save(indResultCorNovo);
indResulNovo.getItemEstrtIndResulCorIettrcores().add(indResultCorNovo);
}
} //FIM WHILE itOrigem
}
catch (Exception e){
e.printStackTrace();
}
return novoItem.getItemEstrtIndResulIettrs();
}
/*
* Hist�rico
*/
private void gerarHistorico(HistoricoItemEstruturaIett historicoItemEstruturaIett, Long tipoHistorico) throws ECARException {
Historico historico = new Historico<HistoricoItemEstruturaIett, ItemEstruturaIett>() {};
//Grupo de atributo configurado como n�vel de planejamento
SisGrupoAtributoSga sisGrupoAtributoNivelPlanejamento = null;
if (historicoItemEstruturaIett != null) {
EstruturaEtt ett = historicoItemEstruturaIett.getEstruturaEtt();
//Pega todos os atributos/fun��es de acompanhamento configurados para a fun��o de dados gerais
List<ObjetoEstrutura> lista = (new EstruturaDao(null)).getAtributosEstruturaDadosGerais(ett);
//Inicializa a cole��o de atributos livres
Hibernate.initialize(historicoItemEstruturaIett.getItemEstruturaSisAtributoIettSatbs());
//Percorre a lista de atributos/fun��es para inicializar as cole��es
for (ObjetoEstrutura etta : lista) {
if (etta.iGetGrupoAtributosLivres() != null){
Hibernate.initialize(etta.iGetGrupoAtributosLivres());
if (etta.iGetGrupoAtributosLivres().getSisAtributoSatbs() != null){
Hibernate.initialize(etta.iGetGrupoAtributosLivres().getSisAtributoSatbs());
}
}
if (etta.iGetLibTipoFuncAcompTpfas() != null){
Hibernate.initialize(etta.iGetLibTipoFuncAcompTpfas());
}
}
if (lista != null)
historicoItemEstruturaIett.setAtributoEstrutura(lista);
sisGrupoAtributoNivelPlanejamento = new ConfiguracaoDao(null).getConfiguracao().getSisGrupoAtributoSgaByCodSgaGrAtrNvPlan();
//Inicializa os objetos dependentes do grupo de atributo do n�vel de planejamento
if (sisGrupoAtributoNivelPlanejamento != null){
if (sisGrupoAtributoNivelPlanejamento.getSisTipoExibicGrupoSteg() != null){
Hibernate.initialize(sisGrupoAtributoNivelPlanejamento.getSisTipoExibicGrupoSteg());
}
if (sisGrupoAtributoNivelPlanejamento.getSisAtributoSatbs() != null){
Hibernate.initialize(sisGrupoAtributoNivelPlanejamento.getSisAtributoSatbs());
}
historicoItemEstruturaIett.setSisGrupoAtributoNivelPlanejamento(sisGrupoAtributoNivelPlanejamento);
}
if (historicoItemEstruturaIett.getItemEstruturaNivelIettns() != null){
Hibernate.initialize(historicoItemEstruturaIett.getItemEstruturaNivelIettns());
}
historico.setHistorico(historicoItemEstruturaIett, tipoHistorico, ((ecar.login.SegurancaECAR) request.getSession().getAttribute("seguranca")).getUsuario(),
session);
ett = null;
lista = null;
}
historico = null;
sisGrupoAtributoNivelPlanejamento = null;
}
/**
* Consulta a lista de ItensAtivos ativos que utilizam o atributo Livre
* utilizado como par�metro.
*
* @param sisAtributo
* @return
* @throws ECARException
*/
public List<PontoCriticoSisAtributoPtcSatb> consultarItensEstruturaSisAtributoAtivos(SisAtributoSatb sisAtributo) throws ECARException {
try {
String hql = MessageFormat.format(Util.getHql(ConstantesECAR.PESQUISA_ITEMESTRUTURA_ATRIBUTOLIVRE_ATIVO, request.getSession().getServletContext()),sisAtributo.getCodSatb(),"\'S\'");
Query query = this.session.createQuery(hql);
return query.list();
}
catch (IOException ioex) {
this.logger.error(ioex);
throw new ECARException(ioex);
}
catch (HibernateException e) {
this.logger.error(e);
throw new ECARException(e);
}
}
/**
* Retorna o Objeto do tipo Sequencial contido na lista.
* @param itemEstruturaSisAtributo
* @return
* @throws ECARException
*/
public TipoValor obterTipoSequencial(ItemEstruturaSisAtributoIettSatb itemEstruturaSisAtributo) throws ECARException {
TipoValor tipoSeq = null;
Iterator<TipoValor> it = null;
try {
if (getSession().contains(itemEstruturaSisAtributo)) {
it = itemEstruturaSisAtributo.getTiposValores().iterator();
} else {
throw new ECARException(new Throwable("Sess�o encerrada."));
}
} catch (ECARException ecarex){
this.logger.error(ecarex.getCausaRaiz()+" Recupera��o realizada com sucesso.");
itemEstruturaSisAtributo = this.carregarObjetoItemEstruturaSisAtributo(itemEstruturaSisAtributo);
it = itemEstruturaSisAtributo.getTiposValores().iterator();
}
while (it.hasNext()) {
tipoSeq = (TipoValor)it.next();
if (tipoSeq.getTipo().compareTo(TipoValorEnum.SEQUENCIAL) == 0){
break;
}
}
return tipoSeq;
}
/**
* Utilizado para carregar o objeto ItemEstruturaSisAtributoIettSatb caso ele n�o esteja na sess�o do hibernate.
* TODO Novos atributos lazy poder�o ser adicionados ao Hibernate.initialize de acordo com a necessidade
* @param itemEstruturaSisAtributo
* @return
* @throws ECARException
*/
private ItemEstruturaSisAtributoIettSatb carregarObjetoItemEstruturaSisAtributo(ItemEstruturaSisAtributoIettSatb itemEstruturaSisAtributo) throws ECARException {
if (!getSession().contains(itemEstruturaSisAtributo)) {
itemEstruturaSisAtributo = (ItemEstruturaSisAtributoIettSatb) this.buscar(ItemEstruturaSisAtributoIettSatb.class,itemEstruturaSisAtributo.getComp_id());
}
Hibernate.initialize(itemEstruturaSisAtributo.getTiposValores());
return itemEstruturaSisAtributo;
}
/**
* efetua a carga inicial do hist�rico de dados gerais
* Devido ao problema de java heap space e ao problema de n�o termos tempo
* devido a entrega da vers�o, esse m�todo s� da a carga de 250 registros
* de item a cada vez que � chamado
* @throws ECARException
*/
public void cargaInicialHistorico() throws ECARException {
HistoricoItemEstruturaIett pojoHistorico = new HistoricoItemEstruturaIett();
HistoricoDao historicoDao = new HistoricoDao(request);
Transaction tx=null;
try {
String[] ordem = new String[] {"codIett", "asc"};
List<Long> listaIdObjetoSerializado = historicoDao.listaIdObjetoSerializado(HistoricoItemEstruturaIett.class);
List<ItemEstruturaIett> lista = getItemEstruturaIettSemHistorico(listaIdObjetoSerializado);
Iterator itLista = lista.iterator();
int count = 1;
ItemEstruturaIett iett = null;
while (itLista.hasNext() && count <= 250) {
iett = (ItemEstruturaIett) itLista.next();
System.out.println("Codigo Item: " + iett.getCodIett());
System.out.println("Contador Iett: " + count);
tx = session.beginTransaction();
pojoHistorico.carregar(iett);
gerarHistorico(pojoHistorico, Historico.INCLUIR);
tx.commit();
count++;
iett = null;
if (count%100 == 0){
System.gc();
}
}
pojoHistorico = null;
ordem = null;
lista = null;
listaIdObjetoSerializado = null;
}
catch (ECARException e) {
if (tx != null)
tx.rollback();
this.logger.error(e);
throw new ECARException(e);
}
}
/**
* Retorna os itens que ainda n�o tem hist�rico gerado.
* @param codigos
* @return
*/
public List getItemEstruturaIettSemHistorico(List<Long> codigos){
StringBuffer query = new StringBuffer();
query.append("select iett from ItemEstruturaIett iett where iett.indAtivoIett = 'S' and iett.estruturaEtt.indAtivoEtt = 'S' ");
if (codigos != null && codigos.size() > 0){
query.append("and iett.codIett not in (:codigos)");
}
Query q = this.session.createQuery(query.toString());
if (codigos != null && codigos.size() > 0){
q.setParameterList("codigos", codigos);
}
return q.list();
}
/**
* Retorna a quantidade de registros ativos de itemEstrutura
* @return
*/
public Integer getQuantidadeLinhasIettAtivos(){
Query q = this.session.createQuery("select count(iett) from ItemEstruturaIett iett where iett.indAtivoIett = 'S' and iett.estruturaEtt.indAtivoEtt = 'S'");
return (Integer) q.uniqueResult();
}
/**
* Cria o conte�do da coluna(<td>) que faz parte da linha do item(<tr>) que
* comp�e a tabela da �rvore de ajax.
* O nome do item � setado de acordo com a configura��o de estruturaAtributo.
*
* @param item
* @param estruturaSelecionada
* @return String nomeItem
* @throws ECARException
*/
public String criaColunaConteudoColunaArvoreAjax(ItemEstruturaIett item, EstruturaEtt estruturaSelecionada) throws ECARException{
String nomeItem = "";
EstruturaDao estruturaDao= new EstruturaDao(null);
ConfiguracaoCfg configuracaoCfg = new ConfiguracaoDao(request).getConfiguracao();
List atributos = estruturaDao.getAtributosArvoreEstrutura(estruturaSelecionada);
Iterator itAtributos = atributos.iterator();
if (item.getCodIett() != null){
item = (ItemEstruturaIett) this.buscar(ItemEstruturaIett.class, item.getCodIett());
}
if(!itAtributos.hasNext()){
nomeItem = "Atributo n�o configurado";
}else if (item.getCodIett() != null) {
while(itAtributos.hasNext()){
EstruturaAtributoEttat atributo = (EstruturaAtributoEttat) itAtributos.next();
boolean campoMultiValor = false;
boolean primeiro = true;
if (atributo.getAtributosAtb().getSisGrupoAtributoSga() == null) { //Se n�o for atributo livre
if (atributo.getAtributosAtb().getSisGrupoAtributoSga() == null) { //Se n�o for atributo livre
if("nivelPlanejamento".equals(atributo.iGetNome())){
String niveis = "";
if(item.getItemEstruturaNivelIettns() != null && !item.getItemEstruturaNivelIettns().isEmpty()){
Iterator itNiveis = item.getItemEstruturaNivelIettns().iterator();
while(itNiveis.hasNext()){
SisAtributoSatb nivel = (SisAtributoSatb) itNiveis.next();
niveis += nivel.getDescricaoSatb() + "; ";
}
niveis = niveis.substring(0, niveis.lastIndexOf(";"));
}
nomeItem += niveis + (itAtributos.hasNext() ? " - " : "");
}
else {
nomeItem += atributo.iGetValor(item) + (itAtributos.hasNext() ? " - " : "");
}
}
} else {//Se for atributo livre
Set<SisAtributoSatb> sisAtributos = atributo.getAtributosAtb().getSisGrupoAtributoSga().getSisAtributoSatbs();
Iterator sisAtributosIt = sisAtributos.iterator();
while(sisAtributosIt.hasNext()) { //Obtem os atributos livres do grupo
SisAtributoSatb sisAtributo = (SisAtributoSatb)sisAtributosIt.next();
ItemEstruturaSisAtributoIettSatbPK itemSisAtributoPk = new ItemEstruturaSisAtributoIettSatbPK(item.getCodIett(),sisAtributo.getCodSatb());
try {
//Busca o conteudo gravado para o atributo livre
ItemEstruturaSisAtributoIettSatb itemEstruturaSisAtributo = (ItemEstruturaSisAtributoIettSatb)this.buscar(ItemEstruturaSisAtributoIettSatb.class, itemSisAtributoPk);
if (itemEstruturaSisAtributo.getInformacao() != null && !itemEstruturaSisAtributo.getInformacao().equals("")) { //Alguns atributos livres n�o possuem conteudo no campo informa��o, caso possua deve obter a informa��o
if(campoMultiValor && !primeiro) {
nomeItem += configuracaoCfg.getSeparadorCampoMultivalor();
}
nomeItem += itemEstruturaSisAtributo.getInformacaoFormatada();
primeiro = false;
} else if(!sisAtributo.getDescricaoSatb().equals("")) {//caso n�o possua, deve obter apenas a descri��o do atributo livre. throws ECARException{
if(campoMultiValor && !primeiro) {
nomeItem += configuracaoCfg.getSeparadorCampoMultivalor();
}
nomeItem += sisAtributo.getDescricaoSatb();
primeiro = false;
}
} catch (ECARException ex){ //Retira o caracter "-" da �ltima posi��o da string, caso ele ocorra. Ex.: "Teste -" => "Teste"
//nomeItem += (sisAtributosIt.hasNext() ? configuracaoCfg.getSeparadorCampoMultivalor()+" " : "");
/*
if (!itAtributos.hasNext()) {
if (nomeItem.substring(nomeItem.length()-2, nomeItem.length()).contains("-")){
nomeItem = nomeItem.substring(0, nomeItem.length()-2);
}
}
*/
}
campoMultiValor = true;
}
nomeItem += (itAtributos.hasNext() ? " - " : "");
}
}
}
/*
if (nomeItem.length() > 1 && nomeItem.substring(nomeItem.length()-2, nomeItem.length()).contains("-")){
nomeItem = nomeItem.substring(0, nomeItem.length()-2);
}
*/
//retira caracteres especiais
nomeItem = nomeItem.replace("\n", " ").replace("\r", " ").replace("\t", " ");
return nomeItem;
}
/**
* M�todo para carga de dados do PacInter - Tempor�rio
* @param codIettPai
* @param codEstrutura
* @param nomeItem
* @return
*/
public ItemEstruturaIett getItemEstruturaIett(String descricaoR1Pai, Long codEstruturaEtt, String nomeItem) throws ECARException{
ItemEstruturaIett itemEstruturaIett = null;
try {
StringBuffer hql = new StringBuffer();
hql.append("select itemEstruturaIett from ItemEstruturaIett itemEstruturaIett ");
hql.append("where itemEstruturaIett.itemEstruturaIett.descricaoR1 = :descricaoR1Pai and ");
hql.append("itemEstruturaIett.estruturaEtt.codEtt = :codEstruturaEtt and ");
hql.append("itemEstruturaIett.nomeIett = :nomeItem");
Query q = this.session.createQuery(hql.toString());
q.setString("descricaoR1Pai", descricaoR1Pai);
q.setLong("codEstruturaEtt", codEstruturaEtt);
q.setString("nomeItem", nomeItem);
q.setMaxResults(1);
itemEstruturaIett = (ItemEstruturaIett) q.uniqueResult();
}catch(HibernateException e) {
this.logger.error(e);
throw new ECARException("erro.hibernateException");
}
return itemEstruturaIett;
}
/**
* M�todo para carga de dados do PACInter Tempor�rio
* @param nomeIett
* @param siglaIett
* @return
* @throws ECARException
*/
public ItemEstruturaIett getItemEstruturaBySiglaDescricaoR1Avo(String siglaIett, String descricaoR1Avo) throws ECARException{
ItemEstruturaIett itemEstruturaIett = null;
try {
StringBuffer hql = new StringBuffer();
hql.append("select itemEstruturaIett from ItemEstruturaIett itemEstruturaIett ");
hql.append("where itemEstruturaIett.siglaIett = :siglaIett and ");
hql.append("itemEstruturaIett.itemEstruturaIett.itemEstruturaIett.descricaoR1 = :descricaoR1 ");
Query q = this.session.createQuery(hql.toString());
q.setString("siglaIett", siglaIett);
q.setString("descricaoR1", descricaoR1Avo);
q.setMaxResults(1);
itemEstruturaIett = (ItemEstruturaIett) q.uniqueResult();
}catch(HibernateException e) {
this.logger.error(e);
throw new ECARException("erro.hibernateException");
}
return itemEstruturaIett;
}
/**
*
* @param estruturaEtt
* @param descricaoR1
* @return
*/
public ItemEstruturaIett getItemEstruturaIettByEstruturaDescricaoR1(EstruturaEtt estruturaEtt, String descricaoR1) throws ECARException{
ItemEstruturaIett itemEstruturaIett = null;
try {
StringBuffer hql = new StringBuffer();
hql.append("select itemEstruturaIett from ItemEstruturaIett itemEstruturaIett ");
hql.append("where itemEstruturaIett.descricaoR1 = :descricaoR1 and ");
hql.append("itemEstruturaIett.estruturaEtt = :estruturaEtt and ");
hql.append("itemEstruturaIett.indAtivoIett = :indAtivo ");
Query q = this.session.createQuery(hql.toString());
q.setParameter("estruturaEtt", estruturaEtt);
q.setString("descricaoR1", descricaoR1);
q.setString("indAtivo", "S");
q.setMaxResults(1);
itemEstruturaIett = (ItemEstruturaIett) q.uniqueResult();
}catch(HibernateException e) {
this.logger.error(e);
throw new ECARException("erro.hibernateException");
}
return itemEstruturaIett;
}
/**
*
* @param estruturaEtt
* @param descricaoR1
* @return
*/
public ItemEstruturaIett getItemEstruturaIettByEstruturaDescricaoR3(EstruturaEtt estruturaEtt, ItemEstruturaIett itemBase, String descricaoR3) throws ECARException{
ItemEstruturaIett itemEstruturaIett = null;
try {
StringBuffer hql = new StringBuffer();
hql.append("select itemEstruturaIett from ItemEstruturaIett itemEstruturaIett ");
hql.append("where itemEstruturaIett.descricaoR3 = :descricaoR3 and ");
hql.append("itemEstruturaIett.itemEstruturaIett = :itemBase and ");
hql.append("itemEstruturaIett.estruturaEtt = :estruturaEtt and ");
hql.append("itemEstruturaIett.indAtivoIett = :indAtivo and ");
hql.append("itemEstruturaIett.itemEstruturaIett.indAtivoIett = :indAtivo ");
Query q = this.session.createQuery(hql.toString());
q.setParameter("estruturaEtt", estruturaEtt);
// q.setString("descricaoR1", descricaoR1);
q.setString("descricaoR3", descricaoR3);
q.setString("indAtivo", "S");
q.setParameter("itemBase", itemBase);
q.setMaxResults(1);
itemEstruturaIett = (ItemEstruturaIett) q.uniqueResult();
}catch(HibernateException e) {
this.logger.error(e);
throw new ECARException("erro.hibernateException");
}
return itemEstruturaIett;
}
/**
*
* @param estruturaEtt
* @param descricaoR1
* @return
*/
public ItemEstruturaIett getItemEstruturaIettByEstruturaDescricaoR3Validacao(EstruturaEtt estruturaEtt, String descricaoR1, String descricaoR3) throws ECARException{
ItemEstruturaIett itemEstruturaIett = null;
try {
StringBuffer hql = new StringBuffer();
hql.append("select itemEstruturaIett from ItemEstruturaIett itemEstruturaIett ");
hql.append("where itemEstruturaIett.itemEstruturaIett.descricaoR1 = :descricaoR1 and ");
hql.append("itemEstruturaIett.descricaoR3 = :descricaoR3 and ");
hql.append("itemEstruturaIett.estruturaEtt = :estruturaEtt and ");
hql.append("itemEstruturaIett.indAtivoIett = :indAtivo and ");
hql.append("itemEstruturaIett.itemEstruturaIett.indAtivoIett = :indAtivo ");
Query q = this.session.createQuery(hql.toString());
q.setParameter("estruturaEtt", estruturaEtt);
q.setString("descricaoR1", descricaoR1);
q.setString("descricaoR3", descricaoR3);
q.setString("indAtivo", "S");
q.setMaxResults(1);
itemEstruturaIett = (ItemEstruturaIett) q.uniqueResult();
}catch(HibernateException e) {
this.logger.error(e);
throw new ECARException("erro.hibernateException");
}
return itemEstruturaIett;
}
/**
*
* @param estruturaEtt
* @param siglaIett
* @return
*/
public ItemEstruturaIett getItemEstruturaIettByEstruturaSiglaIett(EstruturaEtt estruturaEtt, String siglaIett, String descricaoR1, String descricaoR3) throws ECARException{
ItemEstruturaIett itemEstruturaIett = null;
try {
StringBuffer hql = new StringBuffer();
hql.append("select itemEstruturaIett from ItemEstruturaIett itemEstruturaIett ");
hql.append("where itemEstruturaIett.siglaIett = :siglaIett and ");
hql.append("itemEstruturaIett.indAtivoIett = 'S' and ");
hql.append("itemEstruturaIett.estruturaEtt = :estruturaEtt and ");
hql.append("itemEstruturaIett.descricaoR1 = :descricaoR1 and ");
hql.append("itemEstruturaIett.descricaoR3 = :descricaoR3 ");
Query q = this.session.createQuery(hql.toString());
q.setParameter("estruturaEtt", estruturaEtt);
q.setString("siglaIett", siglaIett);
q.setString("descricaoR1", descricaoR1);
q.setString("descricaoR3", descricaoR3);
q.setMaxResults(1);
itemEstruturaIett = (ItemEstruturaIett) q.uniqueResult();
}catch(HibernateException e) {
this.logger.error(e);
throw new ECARException("erro.hibernateException");
}
return itemEstruturaIett;
}
/**
*
* @param estruturaEtt
* @param itemEstruturaSuperior
* @param nomeIett
* @return
* @throws ECARException
*/
public ItemEstruturaIett getItemEstruturaIett(EstruturaEtt estruturaEtt, ItemEstruturaIett itemEstruturaSuperior, String nomeIett) throws ECARException{
ItemEstruturaIett itemEstruturaIett = null;
try {
StringBuffer hql = new StringBuffer();
hql.append("select itemEstruturaIett from ItemEstruturaIett itemEstruturaIett ");
hql.append("where itemEstruturaIett.estruturaEtt = :estruturaEtt and ");
hql.append("itemEstruturaIett.itemEstruturaIett = :itemEstruturaSuperior and ");
hql.append("itemEstruturaIett.nomeIett = :nomeIett");
Query q = this.session.createQuery(hql.toString());
q.setParameter("estruturaEtt", estruturaEtt);
q.setParameter("itemEstruturaSuperior", itemEstruturaSuperior);
q.setString("nomeIett", nomeIett);
q.setMaxResults(1);
itemEstruturaIett = (ItemEstruturaIett) q.uniqueResult();
}catch(HibernateException e) {
this.logger.error(e);
throw new ECARException("erro.hibernateException");
}
return itemEstruturaIett;
}
/**
* Retorna uma lista com os meses que est�o entre as datas inicial e final do item.
*
* caso o item n�o tenha a data inicial ou final, retorna uma lista vazia.
*
* @param itemEstrutura:
* @return Lista com os meses que podem ser acompanhados pelo item
* @throws ECARException
*/
public List<GregorianCalendar> GetMesesReferencia(ItemEstruturaIett itemEstrutura) throws ECARException{
GregorianCalendar dataInicial = new GregorianCalendar();
GregorianCalendar dataFinal = new GregorianCalendar();
List<GregorianCalendar> resultado = new ArrayList<GregorianCalendar>();
dataInicial.setTime(this.ObtemDataInicialItemEstrutura(itemEstrutura));
dataInicial.set(Calendar.DAY_OF_MONTH, 1);
dataFinal.setTime(this.ObtemDataTerminoItemEstrutura(itemEstrutura));
dataFinal.set(Calendar.DAY_OF_MONTH, 1);
while(dataInicial.compareTo(dataFinal)<=0){
resultado.add((GregorianCalendar)dataInicial.clone());
dataInicial.add(GregorianCalendar.MONTH, 1);
}
return resultado;
}
public List<GregorianCalendar> GetMesesReferenciaFiltraAno(ItemEstruturaIett itemEstrutura, long ano) throws ECARException{
GregorianCalendar dataInicial = new GregorianCalendar();
GregorianCalendar dataFinal = new GregorianCalendar();
GregorianCalendar filtroDataInicial = new GregorianCalendar((int) ano,0,1);
GregorianCalendar filtroDataFinal = new GregorianCalendar((int) ano,11,31);
List<GregorianCalendar> resultado = new ArrayList<GregorianCalendar>();
dataInicial.setTime(this.ObtemDataInicialItemEstrutura(itemEstrutura));
dataFinal.setTime(this.ObtemDataTerminoItemEstrutura(itemEstrutura));
if ((dataInicial.compareTo(filtroDataFinal)<=0)&&(dataFinal.compareTo(filtroDataInicial)>=0)){
if (dataInicial.compareTo(filtroDataInicial)<=0){
dataInicial = filtroDataInicial;
}
if (dataFinal.compareTo(filtroDataFinal)>0){
dataFinal = filtroDataFinal;
}
while((dataInicial.get(GregorianCalendar.MONTH) <= dataFinal.get(GregorianCalendar.MONTH))&&
(dataInicial.get(GregorianCalendar.YEAR) == ano)){
resultado.add((GregorianCalendar)dataInicial.clone());
dataInicial.add(GregorianCalendar.MONTH, 1);
}
}
return resultado;
}
/**
*
* @param orgao
* @param acompReferencia
* @return
* @throws ECARException
*/
public List[] getItensAlterarAcompanhamentoPorOrgao( List itensSelecionaveis, OrgaoOrg orgao,
AcompReferenciaAref acompReferencia) throws ECARException {
ValidaPermissao validaPermissao = new ValidaPermissao();
List[] retorno = new List[2];
//M�todo exclui da lista de selecion�veis o itens que o usu�rio n�o tem acesso
List selecionaveis = this.getItensSelecionaveisFiltradosPorAtributo(itensSelecionaveis, acompReferencia.getTipoAcompanhamentoTa());
retorno[0] = getItensOrdenados(selecionaveis, acompReferencia.getTipoAcompanhamentoTa());
retorno[1] = selecionaveis;
return retorno;
}
public void atualizaIndNaoPorLocal(ItemEstruturaIett itemEstrutura){
for(Object indicador: itemEstrutura.getItemEstrtIndResulIettrs()){
ItemEstrtIndResulIettr item = (ItemEstrtIndResulIettr) indicador;
if (("S".equals(item.getIndPrevPorLocal()))||("S".equals(item.getIndRealPorLocal()))){
item.setIndPrevPorLocal("N");
item.setIndRealPorLocal("N");
item.setNivelAbrangencia(null);
try {
this.salvar(item);
} catch (ECARException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
/**
* Retorna a menor data inicial dos exerc�cios.
* Caso o item tenha a data inicial do cadastro maior que
* a data inicial dos exerc�cios retorna a data do cadastro.
* @param itemEstrutura
* @return
* @throws ECARException
*/
public Date ObtemDataInicialItemEstrutura(ItemEstruturaIett itemEstrutura) throws ECARException{
Date retorno = null;
Date dataInicioItem = null;
Date dataInicioExercicio = null;
dataInicioItem = itemEstrutura.getDataInicioIett();
ExercicioDao exercicioDao = new ExercicioDao(this.request);
dataInicioExercicio = exercicioDao.getDataInicialExePrimeiroExercicio();
if (dataInicioItem != null){
if (dataInicioItem.compareTo(dataInicioExercicio) > 0){
retorno = dataInicioItem;
}else{
retorno = dataInicioExercicio;
}
}
else{
retorno = dataInicioExercicio;
}
return retorno;
}
/**
* Retorna a data final de um item de estrutura.
* Retorna a maior data final dos exerc�cios.
* Caso o item tenha a data final do cadastro menor que a data
* final dos exerc�cios retorna a data do cadastro.
* @param itemEstrutura
* @return
* @throws ECARException
*/
public Date ObtemDataTerminoItemEstrutura(ItemEstruturaIett itemEstrutura) throws ECARException{
Date retorno = null;
Date dataTerminoItem = null;
Date dataFinalExercicio = null;
dataTerminoItem = itemEstrutura.getDataTerminoIett();
ExercicioDao exercicioDao = new ExercicioDao(this.request);
dataFinalExercicio = exercicioDao.getDataFinalExeUltimoExercicio();
if (dataTerminoItem != null){
if (dataTerminoItem.compareTo(dataFinalExercicio) < 0){
retorno = dataTerminoItem;
}
else{
retorno = dataFinalExercicio;
}
}
else{
retorno = dataFinalExercicio;
}
return retorno;
}
/**
* Retorna se um sisAtributoSatb de item est� sendo usado como atributo restritivo numa estrutura filha
* @param itemEstrutura
* @return
* @throws ECARException
*/
public boolean existeEstruturaFilhaUsandoAtributoComoRestritivo(ItemEstruturaIett itemEstrutura, SisAtributoSatb sisAtributo) throws ECARException{
boolean existe = false;
try {
//se a estrutura do item possui estruturas filhas
if(itemEstrutura != null && itemEstrutura.getEstruturaEtt() != null &&
(itemEstrutura.getEstruturaEtt().getEstruturaEtts() != null && !itemEstrutura.getEstruturaEtt().getEstruturaEtts().isEmpty())) {
//pesquisa se alguma estrutura filha usa o atributo como restritivo
StringBuffer hql = new StringBuffer();
hql.append("select estruturaEtt from EstruturaEtt estruturaEtt ");
hql.append("join estruturaEtt.sisAtributoSatbEttSuperior sisAtb ");
hql.append("join estruturaEtt.itemEstruturaIetts iett ");
hql.append("where sisAtb.codSatb = :codSatb ");
hql.append("and estruturaEtt.codEtt in (:listaCodEstruturaEtt) ");
hql.append("and iett.indAtivoIett = 'S' ");
hql.append("and iett.itemEstruturaIett = :itemEstruturaIett");
Query q = this.session.createQuery(hql.toString());
q.setParameter("codSatb", sisAtributo.getCodSatb());
List listaCodEstruturaEtt = new ArrayList();
Iterator itEstruturaFilhas = itemEstrutura.getEstruturaEtt().getEstruturaEtts().iterator();
while(itEstruturaFilhas.hasNext()) {
EstruturaEtt estrututuraFilha = (EstruturaEtt) itEstruturaFilhas.next();
listaCodEstruturaEtt.add(estrututuraFilha.getCodEtt());
}
q.setParameterList("listaCodEstruturaEtt", listaCodEstruturaEtt);
q.setEntity("itemEstruturaIett", itemEstrutura);
List listaItens = q.list();
if(listaItens != null && !listaItens.isEmpty()) {
existe = true;
}
}
return existe;
}catch(HibernateException e) {
this.logger.error(e);
throw new ECARException("erro.hibernateException");
}
}
/**
* Lista todos os itens de estrutura.
* @return
*/
public List<ItemEstruturaIett> getListaDeItens(){
String select = "select item from ItemEstruturaIett as item";
Query q = this.session.createQuery(select);
return q.list();
}
}