package br.com.centralit.citcorpore.negocio;
import java.io.File;
import java.sql.Date;
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import net.htmlparser.jericho.Source;
import org.apache.commons.lang.StringUtils;
import br.com.centralit.bpm.dto.PermissoesFluxoDTO;
import br.com.centralit.bpm.dto.TarefaFluxoDTO;
import br.com.centralit.citcorpore.bean.BaseConhecimentoDTO;
import br.com.centralit.citcorpore.bean.CategoriaProblemaDTO;
import br.com.centralit.citcorpore.bean.ConhecimentoProblemaDTO;
import br.com.centralit.citcorpore.bean.ContatoProblemaDTO;
import br.com.centralit.citcorpore.bean.ContratoDTO;
import br.com.centralit.citcorpore.bean.GrupoDTO;
import br.com.centralit.citcorpore.bean.ItemConfiguracaoDTO;
import br.com.centralit.citcorpore.bean.JustificativaProblemaDTO;
import br.com.centralit.citcorpore.bean.OcorrenciaProblemaDTO;
import br.com.centralit.citcorpore.bean.PesquisaProblemaDTO;
import br.com.centralit.citcorpore.bean.ProblemaDTO;
import br.com.centralit.citcorpore.bean.ProblemaItemConfiguracaoDTO;
import br.com.centralit.citcorpore.bean.ProblemaMudancaDTO;
import br.com.centralit.citcorpore.bean.ProblemaRelacionadoDTO;
import br.com.centralit.citcorpore.bean.RelatorioProblemaIncidentesDTO;
import br.com.centralit.citcorpore.bean.RelatorioQuantitativoProblemaDTO;
import br.com.centralit.citcorpore.bean.ServicoContratoDTO;
import br.com.centralit.citcorpore.bean.SolicitacaoServicoDTO;
import br.com.centralit.citcorpore.bean.SolicitacaoServicoProblemaDTO;
import br.com.centralit.citcorpore.bean.TemplateSolicitacaoServicoDTO;
import br.com.centralit.citcorpore.bean.UploadDTO;
import br.com.centralit.citcorpore.bean.UsuarioDTO;
import br.com.centralit.citcorpore.integracao.BaseConhecimentoDAO;
import br.com.centralit.citcorpore.integracao.CategoriaProblemaDAO;
import br.com.centralit.citcorpore.integracao.ConhecimentoProblemaDao;
import br.com.centralit.citcorpore.integracao.ContatoProblemaDAO;
import br.com.centralit.citcorpore.integracao.ContratoDao;
import br.com.centralit.citcorpore.integracao.GrupoDao;
import br.com.centralit.citcorpore.integracao.OcorrenciaProblemaDAO;
import br.com.centralit.citcorpore.integracao.PermissoesFluxoDao;
import br.com.centralit.citcorpore.integracao.ProblemaDAO;
import br.com.centralit.citcorpore.integracao.ProblemaItemConfiguracaoDAO;
import br.com.centralit.citcorpore.integracao.ProblemaMudancaDAO;
import br.com.centralit.citcorpore.integracao.ProblemaRelacionadoDao;
import br.com.centralit.citcorpore.integracao.ServicoContratoDao;
import br.com.centralit.citcorpore.integracao.SolicitacaoServicoProblemaDao;
import br.com.centralit.citcorpore.integracao.UsuarioDao;
import br.com.centralit.citcorpore.util.CITCorporeUtil;
import br.com.centralit.citcorpore.util.CriptoUtils;
import br.com.centralit.citcorpore.util.Enumerados;
import br.com.centralit.citcorpore.util.Enumerados.CategoriaOcorrencia;
import br.com.centralit.citcorpore.util.Enumerados.OrigemOcorrencia;
import br.com.centralit.citcorpore.util.Enumerados.ParametroSistema;
import br.com.centralit.citcorpore.util.Enumerados.SituacaoRequisicaoProblema;
import br.com.centralit.citcorpore.util.ParametroUtil;
import br.com.centralit.citcorpore.util.Util;
import br.com.centralit.citged.bean.ControleGEDDTO;
import br.com.centralit.citged.integracao.ControleGEDDao;
import br.com.citframework.dto.IDto;
import br.com.citframework.excecao.LogicException;
import br.com.citframework.excecao.PersistenceException;
import br.com.citframework.excecao.ServiceException;
import br.com.citframework.integracao.Condition;
import br.com.citframework.integracao.TransactionControler;
import br.com.citframework.integracao.TransactionControlerImpl;
import br.com.citframework.service.CrudServiceImpl;
import br.com.citframework.service.ServiceLocator;
import br.com.citframework.util.Constantes;
import br.com.citframework.util.UtilDatas;
import br.com.citframework.util.UtilStrings;
import com.google.gson.Gson;
@SuppressWarnings({ "rawtypes", "unchecked" })
public class ProblemaServiceEjb extends CrudServiceImpl implements ProblemaService {
private ProblemaDAO dao;
private ProblemaItemConfiguracaoDAO problemaItemConfiguracaoDao;
private ProblemaMudancaDAO problemaMudancaDao;
private BaseConhecimentoService baseConhecimentoService;
protected ProblemaDAO getDao() {
if (dao == null) {
dao = new ProblemaDAO();
}
return dao;
}
private BaseConhecimentoService getBaseConhecimentoService() throws ServiceException, Exception {
if (baseConhecimentoService == null) {
baseConhecimentoService = (BaseConhecimentoService) ServiceLocator.getInstance().getService(BaseConhecimentoService.class, null);
}
return baseConhecimentoService;
}
private ProblemaItemConfiguracaoDAO getProblemaItemConfiguracaoDao() {
if (problemaItemConfiguracaoDao == null) {
problemaItemConfiguracaoDao = new ProblemaItemConfiguracaoDAO();
}
return problemaItemConfiguracaoDao;
}
private ProblemaMudancaDAO getProblemaMudancaDao() {
if (problemaMudancaDao == null) {
problemaMudancaDao = new ProblemaMudancaDAO();
}
return problemaMudancaDao;
}
protected void validaCreate(Object arg0) throws Exception {
ProblemaDTO dto = (ProblemaDTO) arg0;
dto.setDataHoraInicio(new Timestamp(new java.util.Date().getTime()));
}
public void reativa(UsuarioDTO usuarioDto, ProblemaDTO problemaDto) throws Exception {
TransactionControler tc = new TransactionControlerImpl(getDao().getAliasDB());
try {
tc.start();
reativa(usuarioDto, problemaDto, tc);
tc.commit();
} catch (Exception e) {
this.rollbackTransaction(tc, e);
throw new ServiceException(e);
} finally {
try {
tc.close();
} catch (PersistenceException e) {
e.printStackTrace();
}
}
}
public void reativa(UsuarioDTO usuarioDto, ProblemaDTO problemaDto, TransactionControler tc) throws Exception {
ProblemaDTO problemaAuxDto = restoreAll(problemaDto.getIdProblema(), tc);
new ExecucaoProblemaServiceEjb().reativa(usuarioDto, problemaAuxDto, tc);
}
@Override
public IDto create(IDto model) throws ServiceException, LogicException {
// TODO DTO
ContatoProblemaDTO contatoProblemaDto = new ContatoProblemaDTO();
OcorrenciaProblemaDTO ocorrenciaProblemaDto = new OcorrenciaProblemaDTO();
CategoriaProblemaDTO categoriaProblemaDto = new CategoriaProblemaDTO();
ProblemaRelacionadoDTO problemaRelacionadoDto = null;
ProblemaDTO problema = (ProblemaDTO) model;
// TODO ServiceEjb
ExecucaoProblemaServiceEjb execucaoProblemaServiceEjb = new ExecucaoProblemaServiceEjb();
// TODO DAO
ProblemaDAO problemaDao = this.getDao();
SolicitacaoServicoProblemaDao solicitacaoServicoProblemaDao = new SolicitacaoServicoProblemaDao();
ServicoContratoDao servicoContratoDao = new ServicoContratoDao();
ProblemaItemConfiguracaoDAO problemaItemConfiguracaoDao = new ProblemaItemConfiguracaoDAO();
ProblemaMudancaDAO problemaMudancaDao = new ProblemaMudancaDAO();
OcorrenciaProblemaDAO ocorrenciaProblemaDao = new OcorrenciaProblemaDAO();
CategoriaProblemaDAO categoriaProblemaDao = new CategoriaProblemaDAO();
ProblemaRelacionadoDao problemaRelacionadoDao = new ProblemaRelacionadoDao();
TransactionControler tc = null;
try {
if (problemaDao != null && problemaDao.getTransactionControler() != null) {
tc = problemaDao.getTransactionControler();
} else {
tc = new TransactionControlerImpl(problemaDao.getAliasDB());
}
if (!tc.isStarted()) {
tc.start();
}
validaCreate(model);
problemaDao.setTransactionControler(tc);
solicitacaoServicoProblemaDao.setTransactionControler(tc);
servicoContratoDao.setTransactionControler(tc);
problemaItemConfiguracaoDao.setTransactionControler(tc);
problemaMudancaDao.setTransactionControler(tc);
ocorrenciaProblemaDao.setTransactionControler(tc);
categoriaProblemaDao.setTransactionControler(tc);
problemaRelacionadoDao.setTransactionControler(tc);
contatoProblemaDto = this.criarContatoProblema(problema, tc);
if (contatoProblemaDto.getIdContatoProblema() != null) {
problema.setIdContatoProblema(contatoProblemaDto.getIdContatoProblema());
}
// Bruno.Aquino: comentado o setIdProprietario pois ao criar a solicita��o o usu�rio logado estava ficando como respons�vel do problema criado, fugindo da regra de
// neg�cio.
problema.setDataHoraCaptura(UtilDatas.getDataHoraAtual());
problema.setDataHoraSolicitacao(UtilDatas.getDataHoraAtual());
// problema.setIdProprietario(problema.getUsuarioDto().getIdUsuario());
problema.setStatus(SituacaoRequisicaoProblema.Registrada.name());
if (problema.getDataHoraLimiteSolucionar() != null) {
problema.setDataHoraLimite(transformaHoraFinal(problema.getDataHoraLimiteSolucionar()));
// this.determinaPrazo(problema, problema.getIdCalendario());
} else {
problema.setPrazoHH(00);
problema.setPrazoMM(00);
}
if (problema.getIdCategoriaProblema() != null) {
categoriaProblemaDto.setIdCategoriaProblema(problema.getIdCategoriaProblema());
categoriaProblemaDto = (CategoriaProblemaDTO) categoriaProblemaDao.restore(categoriaProblemaDto);
}
if (problema.getIdGrupo() == null) {
if (categoriaProblemaDto != null) {
if (categoriaProblemaDto.getIdGrupoExecutor() != null) {
// problema.setIdGrupoNivel1(categoriaProblemaDto.getIdGrupoExecutor()); N�o existe GrupoNivel1 e GrupoAtual na entidade Problema. Verificar DAO da entidade. valdoilo.damasceno
problema.setIdGrupo(categoriaProblemaDto.getIdGrupoExecutor());
} else {
if (problema.getIdGrupoNivel1() == null || problema.getIdGrupoNivel1().intValue() <= 0) {
Integer idGrupoNivel1 = null;
String idGrupoN1 = ParametroUtil.getValor(ParametroSistema.ID_GRUPO_PADRAO_NIVEL1, tc, null);
if (idGrupoN1 != null && !idGrupoN1.trim().equalsIgnoreCase("")) {
try {
idGrupoNivel1 = new Integer(idGrupoN1);
} catch (Exception e) {
e.printStackTrace();
}
}
if (idGrupoNivel1 == null || idGrupoNivel1.intValue() <= 0)
throw new LogicException(i18nMessage("solicitacaoservico.validacao.servicolocalizado"));
problema.setIdGrupoNivel1(idGrupoNivel1);
problema.setIdGrupo(idGrupoNivel1);
}
}
}
}
// N�o existe GrupoNivel1 e GrupoAtual na entidade Problema. Verificar DAO da entidade. valdoilo.damasceno
// else {
// problema.setIdGrupoNivel1(problema.getIdGrupo());
// problema.setIdGrupo(problema.getIdGrupo());
// problema.setIdGrupoAtual(problema.getIdGrupo());
// }
if (!problema.getTitulo().equalsIgnoreCase("Problema Criado por Rotina autom�tica")) {
boolean resultado = validacaoGrupoExecutor(problema);
if (resultado == false) {
throw new LogicException(i18nMessage("Problema.grupoSemPermissao"));
}
} else {
problema.setRegistroexecucao("Problema Criado por Rotina autom�tica");
}
problemaRelacionadoDao.deleteByIdProblema(problema.getIdProblema());
if (problema.getListProblemaRelacionadoDTO() != null && problema.getListProblemaRelacionadoDTO().size() > 0) {
for (ProblemaDTO beanProblema : problema.getListProblemaRelacionadoDTO()) {
problemaRelacionadoDto = new ProblemaRelacionadoDTO();
problemaRelacionadoDto.setIdProblema(problema.getIdProblema());
problemaRelacionadoDto.setIdProblemaRelacionado(beanProblema.getIdProblema());
problemaRelacionadoDao.create(problemaRelacionadoDto);
}
}
problema = (ProblemaDTO) problemaDao.create(problema);
if (problema != null && problema.getInformacoesComplementares() != null) {
TemplateSolicitacaoServicoDTO templateDto = new TemplateSolicitacaoServicoServiceEjb().recuperaTemplateProblema(problema);
if (templateDto != null && templateDto.getNomeClasseServico() != null) {
ComplemInfProblemaServicoService complemInfProblemaServicoService = (ComplemInfProblemaServicoService) this.getInformacoesComplementaresService(templateDto.getNomeClasseServico());
complemInfProblemaServicoService.create(tc, problema, problema.getInformacoesComplementares());
}
}
if (problema != null) {
this.criarOcorrenciaProblema(problema, tc);
}
Source source = null;
if (problema != null) {
source = new Source(problema.getRegistroexecucao());
}
if (source != null) {
problema.setRegistroexecucao(source.getTextExtractor().toString());
}
if (problema != null && problema.getRegistroexecucao() != null && !problema.getRegistroexecucao().trim().equalsIgnoreCase("")) {
ocorrenciaProblemaDto.setIdProblema(problema.getIdProblema());
ocorrenciaProblemaDto.setDataregistro(UtilDatas.getDataAtual());
ocorrenciaProblemaDto.setHoraregistro(UtilDatas.formatHoraFormatadaStr(UtilDatas.getHoraAtual()));
ocorrenciaProblemaDto.setTempoGasto(0);
ocorrenciaProblemaDto.setDescricao(br.com.centralit.citcorpore.util.Enumerados.CategoriaOcorrencia.Execucao.getDescricao());
ocorrenciaProblemaDto.setDataInicio(UtilDatas.getDataAtual());
ocorrenciaProblemaDto.setDataFim(UtilDatas.getDataAtual());
ocorrenciaProblemaDto.setInformacoesContato("n�o se aplica");
ocorrenciaProblemaDto.setRegistradopor(problema.getUsuarioDto().getLogin());
try {
ocorrenciaProblemaDto.setDadosProblema(new Gson().toJson(problema));
} catch (Exception e) {
e.printStackTrace();
}
ocorrenciaProblemaDto.setOrigem(br.com.centralit.citcorpore.util.Enumerados.OrigemOcorrencia.OUTROS.getSigla().toString());
ocorrenciaProblemaDto.setCategoria(br.com.centralit.citcorpore.util.Enumerados.CategoriaOcorrencia.Criacao.getSigla());
ocorrenciaProblemaDto.setOcorrencia(problema.getRegistroexecucao());
ocorrenciaProblemaDao.create(ocorrenciaProblemaDto);
}
if (problema != null) {
if (problema.getListIdSolicitacaoServico() != null && problema.getListIdSolicitacaoServico().size() > 0) {
solicitacaoServicoProblemaDao.deleteByIdProblema(problema.getIdProblema());
for (SolicitacaoServicoDTO solicitacaoServicoDTO : problema.getListIdSolicitacaoServico()) {
SolicitacaoServicoProblemaDTO solicitacaoServicoProblemaDTO = new SolicitacaoServicoProblemaDTO();
solicitacaoServicoProblemaDTO.setIdProblema(problema.getIdProblema());
solicitacaoServicoProblemaDTO.setIdSolicitacaoServico(solicitacaoServicoDTO.getIdSolicitacaoServico());
solicitacaoServicoProblemaDao.create(solicitacaoServicoProblemaDTO);
}
}
if (problema.getListProblemaItemConfiguracaoDTO() != null) {
problemaItemConfiguracaoDao.deleteByIdProblemaItemConfiguracao(problema.getIdProblema());
for (ProblemaItemConfiguracaoDTO ic : problema.getListProblemaItemConfiguracaoDTO()) {
ic.setIdProblema(problema.getIdProblema());
problemaItemConfiguracaoDao.create(ic);
}
}
if (problema.getListProblemaMudancaDTO() != null) {
problemaMudancaDao.deleteByIdProblemaMudanca(problema.getIdProblema());
for (ProblemaMudancaDTO problemaRequisicao : problema.getListProblemaMudancaDTO()) {
problemaRequisicao.setIdProblema(problema.getIdProblema());
problemaMudancaDao.create(problemaRequisicao);
}
}
}
/**
* Adicionado gravar anexo
*
* @author mario.junior
* @since 31/10/2013 08:21
*/
if (problema != null && problema.getColArquivosUpload() != null && problema.getColArquivosUpload().size() > 0) {
gravaInformacoesGED(problema.getColArquivosUpload(), 1, problema, tc);
}
execucaoProblemaServiceEjb.registraProblema(problema, tc);
tc.commit();
tc.close();
} catch (Exception e) {
this.rollbackTransaction(tc, e);
e.printStackTrace();
}
return model;
}
private void criarOcorrenciaProblema(ProblemaDTO problema, TransactionControler tc) throws Exception {
OcorrenciaProblemaDAO ocorrenciaProblemaDao = new OcorrenciaProblemaDAO();
ocorrenciaProblemaDao.setTransactionControler(tc);
OcorrenciaProblemaDTO ocorrenciaProblemaDto = new OcorrenciaProblemaDTO();
ocorrenciaProblemaDto.setIdProblema(problema.getIdProblema());
ocorrenciaProblemaDto.setDataregistro(UtilDatas.getDataAtual());
ocorrenciaProblemaDto.setHoraregistro(UtilDatas.formatHoraFormatadaStr(UtilDatas.getHoraAtual()));
ocorrenciaProblemaDto.setTempoGasto(0);
ocorrenciaProblemaDto.setDescricao(br.com.centralit.citcorpore.util.Enumerados.CategoriaOcorrencia.Execucao.getDescricao());
ocorrenciaProblemaDto.setDataInicio(UtilDatas.getDataAtual());
ocorrenciaProblemaDto.setDataFim(UtilDatas.getDataAtual());
ocorrenciaProblemaDto.setInformacoesContato("n�o se aplica");
ocorrenciaProblemaDto.setRegistradopor(problema.getUsuarioDto().getLogin());
try {
ocorrenciaProblemaDto.setDadosProblema(new Gson().toJson(problema));
} catch (Exception e) {
e.printStackTrace();
}
ocorrenciaProblemaDto.setOrigem(br.com.centralit.citcorpore.util.Enumerados.OrigemOcorrencia.OUTROS.getSigla().toString());
ocorrenciaProblemaDto.setCategoria(br.com.centralit.citcorpore.util.Enumerados.CategoriaOcorrencia.Criacao.getSigla());
ocorrenciaProblemaDao.create(ocorrenciaProblemaDto);
}
@Override
public void update(IDto model) throws ServiceException, LogicException {
// TODO DTO
ContatoProblemaDTO contatoProblemaDto = new ContatoProblemaDTO();
OcorrenciaProblemaDTO ocorrenciaProblemaDto = new OcorrenciaProblemaDTO();
ProblemaRelacionadoDTO problemaRelacionadoDto = null;
ProblemaDTO problema = (ProblemaDTO) model;
// TODO ServiceEjb
ExecucaoProblemaServiceEjb execucaoProblemaServiceEjb = new ExecucaoProblemaServiceEjb();
// TODO DAO
ProblemaDAO problemaDao = this.getDao();
SolicitacaoServicoProblemaDao solicitacaoServicoProblemaDao = new SolicitacaoServicoProblemaDao();
ServicoContratoDao servicoContratoDao = new ServicoContratoDao();
ProblemaItemConfiguracaoDAO problemaItemConfiguracaoDao = new ProblemaItemConfiguracaoDAO();
ProblemaMudancaDAO problemaMudancaDao = new ProblemaMudancaDAO();
OcorrenciaProblemaDAO ocorrenciaProblemaDao = new OcorrenciaProblemaDAO();
ProblemaRelacionadoDao problemaRelacionadoDao = new ProblemaRelacionadoDao();
try {
problema.setDataHoraInicio(getProblemaAtual(problema.getIdProblema()).getDataHoraInicio());
problema.setDataHoraCaptura(getProblemaAtual(problema.getIdProblema()).getDataHoraCaptura());
} catch (Exception e1) {
e1.printStackTrace();
}
TransactionControler tc = new TransactionControlerImpl(problemaDao.getAliasDB());
try {
tc.start();
problemaDao.setTransactionControler(tc);
solicitacaoServicoProblemaDao.setTransactionControler(tc);
servicoContratoDao.setTransactionControler(tc);
problemaItemConfiguracaoDao.setTransactionControler(tc);
problemaMudancaDao.setTransactionControler(tc);
ocorrenciaProblemaDao.setTransactionControler(tc);
problemaRelacionadoDao.setTransactionControler(tc);
if (problema != null && problema.getStatus().equalsIgnoreCase(SituacaoRequisicaoProblema.Cancelada.getDescricao())) {
if (problema.getFechamento() == null || problema.getFechamento().equalsIgnoreCase("")) {
throw new LogicException(i18nMessage("citcorpore.comum.informeFechamento"));
}
}
if (problema != null && problema.getAcaoFluxo().equalsIgnoreCase("E")) {
if (problema.getStatus() != null && problema.getStatus().equalsIgnoreCase(SituacaoRequisicaoProblema.EmInvestigacao.getDescricao())) {
if (problema.getCausaRaiz() != null) {
if (problema.getCausaRaiz().equalsIgnoreCase("")) {
throw new LogicException(i18nMessage("problema.campoObrigatorioCausaRaiz"));
}
}
if (problema.getSolucaoContorno() != null) {
if (problema.getSolucaoContorno().equalsIgnoreCase("")) {
throw new LogicException(i18nMessage("problema.campoObrigatorioSolucaoContorno"));
}
}
}
if (problema.getStatus() != null && problema.getStatus().equalsIgnoreCase(SituacaoRequisicaoProblema.Resolucao.getDescricao())) {
if (problema.getFechamento() == null || problema.getFechamento().equalsIgnoreCase("")) {
throw new LogicException(i18nMessage("citcorpore.comum.informeFechamento"));
}
}
}
if (problema != null && !problema.getStatus().equalsIgnoreCase(SituacaoRequisicaoProblema.Cancelada.getDescricao())) {
if (problema.getAlterarSituacao().equalsIgnoreCase("N")) {
problema.setStatus(getStatusAtual(problema.getIdProblema()));
}
}
if (problema != null) {
problema.setIdProprietario(problema.getUsuarioDto().getIdUsuario());
}
if (problema != null && problema.getDataHoraLimiteSolucionar() != null) {
problema.setDataHoraLimite(transformaHoraFinal(problema.getDataHoraLimiteSolucionar()));
// this.determinaPrazo(problema, problema.getIdCalendario());
} else {
if (problema != null) {
problema.setPrazoHH(00);
problema.setPrazoMM(00);
}
}
contatoProblemaDto = this.criarContatoProblema(problema, tc);
if (contatoProblemaDto.getIdContatoProblema() != null) {
problema.setIdContatoProblema(contatoProblemaDto.getIdContatoProblema());
}
problemaDao.update(problema);
this.updateConteudoBaseConhecimento(problema, tc);
if (problema != null) {
if (problema.getListIdSolicitacaoServico() != null && problema.getListIdSolicitacaoServico().size() > 0) {
solicitacaoServicoProblemaDao.deleteByIdProblema(problema.getIdProblema());
for (SolicitacaoServicoDTO solicitacaoServicoDTO : problema.getListIdSolicitacaoServico()) {
SolicitacaoServicoProblemaDTO solicitacaoServicoProblemaDTO = new SolicitacaoServicoProblemaDTO();
solicitacaoServicoProblemaDTO.setIdProblema(problema.getIdProblema());
solicitacaoServicoProblemaDTO.setIdSolicitacaoServico(solicitacaoServicoDTO.getIdSolicitacaoServico());
solicitacaoServicoProblemaDao.create(solicitacaoServicoProblemaDTO);
}
} else {
SolicitacaoServicoProblemaDTO solicitacaoServicoProblemaDTO = new SolicitacaoServicoProblemaDTO();
SolicitacaoServicoProblemaService solicitacaoServicoProblemaService = (SolicitacaoServicoProblemaService) ServiceLocator.getInstance().getService(
SolicitacaoServicoProblemaService.class, null);
solicitacaoServicoProblemaDTO = solicitacaoServicoProblemaService.restoreByIdProblema(problema.getIdProblema());
if (solicitacaoServicoProblemaDTO != null && solicitacaoServicoProblemaDTO.getIdProblema() != null && solicitacaoServicoProblemaDTO.getIdProblema().intValue() > 0) {
solicitacaoServicoProblemaDao.deleteByIdProblema(solicitacaoServicoProblemaDTO.getIdProblema());
}
}
if (problema.getListProblemaItemConfiguracaoDTO() != null && problema.getListProblemaItemConfiguracaoDTO().size() > 0) {
problemaItemConfiguracaoDao.deleteByIdProblema(problema.getIdProblema());
for (ProblemaItemConfiguracaoDTO ic : problema.getListProblemaItemConfiguracaoDTO()) {
ic.setIdProblema(problema.getIdProblema());
problemaItemConfiguracaoDao.create(ic);
}
} else {
ProblemaItemConfiguracaoDTO problemaItemConfiguracaoRestoreDTO = new ProblemaItemConfiguracaoDTO();
ProblemaItemConfiguracaoService problemaItemConfiguracaoService = (ProblemaItemConfiguracaoService) ServiceLocator.getInstance().getService(ProblemaItemConfiguracaoService.class,
null);
problemaItemConfiguracaoRestoreDTO = (ProblemaItemConfiguracaoDTO) problemaItemConfiguracaoService.restoreByIdProblema(problema.getIdProblema());
if (problemaItemConfiguracaoRestoreDTO != null && problemaItemConfiguracaoRestoreDTO.getIdProblema() != null && problemaItemConfiguracaoRestoreDTO.getIdProblema().intValue() > 0) {
problemaItemConfiguracaoDao.deleteByIdProblema(problemaItemConfiguracaoRestoreDTO.getIdProblema());
}
}
if (problema.getListProblemaMudancaDTO() != null) {
problemaMudancaDao.deleteByIdProblema(problema.getIdProblema());
for (ProblemaMudancaDTO problemaRequisicao : problema.getListProblemaMudancaDTO()) {
problemaRequisicao.setIdProblema(problema.getIdProblema());
problemaMudancaDao.create(problemaRequisicao);
}
} else {
ProblemaMudancaDTO problemaMudancaRestoreDTO = new ProblemaMudancaDTO();
ProblemaMudancaService problemaMudancaService = (ProblemaMudancaService) ServiceLocator.getInstance().getService(ProblemaMudancaService.class, null);
problemaMudancaRestoreDTO = problemaMudancaService.restoreByIdProblema(problema.getIdProblema());
if (problemaMudancaRestoreDTO != null && problemaMudancaRestoreDTO.getIdProblema() != null && problemaMudancaRestoreDTO.getIdProblema().intValue() > 0) {
problemaMudancaDao.deleteByIdProblema(problemaMudancaRestoreDTO.getIdProblema());
}
}
problemaRelacionadoDao.deleteByIdProblema(problema.getIdProblema());
if (problema.getListProblemaRelacionadoDTO() != null && problema.getListProblemaRelacionadoDTO().size() > 0) {
for (ProblemaDTO beanProblema : problema.getListProblemaRelacionadoDTO()) {
problemaRelacionadoDto = new ProblemaRelacionadoDTO();
problemaRelacionadoDto.setIdProblema(problema.getIdProblema());
problemaRelacionadoDto.setIdProblemaRelacionado(beanProblema.getIdProblema());
problemaRelacionadoDao.create(problemaRelacionadoDto);
}
}
}
if (problema != null && problema.getPrecisaMudanca() != null && problema.getPrecisaMudanca().equalsIgnoreCase("N")) {
problemaMudancaDao.deleteByIdProblema(problema.getIdProblema());
}
if (problema != null && problema.getIdTarefa() == null) {
problemaDao.update(problema);
} else {
if (problema.getStatus().equalsIgnoreCase(SituacaoRequisicaoProblema.Cancelada.getDescricao())) {
execucaoProblemaServiceEjb.encerra(problema.getUsuarioDto(), problema, tc);
} else {
execucaoProblemaServiceEjb.executa(problema, problema.getIdTarefa(), problema.getAcaoFluxo(), tc);
}
}
if (problema.getInformacoesComplementares() != null) {
TemplateSolicitacaoServicoDTO templateDto = new TemplateSolicitacaoServicoServiceEjb().recuperaTemplateProblema(problema, tc);
if (templateDto != null && templateDto.getNomeClasseServico() != null) {
ComplemInfProblemaServicoService complemInfProblemaServicoService = (ComplemInfProblemaServicoService) this.getInformacoesComplementaresService(templateDto.getNomeClasseServico());
complemInfProblemaServicoService.update(tc, problema, problema.getInformacoesComplementares());
}
}
Source source = new Source(problema.getRegistroexecucao());
problema.setRegistroexecucao(source.getTextExtractor().toString());
if (problema.getRegistroexecucao() != null && !problema.getRegistroexecucao().trim().equalsIgnoreCase("")) {
ocorrenciaProblemaDto.setIdProblema(problema.getIdProblema());
ocorrenciaProblemaDto.setDataregistro(UtilDatas.getDataAtual());
ocorrenciaProblemaDto.setHoraregistro(UtilDatas.formatHoraFormatadaStr(UtilDatas.getHoraAtual()));
ocorrenciaProblemaDto.setTempoGasto(0);
ocorrenciaProblemaDto.setDescricao(br.com.centralit.citcorpore.util.Enumerados.CategoriaOcorrencia.Execucao.getDescricao());
ocorrenciaProblemaDto.setDataInicio(UtilDatas.getDataAtual());
ocorrenciaProblemaDto.setDataFim(UtilDatas.getDataAtual());
ocorrenciaProblemaDto.setInformacoesContato("n�o se aplica");
ocorrenciaProblemaDto.setRegistradopor(problema.getUsuarioDto().getLogin());
try {
ocorrenciaProblemaDto.setDadosProblema(new Gson().toJson(problema));
} catch (Exception e) {
e.printStackTrace();
}
ocorrenciaProblemaDto.setOrigem(br.com.centralit.citcorpore.util.Enumerados.OrigemOcorrencia.OUTROS.getSigla().toString());
ocorrenciaProblemaDto.setCategoria(br.com.centralit.citcorpore.util.Enumerados.CategoriaOcorrencia.Criacao.getSigla());
ocorrenciaProblemaDto.setOcorrencia(problema.getRegistroexecucao());
ocorrenciaProblemaDao.create(ocorrenciaProblemaDto);
}
if (problema.getAcaoFluxo().equalsIgnoreCase("E")) {
if (problema.getStatus() != null
&& (problema.getStatus().equalsIgnoreCase(SituacaoRequisicaoProblema.Resolucao.getDescricao()) || problema.getStatus().equalsIgnoreCase(
SituacaoRequisicaoProblema.Concluida.getDescricao()))) {
fechaRelacionamentoProblema(problema, tc);
}
}
/**
* Adicionado para gravar anexo
*
* @author mario.junior
* @since 31/10/2013 08:21
*/
if (problema.getColArquivosUpload() != null && problema.getColArquivosUpload().size() > 0) {
gravaInformacoesGED(problema.getColArquivosUpload(), 1, problema, tc);
}
tc.commit();
tc.close();
} catch (Exception e) {
this.rollbackTransaction(tc, e);
e.printStackTrace();
}
}
@Override
public void create(ProblemaDTO problemaDto, TransactionControler tc) throws Exception {
this.getDao().setTransactionControler(tc);
this.create(problemaDto);
}
// Falta arrumar o Create
// David
public void createAll(ProblemaDTO problema, ArrayList<ProblemaItemConfiguracaoDTO> ics, ArrayList<ProblemaMudancaDTO> rdm, UsuarioDTO usuarioDto) throws ServiceException, LogicException {
BaseConhecimentoDTO baseAux = null;
ProblemaDTO problemabean = new ProblemaDTO();
SolicitacaoServicoProblemaDao solicitacaoServicoProblemaDao = new SolicitacaoServicoProblemaDao();
TransactionControler tc = new TransactionControlerImpl(getDao().getAliasDB());
ContatoProblemaDTO contatoProblemaDto = new ContatoProblemaDTO();
ExecucaoProblemaServiceEjb execucaoProblemaServiceEjb = new ExecucaoProblemaServiceEjb();
if (problema != null) {
problema.setDataHoraCaptura(UtilDatas.getDataHoraAtual());
problema.setDataHoraSolicitacao(UtilDatas.getDataHoraAtual());
problema.setIdProprietario(usuarioDto.getIdUsuario());
}
try {
this.getDao().setTransactionControler(tc);
this.getProblemaItemConfiguracaoDao().setTransactionControler(tc);
solicitacaoServicoProblemaDao.setTransactionControler(tc);
tc.start();
contatoProblemaDto = criarContatoProblema(problema, tc);
if (problema != null) {
problema.setIdContatoProblema(contatoProblemaDto.getIdContatoProblema());
}
problemabean = problema;
if ((problema != null) && (problema.getIdGrupoNivel1() == null || problema.getIdGrupoNivel1().intValue() <= 0)) {
Integer idGrupoNivel1 = null;
String idGrupoN1 = ParametroUtil.getValor(ParametroSistema.ID_GRUPO_PADRAO_NIVEL1, tc, null);
if (idGrupoN1 != null && !idGrupoN1.trim().equalsIgnoreCase("")) {
try {
idGrupoNivel1 = new Integer(idGrupoN1);
} catch (Exception e) {
e.printStackTrace();
}
}
if (idGrupoNivel1 == null || idGrupoNivel1.intValue() <= 0)
throw new LogicException(i18nMessage("solicitacaoservico.validacao.servicolocalizado"));
problema.setIdGrupoNivel1(idGrupoNivel1);
problema.setIdGrupo(idGrupoNivel1);
}
problema = (ProblemaDTO) this.getDao().create(problema);
if (problemabean != null) {
if (problemabean.getListIdSolicitacaoServico() != null && problemabean.getListIdSolicitacaoServico().size() > 0) {
solicitacaoServicoProblemaDao.deleteByIdProblema(problema.getIdProblema());
for (SolicitacaoServicoDTO solicitacaoServicoDTO : problemabean.getListIdSolicitacaoServico()) {
SolicitacaoServicoProblemaDTO solicitacaoServicoProblemaDTO = new SolicitacaoServicoProblemaDTO();
solicitacaoServicoProblemaDTO.setIdProblema(problema.getIdProblema());
solicitacaoServicoProblemaDTO.setIdSolicitacaoServico(solicitacaoServicoDTO.getIdSolicitacaoServico());
solicitacaoServicoProblemaDao.create(solicitacaoServicoProblemaDTO);
}
}
}
if (ics != null) {
for (ProblemaItemConfiguracaoDTO ic : ics) {
ic.setIdProblema(problema.getIdProblema());
getProblemaItemConfiguracaoDao().create(ic);
}
}
if (rdm != null) {
for (ProblemaMudancaDTO problemaRequisicao : rdm) {
problemaRequisicao.setIdProblema(problema.getIdProblema());
getProblemaMudancaDao().create(problemaRequisicao);
}
}
// ///////////////// ID EMPRESA SETADO MANUALMENTE POR N�O HAVER AINDA TRATAMENTO DE MULTIPLAS EMPRESAS /////////////////////////////////
// //////////////// APROVA BASE SETADO TRUE MANUALMENTE POIS QUEM REGISTRA PROBLEMA DEVE TE-LA INDUBITAVELMENTE /////////////////////
if (problema.getAdicionarBDCE() != null && problema.getAdicionarBDCE().trim().equalsIgnoreCase("S")) {
baseAux = getBaseConhecimentoService().create(getBeanErroConhecidoBaseConhecimento(problema), null, 1, usuarioDto);
problema.setIdBaseConhecimento(baseAux.getIdBaseConhecimento());
getDao().update(problema);
}
execucaoProblemaServiceEjb.registraProblema(problema, tc);
tc.commit();
tc.close();
} catch (Exception e) {
this.rollbackTransaction(tc, e);
e.printStackTrace();
}
}
public ProblemaDTO restoreAll(Integer idProblema) throws Exception {
return restoreAll(idProblema, null);
}
public ProblemaDTO restoreAll(Integer idProblema, TransactionControler tc) throws Exception {
if (tc != null)
getDao().setTransactionControler(tc);
ProblemaDTO problemaDto = new ProblemaDTO();
problemaDto.setIdProblema(idProblema);
problemaDto = (ProblemaDTO) getDao().restore(problemaDto);
try {
} catch (Exception e) {
throw new Exception(i18nMessage("solicitacaoservico.erro.recuperardadosolicitacao") + " " + idProblema);
}
if (problemaDto != null) {
// Isso eh necessario!!!
if (problemaDto.getDataHoraLimite() != null) {
problemaDto.setDataHoraLimiteStr(problemaDto.getDataHoraLimiteStr());
}
problemaDto.setIdGrupoAtual(problemaDto.getIdGrupo());
problemaDto.setIdGrupoNivel1(problemaDto.getIdGrupo());
problemaDto.setNomeServico(problemaDto.getServico());
if (problemaDto.getNomeUnidadeSolicitante() != null && !problemaDto.getNomeUnidadeSolicitante().trim().equalsIgnoreCase(""))
problemaDto.setSolicitanteUnidade(problemaDto.getSolicitante() + " (" + problemaDto.getNomeUnidadeSolicitante() + ")");
if (problemaDto.getNomeUnidadeResponsavel() != null && !problemaDto.getNomeUnidadeResponsavel().trim().equalsIgnoreCase(""))
problemaDto.setResponsavel(problemaDto.getResponsavel() + " (" + problemaDto.getNomeUnidadeResponsavel() + ")");
if (problemaDto.getIdSolicitante() != null) {
UsuarioDTO usuarioDto = new UsuarioDTO();
UsuarioDao usuarioDao = new UsuarioDao();
usuarioDto.setIdEmpregado(problemaDto.getIdSolicitante());
usuarioDto = (UsuarioDTO) usuarioDao.restoreByIdEmpregado(usuarioDto.getIdEmpregado());
if (usuarioDto != null) {
problemaDto.setSolicitante(usuarioDto.getNomeUsuario());
}
}
if (problemaDto.getIdProprietario() != null) {
UsuarioDTO usuarioDto = new UsuarioDTO();
UsuarioDao usuarioDao = new UsuarioDao();
usuarioDto.setIdUsuario(problemaDto.getIdProprietario());
usuarioDto = (UsuarioDTO) usuarioDao.restore(usuarioDto);
if (usuarioDto != null) {
problemaDto.setResponsavel(usuarioDto.getLogin());
}
}
if (problemaDto.getIdGrupo() != null) {
GrupoDao grupoDao = new GrupoDao();
GrupoDTO grupoDto = new GrupoDTO();
grupoDto.setIdGrupo(problemaDto.getIdGrupo());
grupoDto = (GrupoDTO) grupoDao.restore(grupoDto);
if (grupoDto != null)
problemaDto.setNomeGrupoAtual(grupoDto.getSigla());
}
if (problemaDto.getIdContrato() != null) {
ContratoDTO contratoDto = new ContratoDTO();
ContratoDao contratoDao = new ContratoDao();
contratoDto.setIdContrato(problemaDto.getIdContrato());
contratoDto = (ContratoDTO) contratoDao.restore(contratoDto);
if (contratoDto != null)
problemaDto.setContrato(contratoDto.getNumero());
}
if (problemaDto.getIdContatoProblema() != null) {
ContatoProblemaDTO contatoProblemaDto = new ContatoProblemaDTO();
ContatoProblemaDAO contatoProblemaDao = new ContatoProblemaDAO();
if (CITCorporeUtil.SGBD_PRINCIPAL.equalsIgnoreCase("SQLSERVER"))
if (tc != null)
contatoProblemaDao.setTransactionControler(tc);
contatoProblemaDto.setIdContatoProblema(problemaDto.getIdContatoProblema());
contatoProblemaDto = (ContatoProblemaDTO) contatoProblemaDao.restore(contatoProblemaDto);
if (contatoProblemaDto != null) {
problemaDto.setNomeContato(contatoProblemaDto.getNomecontato());
problemaDto.setEmailContato(contatoProblemaDto.getEmailcontato());
problemaDto.setTelefoneContato(contatoProblemaDto.getTelefonecontato());
problemaDto.setRamal(contatoProblemaDto.getRamal());
problemaDto.setObservacao(contatoProblemaDto.getObservacao());
problemaDto.setIdLocalidade(contatoProblemaDto.getIdLocalidade());
}
}
}
return verificaSituacaoSLA(problemaDto, tc);
}
public ProblemaDTO verificaSituacaoSLA(ProblemaDTO problemaDto, TransactionControler tc) throws Exception {
long atrasoSLA = 0;
if (problemaDto == null) {
return problemaDto;
}
if (problemaDto.getDataHoraLimite() == null)
determinaPrazoLimite(problemaDto, null, tc);
if (problemaDto.getDataHoraLimite() != null) {
Timestamp dataHoraLimite = problemaDto.getDataHoraLimite();
Timestamp dataHoraComparacao = UtilDatas.getDataHoraAtual();
if (problemaDto.encerrada())
dataHoraComparacao = problemaDto.getDataHoraFim();
if (dataHoraComparacao != null) {
if (dataHoraComparacao.compareTo(dataHoraLimite) > 0) {
atrasoSLA = UtilDatas.calculaDiferencaTempoEmMilisegundos(dataHoraComparacao, dataHoraLimite) / 1000;
}
}
}
problemaDto.setAtrasoSLA(atrasoSLA);
return problemaDto;
}
public void determinaPrazoLimite(ProblemaDTO problemaDto, Integer idCalendarioParm, TransactionControler tc) throws Exception {
new ExecucaoProblemaServiceEjb().determinaPrazoLimite(problemaDto, idCalendarioParm, tc);
}
public void updateAll(ProblemaDTO problema, ArrayList<ProblemaItemConfiguracaoDTO> ics, ArrayList<ProblemaMudancaDTO> rdm, UsuarioDTO usuarioDto) throws ServiceException, LogicException {
BaseConhecimentoDTO baseAux = null;
ProblemaDTO problemabean = new ProblemaDTO();
SolicitacaoServicoProblemaDao solicitacaoServicoProblemaDao = new SolicitacaoServicoProblemaDao();
TransactionControler tc = new TransactionControlerImpl(getDao().getAliasDB());
SolicitacaoServicoServiceEjb solicitacaoServicoServiceEjb = new SolicitacaoServicoServiceEjb();
ServicoContratoDao servicoContratoDao = new ServicoContratoDao();
SolicitacaoServicoDTO solicitacaoServicoDto = new SolicitacaoServicoDTO();
if (problema != null) {
solicitacaoServicoDto.setIdSolicitante(problema.getIdSolicitacaoServico());
}
solicitacaoServicoDto.setUsuarioDto(usuarioDto);
if (problema != null) {
solicitacaoServicoDto.setIdContrato(problema.getIdContrato());
solicitacaoServicoDto.setIdServico(problema.getIdServico());
}
try {
tc.start();
ProblemaDTO problemaAux = (ProblemaDTO) getDao().restore(problema);
if (problemaAux == null) {
problemaAux = new ProblemaDTO();
}
if (problema != null && solicitacaoServicoDto != null && usuarioDto != null) {
ServicoContratoDTO servicoContratoDTO = servicoContratoDao.findByIdContratoAndIdServico(problema.getIdContrato(), problema.getIdServico());
solicitacaoServicoDto.setIdServicoContrato(servicoContratoDTO.getIdServicoContrato());
solicitacaoServicoDto.setDataHoraSolicitacao(problemaAux.getDataHoraSolicitacao());
problema.setIdServicoContrato(servicoContratoDTO.getIdServicoContrato());
solicitacaoServicoDto.setUrgencia(problema.getUrgencia().substring(0, 1));
solicitacaoServicoDto.setImpacto(problema.getImpacto().substring(0, 1));
if (solicitacaoServicoDto.getDataHoraSolicitacao() == null) {
solicitacaoServicoDto.setDataHoraSolicitacao(UtilDatas.getDataHoraAtual());
}
solicitacaoServicoServiceEjb.determinaPrioridadeEPrazo(solicitacaoServicoDto, tc);
problema.setIdPrioridade(solicitacaoServicoDto.getIdPrioridade());
problema.setPrazoHH(solicitacaoServicoDto.getPrazoHH());
problema.setPrazoMM(solicitacaoServicoDto.getPrazoMM());
problema.setSlaACombinar(solicitacaoServicoDto.getSlaACombinar());
problema.setDataHoraLimite(solicitacaoServicoDto.getDataHoraLimite());
problema.setIdProprietario(usuarioDto.getIdUsuario());
}
} catch (Exception e1) {
e1.printStackTrace();
throw new LogicException(e1);
}
try {
getDao().setTransactionControler(tc);
getProblemaItemConfiguracaoDao().setTransactionControler(tc);
getProblemaMudancaDao().setTransactionControler(tc);
solicitacaoServicoProblemaDao.setTransactionControler(tc);
tc.start();
problemabean = problema;
getDao().update(problema);
if (problemabean != null) {
if (problemabean.getListIdSolicitacaoServico() != null && problemabean.getListIdSolicitacaoServico().size() > 0) {
solicitacaoServicoProblemaDao.deleteByIdProblema(problema.getIdProblema());
for (SolicitacaoServicoDTO solicitacaoServicoDTO : problemabean.getListIdSolicitacaoServico()) {
SolicitacaoServicoProblemaDTO solicitacaoServicoProblemaDTO = new SolicitacaoServicoProblemaDTO();
solicitacaoServicoProblemaDTO.setIdProblema(problema.getIdProblema());
solicitacaoServicoProblemaDTO.setIdSolicitacaoServico(solicitacaoServicoDTO.getIdSolicitacaoServico());
solicitacaoServicoProblemaDao.create(solicitacaoServicoProblemaDTO);
}
}
}
if (ics != null) {
ProblemaItemConfiguracaoDTO aux = null;
for (ProblemaItemConfiguracaoDTO ic : ics) {
aux = (ProblemaItemConfiguracaoDTO) getProblemaItemConfiguracaoDao().findByIdItemConfiguracaoEIdProblema(ic.getIdItemConfiguracao(), problema.getIdProblema());
if (aux == null) {
ic.setIdProblema(problema.getIdProblema());
getProblemaItemConfiguracaoDao().create(ic);
} else {
ic.setIdProblemaItemConfiguracao(aux.getIdProblemaItemConfiguracao());
ic.setIdProblema(problema.getIdProblema());
getProblemaItemConfiguracaoDao().update(ic);
}
}
}
if (problema != null && problema.getListProblemaMudancaDTO() != null) {
problemaMudancaDao.deleteByIdProblema(problema.getIdProblema());
for (ProblemaMudancaDTO dto : problema.getListProblemaMudancaDTO()) {
dto.setIdProblema(problema.getIdProblema());
problemaMudancaDao.create(dto);
}
}
if (problema != null) {
getProblemaItemConfiguracaoDao().deletaOsQueNaoEstaoNaListaByIdProblema(problema.getIdProblema(), ics);
}
// getProblemaMudancaDao().deleteByIdProblema(problema.getIdProblema());
if (problema != null && problema.getAdicionarBDCE() != null && problema.getAdicionarBDCE().trim().equalsIgnoreCase("S")) {
if (problema.getIdBaseConhecimento() != null) {
baseAux = getBeanErroConhecidoBaseConhecimento(problema);
baseAux.setIdBaseConhecimento(problema.getIdBaseConhecimento());
// ///////////////// ID EMPRESA SETADO MANUALMENTE POR N�O HAVER AINDA TRATAMENTO DE MULTIPLAS EMPRESAS /////////////////////////////////
// //////////////// APROVA BASE SETADO TRUE MANUALMENTE POIS QUEM REGISTRA PROBLEMA DEVE TE-LA INDUBITAVELMENTE //////////////////////
getBaseConhecimentoService().update(baseAux, null, 1, usuarioDto);
// faz o update e gera uma nova vers�o. Pega o id da nova vers�o e salva
if (getBaseConhecimentoService().getIdBaseConhecimento() != null) {
problema.setIdBaseConhecimento(getBaseConhecimentoService().getIdBaseConhecimento());
}
getDao().updateNotNull(problema);
} else {
// ///////////////// ID EMPRESA SETADO MANUALMENTE POR N�O HAVER AINDA TRATAMENTO DE MULTIPLAS EMPRESAS /////////////////////////////////
// //////////////// APROVA BASE SETADO TRUE MANUALMENTE POIS QUEM REGISTRA PROBLEMA DEVE TE-LA INDUBITAVELMENTE //////////////////////
baseAux = getBaseConhecimentoService().create(getBeanErroConhecidoBaseConhecimento(problema), null, 1, usuarioDto);
// faz o update e gera uma nova vers�o. Pega o id da nova vers�o e salva
if (baseAux.getIdBaseConhecimento() != null) {
problema.setIdBaseConhecimento(baseAux.getIdBaseConhecimento());
}
getDao().updateNotNull(problema);
}
}
tc.commit();
tc.close();
} catch (Exception e) {
this.rollbackTransaction(tc, e);
e.printStackTrace();
}
}
public List<ProblemaDTO> listProblema(ProblemaDTO bean) throws ServiceException, LogicException {
try {
return (List<ProblemaDTO>) getDao().listProblema(bean);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public void deleteAll(ProblemaDTO problema) throws ServiceException, LogicException {
TransactionControler tc = new TransactionControlerImpl(getDao().getAliasDB());
try {
getDao().setTransactionControler(tc);
getProblemaItemConfiguracaoDao().setTransactionControler(tc);
tc.start();
getDao().delecaoLogica(problema);
tc.commit();
tc.close();
} catch (Exception e) {
this.rollbackTransaction(tc, e);
e.printStackTrace();
}
}
/**
* Grava relacionamento com base conhecimento.
*
* @param problema
*/
private BaseConhecimentoDTO getBeanErroConhecidoBaseConhecimento(ProblemaDTO problema) {
BaseConhecimentoDTO baseDtoAux = new BaseConhecimentoDTO();
if (problema.getAdicionarBDCE() != null && problema.getAdicionarBDCE().trim().equalsIgnoreCase("S")) {
baseDtoAux.setTitulo(problema.getTitulo());
baseDtoAux.setIdPasta(problema.getIdPastaBaseConhecimento());
baseDtoAux.setStatus(problema.getStatusBaseConhecimento());
baseDtoAux.setOrigem(problema.getOrigem());
baseDtoAux.setConteudo("Causa Raiz: <br />" + problema.getCausaRaiz() + " <br /><br /> Solu��o de Contorno:<br />" + problema.getSolucaoContorno());
baseDtoAux.setDataInicio(UtilDatas.getDataAtual());
baseDtoAux.setDataExpiracao(problema.getDataHoraLimiteSolucionar());
}
return baseDtoAux;
}
public Collection findByIdProblema(Integer parm) throws Exception {
try {
return getDao().findByIdProblema(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public void deleteByIdProblema(Integer parm) throws Exception {
try {
getDao().deleteByIdProblema(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public Collection findByStatus(String parm) throws Exception {
try {
return getDao().findByStatus(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public void deleteByStatus(String parm) throws Exception {
try {
getDao().deleteByStatus(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public Collection findByPrioridade(Integer parm) throws Exception {
try {
return getDao().findByPrioridade(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public void deleteByPrioridade(Integer parm) throws Exception {
try {
getDao().deleteByPrioridade(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public Collection findByIdCriador(Integer parm) throws Exception {
try {
return getDao().findByIdCriador(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public void deleteByIdCriador(Integer parm) throws Exception {
try {
getDao().deleteByIdCriador(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public Collection findByIdProprietario(Integer parm) throws Exception {
try {
return getDao().findByIdProprietario(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public void deleteByIdProprietario(Integer parm) throws Exception {
try {
getDao().deleteByIdProprietario(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public Collection findByTitulo(String parm) throws Exception {
try {
return getDao().findByTitulo(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public void deleteByTitulo(String parm) throws Exception {
try {
getDao().deleteByTitulo(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public Collection findByDescricao(String parm) throws Exception {
try {
return getDao().findByDescricao(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public void deleteByDescricao(String parm) throws Exception {
try {
getDao().deleteByDescricao(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public Collection findByIdCategoriaProblema(Integer parm) throws Exception {
try {
return getDao().findByIdCategoriaProblema(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public void deleteByIdCategoriaProblema(Integer parm) throws Exception {
try {
getDao().deleteByIdCategoriaProblema(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public Collection findByImpacto(String parm) throws Exception {
try {
return getDao().findByImpacto(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public void deleteByImpacto(String parm) throws Exception {
try {
getDao().deleteByImpacto(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public Collection findByUrgencia(String parm) throws Exception {
try {
return getDao().findByUrgencia(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public void deleteByUrgencia(String parm) throws Exception {
try {
getDao().deleteByUrgencia(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public Collection findByProativoReativo(String parm) throws Exception {
try {
return getDao().findByProativoReativo(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public void deleteByProativoReativo(String parm) throws Exception {
try {
getDao().deleteByProativoReativo(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public Collection findByMsgErroAssociada(String parm) throws Exception {
try {
return getDao().findByMsgErroAssociada(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public void deleteByMsgErroAssociada(String parm) throws Exception {
try {
getDao().deleteByMsgErroAssociada(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public Collection findByIdProblemaItemConfiguracao(Integer parm) throws Exception {
try {
return getDao().findByIdProblemaItemConfiguracao(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public void deleteByIdProblemaItemConfiguracao(Integer parm) throws Exception {
try {
getDao().deleteByIdProblemaItemConfiguracao(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public Collection findByIdErrosConhecidos(Integer parm) throws Exception {
try {
return getDao().findByIdErrosConhecidos(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public void deleteByIdErrosConhecidos(Integer parm) throws Exception {
try {
getDao().deleteByIdErrosConhecidos(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public Collection findByIdProblemaMudanca(Integer parm) throws Exception {
try {
return getDao().findByIdProblemaMudanca(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public void deleteByIdProblemaMudanca(Integer parm) throws Exception {
try {
getDao().deleteByIdProblemaMudanca(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public Collection findByIdProblemaIncidente(Integer parm) throws Exception {
try {
return getDao().findByIdProblemaIncidente(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public void deleteByIdProblemaIncidente(Integer parm) throws Exception {
try {
getDao().deleteByIdProblemaIncidente(parm);
} catch (Exception e) {
throw new ServiceException(e);
}
}
public Collection findByIdSolictacaoServico(Integer parm) throws ServiceException, LogicException {
SolicitacaoServicoProblemaDao solicitacaoServicoProblemaDao = new SolicitacaoServicoProblemaDao();
Collection<ProblemaDTO> colProblema = new ArrayList<ProblemaDTO>();
ProblemaDTO problema = new ProblemaDTO();
try {
Collection<SolicitacaoServicoProblemaDTO> colAux = solicitacaoServicoProblemaDao.findByIdSolictacaoServico(parm);
if (colAux != null) {
for (SolicitacaoServicoProblemaDTO sol : colAux) {
problema.setIdProblema(sol.getIdProblema());
colProblema.add((ProblemaDTO) getDao().restore(problema));
}
}
} catch (Exception e) {
e.printStackTrace();
}
return colProblema;
}
public Collection findBySolictacaoServico(ProblemaDTO bean) throws ServiceException, LogicException {
try {
return getDao().listProblemaByIdSolicitacao(bean);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
@Override
public List<ProblemaDTO> listProblemaByIdItemConfiguracao(Integer idItemConfiguracao) throws PersistenceException {
try {
return getDao().listProblemaByIdItemConfiguracao(idItemConfiguracao);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
@Override
public Collection<ProblemaDTO> quantidadeProblemaPorBaseConhecimento(ProblemaDTO problema) throws Exception {
return getDao().quantidadeProblemaPorBaseConhecimento(problema);
}
@Override
public Collection<ProblemaDTO> listaProblemaPorBaseConhecimento(ProblemaDTO problema) throws Exception {
Collection<ProblemaDTO> listaProblemaPorBaseConhecimento = null;
try {
listaProblemaPorBaseConhecimento = getDao().listaProblemasPorBaseConhecimento(problema);
for (ProblemaDTO problemaDTO : listaProblemaPorBaseConhecimento) {
Source source = new Source(problemaDTO.getDescricao());
problemaDTO.setDescricao(source.getTextExtractor().toString());
if (StringUtils.contains(StringUtils.upperCase(problemaDTO.getStatus()), StringUtils.upperCase("SolucaoContornoDefinida"))) {
problemaDTO.setStatus("Solu��o Contorno Definida");
}
}
} catch (Exception e) {
e.printStackTrace();
}
return listaProblemaPorBaseConhecimento;
}
@Override
public Collection findByConhecimento(BaseConhecimentoDTO baseConhecimentoDto) throws ServiceException, LogicException {
try {
return getDao().findByConhecimento(baseConhecimentoDto);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public Collection<ProblemaDTO> listByTarefas(Collection<TarefaFluxoDTO> listTarefas) throws Exception {
Collection<ProblemaDTO> listProblemaDto = new ArrayList();
listProblemaDto = getDao().listByTarefas(listTarefas);
if (listProblemaDto != null && !listProblemaDto.isEmpty()) {
for (ProblemaDTO problemaDto : listProblemaDto) {
if (problemaDto != null) {
problemaDto.setDataHoraCapturaStr(problemaDto.getDataHoraCapturaStr());
problemaDto.setDataHoraLimiteStr(problemaDto.getDataHoraLimiteStr());
problemaDto.setDataHoraInicioSLA(problemaDto.getDataHoraInicioSLA());
problemaDto.setNomeServico(problemaDto.getServico());
if (problemaDto.getNomeUnidadeSolicitante() != null && !problemaDto.getNomeUnidadeSolicitante().trim().equalsIgnoreCase(""))
problemaDto.setSolicitanteUnidade(problemaDto.getSolicitante() + " (" + problemaDto.getNomeUnidadeSolicitante() + ")");
if (problemaDto.getNomeUnidadeResponsavel() != null && !problemaDto.getNomeUnidadeResponsavel().trim().equalsIgnoreCase(""))
problemaDto.setResponsavel(problemaDto.getResponsavel() + " (" + problemaDto.getNomeUnidadeResponsavel() + ")");
}
}
}
return listProblemaDto;
}
public ProblemaDTO restoreByIdInstanciaFluxo(Integer idInstanciaFluxo) throws Exception {
ProblemaDTO problemaDTO = null;
try {
problemaDTO = (ProblemaDTO) getDao().restoreByIdInstanciaFluxo(idInstanciaFluxo);
} catch (Exception e) {
System.out.println("CITSMART - Erro na recupera��o dos dados da solicita��o da inst�ncia fluxo" + " " + idInstanciaFluxo);
}
if (problemaDTO != null) {
// Isso eh necessario!!!
problemaDTO.setDataHoraLimiteStr(problemaDTO.getDataHoraLimiteStr());
problemaDTO.setNomeServico(problemaDTO.getServico());
if (problemaDTO.getNomeUnidadeSolicitante() != null && !problemaDTO.getNomeUnidadeSolicitante().trim().equalsIgnoreCase(""))
problemaDTO.setSolicitanteUnidade(problemaDTO.getSolicitante() + " (" + problemaDTO.getNomeUnidadeSolicitante() + ")");
if (problemaDTO.getNomeUnidadeResponsavel() != null && !problemaDTO.getNomeUnidadeResponsavel().trim().equalsIgnoreCase(""))
problemaDTO.setResponsavel(problemaDTO.getResponsavel() + " (" + problemaDTO.getNomeUnidadeResponsavel() + ")");
}
return verificaSituacaoSLA(problemaDTO);
}
public ProblemaDTO verificaSituacaoSLA(ProblemaDTO problemaDto) throws Exception {
return verificaSituacaoSLA(problemaDto, null);
}
public void suspende(UsuarioDTO usuarioDto, ProblemaDTO problemaDto, TransactionControler tc) throws Exception {
ProblemaDTO problemaAuxDto = restoreAll(problemaDto.getIdProblema(), tc);
problemaAuxDto.setIdJustificativaProblema(problemaDto.getIdJustificativaProblema());
problemaAuxDto.setComplementoJustificativa(problemaDto.getComplementoJustificativa());
new ExecucaoProblemaServiceEjb().suspende(usuarioDto, problemaAuxDto, tc);
}
public void suspende(UsuarioDTO usuarioDto, ProblemaDTO problemaDto) throws Exception {
TransactionControler tc = new TransactionControlerImpl(getDao().getAliasDB());
suspende(usuarioDto, problemaDto, tc);
tc.close();
}
public ContatoProblemaDTO criarContatoProblema(ProblemaDTO problemaDto, TransactionControler tc) throws ServiceException, LogicException {
ContatoProblemaDAO contatoProblemaDao = new ContatoProblemaDAO();
ContatoProblemaDTO contatoProblemaDto = new ContatoProblemaDTO();
ProblemaDAO proplemaDao = this.getDao();
try {
contatoProblemaDao.setTransactionControler(tc);
proplemaDao.setTransactionControler(tc);
if (problemaDto.getIdContatoProblema() != null) {
contatoProblemaDto.setIdContatoProblema(problemaDto.getIdContatoProblema());
contatoProblemaDto.setNomecontato(problemaDto.getNomeContato());
contatoProblemaDto.setTelefonecontato(problemaDto.getTelefoneContato());
contatoProblemaDto.setRamal(problemaDto.getRamal());
contatoProblemaDto.setEmailcontato(problemaDto.getEmailContato().trim());
contatoProblemaDto.setObservacao(problemaDto.getObservacao());
contatoProblemaDto.setIdLocalidade(problemaDto.getIdLocalidade());
contatoProblemaDao.update(contatoProblemaDto);
} else {
contatoProblemaDto.setNomecontato(problemaDto.getNomeContato());
contatoProblemaDto.setTelefonecontato(problemaDto.getTelefoneContato());
contatoProblemaDto.setRamal(problemaDto.getRamal());
if (problemaDto.getEmailContato() != null) {
contatoProblemaDto.setEmailcontato(problemaDto.getEmailContato().trim());
}
contatoProblemaDto.setObservacao(problemaDto.getObservacao());
contatoProblemaDto.setIdLocalidade(problemaDto.getIdLocalidade());
contatoProblemaDto = (ContatoProblemaDTO) contatoProblemaDao.create(contatoProblemaDto);
}
} catch (Exception e) {
this.rollbackTransaction(tc, e);
throw new ServiceException(e);
}
return contatoProblemaDto;
}
private String getStatusAtual(Integer id) throws ServiceException, Exception {
ProblemaDTO problemaDto = new ProblemaDTO();
problemaDto.setIdProblema(id);
problemaDto = (ProblemaDTO) getDao().restore(problemaDto);
String res = problemaDto.getStatus();
return res;
}
private Timestamp transformaHoraFinal(Date data) throws ParseException {
String dataHora = data + " 00:00:00";
String pattern = "yyyy-MM-dd hh:mm:ss";
SimpleDateFormat sdf = new SimpleDateFormat(pattern);
java.util.Date d = sdf.parse(dataHora);
java.sql.Timestamp sqlDate = new java.sql.Timestamp(d.getTime());
return sqlDate;
}
private ProblemaDTO getProblemaAtual(Integer id) throws Exception {
ProblemaDTO problemaDto = new ProblemaDTO();
problemaDto.setIdProblema(id);
problemaDto = (ProblemaDTO) getDao().restore(problemaDto);
return problemaDto;
}
/**
* M�todo respons�vel por validar a din�mica do fluxo com rela��o ao registro de erros conhecidos. Esse m�todo deve garantir que o usu�rio s� avance a partir da fase de avalia��o e diagn�stico
* para a fase de resolu��o ap�s ter registrado pelo menos um erro (fase de registro de erros conhecidos).
*
* @autor thiago.monteiro
* @param ProblemaDTO
* problemaDTO
* @param TransactionControler
* tc
* @throws Exception
* @return
*/
public boolean validacaoAvancaFluxo(ProblemaDTO problemaDTO, TransactionControler tc) throws Exception {
boolean avancarFluxo = false;
if (problemaDTO != null && problemaDTO.getIdProblema() != null) {
// 1 - Obtendo o conhecimento sobre um problema.
ConhecimentoProblemaDTO conhecimentoProblemaDTO = new ConhecimentoProblemaDTO();
ConhecimentoProblemaDao conhecimentoProblemaDAO = new ConhecimentoProblemaDao();
if (conhecimentoProblemaDTO != null && conhecimentoProblemaDAO != null) {
if (tc != null) {
conhecimentoProblemaDAO.setTransactionControler(tc);
}
Collection listaConhecimentoProblemaDTO = conhecimentoProblemaDAO.findByIdProblema(problemaDTO.getIdProblema());
BaseConhecimentoDAO baseConhecimentoDAO = new BaseConhecimentoDAO();
if (listaConhecimentoProblemaDTO != null && baseConhecimentoDAO != null) {
Collection listaBaseConhecimentoDTO = null;
List condicao = new ArrayList();
condicao.add(new Condition("idBaseConhecimento", "=", 0));
for (ConhecimentoProblemaDTO conhecimentoProblemaDTOAux : (Collection<ConhecimentoProblemaDTO>) listaConhecimentoProblemaDTO) {
// Alterando o valor da condi��o para o id da base conhecimento.
((Condition) condicao.get(0)).setValue(conhecimentoProblemaDTOAux.getIdBaseConhecimento());
listaBaseConhecimentoDTO = baseConhecimentoDAO.findByCondition(condicao, null);
for (Object baseConhecimentoDTOAux : listaBaseConhecimentoDTO) {
if (((BaseConhecimentoDTO) baseConhecimentoDTOAux).getErroConhecido().equalsIgnoreCase("S")) {
avancarFluxo = true;
}
}
}
}
}
}
return avancarFluxo;
}
/**
* M�todo respons�vel por notificar que o prazo de contorno/solu��o de um problema expirou. O prazo de contorno/solu��o ir� expirar quando a data hora atual for posterior a data hora limite do
* problema. A notifica��o deve ser feita para o propriet�rio (quem capturou o problema) e o grupo de interessados (grupo executor).
*
* @autor thiago.monteiro
* @param ProblemaDTO
* problemaDTO
* @throws Exception
* @return
*/
public int contarProblemasComPrazoLimiteContornoExpirado(UsuarioDTO usuarioDTO) throws Exception {
return getDao().contarProblemasComPrazoLimiteContornoExpirado(usuarioDTO);
}
public void notificarPrazoSolucionarProblemaExpirou(ProblemaDTO problemaDTO) throws Exception {
}
@Override
public void updateNotNull(IDto obj) throws Exception {
getDao().updateNotNull(obj);
}
/**
* M�todo respons�vel de fazer altera��o no campo conteudo do erro conhecido do problema passado dentro da entidade base de conhecimento.
*
* @param ProblemaDTO
* problemaDTO
* @param TransactionControler
* tc
* @throws Exception
* @return
* @autor thays.araujo
*/
public void updateConteudoBaseConhecimento(ProblemaDTO problemaDto, TransactionControler tc) throws Exception {
if (problemaDto != null && problemaDto.getIdProblema() != null) {
ConhecimentoProblemaDTO conhecimentoProblemaDTO = new ConhecimentoProblemaDTO();
BaseConhecimentoDTO baseConhecimentoDto = new BaseConhecimentoDTO();
ConhecimentoProblemaDao conhecimentoProblemaDAO = new ConhecimentoProblemaDao();
BaseConhecimentoDAO baseConhecimentoDao = new BaseConhecimentoDAO();
if (conhecimentoProblemaDTO != null && conhecimentoProblemaDAO != null) {
if (tc != null) {
conhecimentoProblemaDAO.setTransactionControler(tc);
baseConhecimentoDao.setTransactionControler(tc);
}
Collection<ConhecimentoProblemaDTO> listaConhecimentoProblemaDTO = conhecimentoProblemaDAO.findByIdProblema(problemaDto.getIdProblema());
if (listaConhecimentoProblemaDTO != null) {
for (ConhecimentoProblemaDTO conhecimentoProblemaDTOAux : listaConhecimentoProblemaDTO) {
if (conhecimentoProblemaDTOAux.getIdBaseConhecimento() != null) {
baseConhecimentoDto.setIdBaseConhecimento(conhecimentoProblemaDTOAux.getIdBaseConhecimento());
baseConhecimentoDto = (BaseConhecimentoDTO) baseConhecimentoDao.restore(baseConhecimentoDto);
if (baseConhecimentoDto != null) {
if (baseConhecimentoDto.getIdBaseConhecimento() != null) {
if (baseConhecimentoDto.getErroConhecido() != null && baseConhecimentoDto.getErroConhecido().equalsIgnoreCase("S")) {
baseConhecimentoDto.setConteudo("<strong>Causa raiz:</strong><br type='_moz' />" + problemaDto.getCausaRaiz()
+ "<br/><br/><strong> Solução contorno:</strong><br />" + problemaDto.getSolucaoContorno());
baseConhecimentoDao.update(baseConhecimentoDto);
}
}
}
}
}
}
}
}
}
@Override
public Collection<ProblemaDTO> listaProblemasComPrazoLimiteContornoExpirado(UsuarioDTO usuarioDTO) throws Exception {
return getDao().listaProblemasComPrazoLimiteContornoExpirado(usuarioDTO);
}
public Collection<ProblemaDTO> listProblemaByCriterios(ProblemaDTO requisicaoMudancaDto) throws Exception {
return null;
}
public Collection<PesquisaProblemaDTO> listProblemaByCriterios(PesquisaProblemaDTO pesquisaProblemaDto) throws Exception {
Collection<PesquisaProblemaDTO> listProblemaByCriterios = getDao().listProblemaByCriterios(pesquisaProblemaDto);
if (listProblemaByCriterios != null) {
for (PesquisaProblemaDTO problema : listProblemaByCriterios) {
Source source = new Source(problema.getDescricao());
problema.setDescricao(source.getTextExtractor().toString());
}
}
return listProblemaByCriterios;
}
@Override
public String getUrlInformacoesComplementares(ProblemaDTO problemaDto) throws Exception {
String url = "";
TemplateSolicitacaoServicoDTO templateDto = new TemplateSolicitacaoServicoServiceEjb().recuperaTemplateProblema(problemaDto);
if (templateDto != null) {
url = ParametroUtil.getValorParametroCitSmartHashMap(ParametroSistema.URL_Sistema, "");
url += templateDto.getUrlRecuperacao();
url += "?";
url = url.replaceAll("\n", "");
url = url.replaceAll("\r", "");
String editar = "S";
if (problemaDto.getIdProblema() != null && problemaDto.getIdProblema().intValue() > 0) {
url += "idProblema=" + problemaDto.getIdProblema() + "&";
if (problemaDto.getIdTarefa() == null)
editar = "N";
else
url += "idTarefa=" + problemaDto.getIdTarefa() + "&";
}
url += "idCategoriaProblema=" + problemaDto.getIdCategoriaProblema() + "&idContrato=" + problemaDto.getIdContrato();
url += "&editar=" + editar;
}
return url;
}
@Override
public void deserializaInformacoesComplementares(ProblemaDTO problemaDto) throws Exception {
if (problemaDto.getInformacoesComplementares_serialize() != null && !problemaDto.getInformacoesComplementares_serialize().equalsIgnoreCase("")) {
TemplateSolicitacaoServicoDTO templateDto = new TemplateSolicitacaoServicoServiceEjb().recuperaTemplateProblema(problemaDto);
if (templateDto != null && templateDto.getNomeClasseServico() != null) {
ComplemInfProblemaServicoService informacoesComplementaresService = getInformacoesComplementaresService(templateDto.getNomeClasseServico());
IDto informacoesComplementares = informacoesComplementaresService.deserializaObjeto(problemaDto.getInformacoesComplementares_serialize());
problemaDto.setInformacoesComplementares(informacoesComplementares);
}
problemaDto.setInformacoesComplementares_serialize(null);
}
}
public ComplemInfProblemaServicoService getInformacoesComplementaresService(String nomeClasse) throws Exception {
ComplemInfProblemaServicoService informacoesComplementaresService = (ComplemInfProblemaServicoService) Class.forName(nomeClasse).newInstance();
return informacoesComplementaresService;
}
@Override
public Collection<RelatorioProblemaIncidentesDTO> listProblemasIncidentes(RelatorioProblemaIncidentesDTO relatorioProblemaIcidentesDto) throws Exception {
Collection<RelatorioProblemaIncidentesDTO> listFinal = new ArrayList<RelatorioProblemaIncidentesDTO>();
// Retorna quais problemas tem relacionamentos com incidentes;
Collection<RelatorioProblemaIncidentesDTO> listAux = getDao().listProblemaIncidentes(relatorioProblemaIcidentesDto);
Collection<SolicitacaoServicoDTO> listSolicitacaoServicoByProblema = new ArrayList<SolicitacaoServicoDTO>();
SolicitacaoServicoProblemaDao solicitacaoDao = new SolicitacaoServicoProblemaDao();
if (listAux != null) {
for (RelatorioProblemaIncidentesDTO obj : listAux) {
// retorna cole��o de incidentes relacionaodo ao problema
listSolicitacaoServicoByProblema = solicitacaoDao.listSolicitacaoServicoByProblema(obj.getIdProblema());
if (listSolicitacaoServicoByProblema != null) {
obj.setColSolicitacaoServico(listSolicitacaoServicoByProblema);
obj.setTotalSolicitacaoServicoPorProblema(listSolicitacaoServicoByProblema.size());
}
listFinal.add(obj);
}
return listFinal;
}
return null;
}
public ProblemaDTO restoreAll(ProblemaDTO problema) throws Exception {
return restoreAll(problema, null);
}
public ProblemaDTO restoreAll(ProblemaDTO problema, TransactionControler tc) throws Exception {
ProblemaDTO problemaDto = new ProblemaDTO();
problemaDto = (ProblemaDTO) getDao().restoreTela(problema);
try {
} catch (Exception e) {
throw new Exception(i18nMessage("solicitacaoservico.erro.recuperardadosolicitacao") + " " + problema.getIdProblema());
}
if (problemaDto != null) {
// Isso eh necessario!!!
if (problemaDto.getDataHoraLimite() != null) {
problemaDto.setDataHoraLimiteStr(problemaDto.getDataHoraLimiteStr());
}
problemaDto.setIdGrupoAtual(problemaDto.getIdGrupo());
problemaDto.setIdGrupoNivel1(problemaDto.getIdGrupo());
problemaDto.setNomeServico(problemaDto.getServico());
if (problemaDto.getNomeUnidadeSolicitante() != null && !problemaDto.getNomeUnidadeSolicitante().trim().equalsIgnoreCase(""))
problemaDto.setSolicitanteUnidade(problemaDto.getSolicitante() + " (" + problemaDto.getNomeUnidadeSolicitante() + ")");
if (problemaDto.getNomeUnidadeResponsavel() != null && !problemaDto.getNomeUnidadeResponsavel().trim().equalsIgnoreCase(""))
problemaDto.setResponsavel(problemaDto.getResponsavel() + " (" + problemaDto.getNomeUnidadeResponsavel() + ")");
if (problemaDto.getIdSolicitante() != null) {
UsuarioDTO usuarioDto = new UsuarioDTO();
UsuarioDao usuarioDao = new UsuarioDao();
usuarioDto.setIdEmpregado(problemaDto.getIdSolicitante());
usuarioDto = (UsuarioDTO) usuarioDao.restoreByIdEmpregado(usuarioDto.getIdEmpregado());
if (usuarioDto != null) {
problemaDto.setSolicitante(usuarioDto.getNomeUsuario());
}
}
if (problemaDto.getIdProprietario() != null) {
UsuarioDTO usuarioDto = new UsuarioDTO();
UsuarioDao usuarioDao = new UsuarioDao();
usuarioDto.setIdUsuario(problemaDto.getIdProprietario());
usuarioDto = (UsuarioDTO) usuarioDao.restore(usuarioDto);
if (usuarioDto != null) {
problemaDto.setResponsavel(usuarioDto.getLogin());
}
}
if (problemaDto.getIdGrupo() != null) {
GrupoDao grupoDao = new GrupoDao();
GrupoDTO grupoDto = new GrupoDTO();
grupoDto.setIdGrupo(problemaDto.getIdGrupo());
grupoDto = (GrupoDTO) grupoDao.restore(grupoDto);
if (grupoDto != null)
problemaDto.setNomeGrupoAtual(grupoDto.getSigla());
}
if (problemaDto.getIdContrato() != null) {
ContratoDTO contratoDto = new ContratoDTO();
ContratoDao contratoDao = new ContratoDao();
contratoDto.setIdContrato(problemaDto.getIdContrato());
contratoDto = (ContratoDTO) contratoDao.restore(contratoDto);
if (contratoDto != null)
problemaDto.setContrato(contratoDto.getNumero());
}
if (problemaDto.getIdContatoProblema() != null) {
ContatoProblemaDTO contatoProblemaDto = new ContatoProblemaDTO();
ContatoProblemaDAO contatoProblemaDao = new ContatoProblemaDAO();
contatoProblemaDto.setIdContatoProblema(problemaDto.getIdContatoProblema());
contatoProblemaDto = (ContatoProblemaDTO) contatoProblemaDao.restore(contatoProblemaDto);
if (contatoProblemaDto != null) {
problemaDto.setNomeContato(contatoProblemaDto.getNomecontato());
problemaDto.setEmailContato(contatoProblemaDto.getEmailcontato());
problemaDto.setTelefoneContato(contatoProblemaDto.getTelefonecontato());
problemaDto.setRamal(contatoProblemaDto.getRamal());
problemaDto.setObservacao(contatoProblemaDto.getObservacao());
problemaDto.setIdLocalidade(contatoProblemaDto.getIdLocalidade());
}
}
}
return verificaSituacaoSLA(problemaDto, tc);
}
@Override
public ProblemaDTO restauraTodos(ProblemaDTO param) throws Exception {
return (ProblemaDTO) getDao().restauraTodos(param);
}
@Override
public Collection<RelatorioQuantitativoProblemaDTO> listaQuantidadeProblemaPorSituacao(RelatorioQuantitativoProblemaDTO relatorioQuantitativoProblemaDto) throws Exception {
return getDao().listaQuantidadeProblemaPorSituacao(relatorioQuantitativoProblemaDto);
}
@Override
public Collection<RelatorioQuantitativoProblemaDTO> listaQuantidadeProblemaPorGrupo(RelatorioQuantitativoProblemaDTO relatorioQuantitativoProblemaDto) throws Exception {
return getDao().listaQuantidadeProblemaPorGrupo(relatorioQuantitativoProblemaDto);
}
@Override
public Collection<RelatorioQuantitativoProblemaDTO> listaQuantidadeProblemaPorOrigem(RelatorioQuantitativoProblemaDTO relatorioQuantitativoProblemaDto) throws Exception {
return getDao().listaQuantidadeProblemaPorOrigem(relatorioQuantitativoProblemaDto);
}
@Override
public Collection<RelatorioQuantitativoProblemaDTO> listaQuantidadeProblemaPorSolicitante(RelatorioQuantitativoProblemaDTO relatorioQuantitativoProblemaDto) throws Exception {
return getDao().listaQuantidadeProblemaPorSolicitante(relatorioQuantitativoProblemaDto);
}
@Override
public Collection<RelatorioQuantitativoProblemaDTO> listaQuantidadeProblemaPorPrioridade(RelatorioQuantitativoProblemaDTO relatorioQuantitativoProblemaDto) throws Exception {
return getDao().listaQuantidadeProblemaPorPrioridade(relatorioQuantitativoProblemaDto);
}
@Override
public Collection<RelatorioQuantitativoProblemaDTO> listaQuantidadeProblemaPorCategoria(RelatorioQuantitativoProblemaDTO relatorioQuantitativoProblemaDto) throws Exception {
return getDao().listaQuantidadeProblemaPorCategoria(relatorioQuantitativoProblemaDto);
}
@Override
public Collection<RelatorioQuantitativoProblemaDTO> listaQuantidadeProblemaPorProprietario(RelatorioQuantitativoProblemaDTO relatorioQuantitativoProblemaDto) throws Exception {
return getDao().listaQuantidadeProblemaPorProprietario(relatorioQuantitativoProblemaDto);
}
@Override
public Collection<RelatorioQuantitativoProblemaDTO> listaQuantidadeProblemaPorImpacto(RelatorioQuantitativoProblemaDTO relatorioQuantitativoProblemaDto) throws Exception {
return getDao().listaQuantidadeProblemaPorImpacto(relatorioQuantitativoProblemaDto);
}
@Override
public Collection<RelatorioQuantitativoProblemaDTO> listaQuantidadeProblemaPorUrgencia(RelatorioQuantitativoProblemaDTO relatorioQuantitativoProblemaDto) throws Exception {
return getDao().listaQuantidadeProblemaPorUrgencia(relatorioQuantitativoProblemaDto);
}
public void encerra(ProblemaDTO problemaDTO, TransactionControler tc) throws Exception {
ProblemaDTO problemaDTOAux = restoreAll(problemaDTO.getIdProblema(), tc);
new ExecucaoProblemaServiceEjb().encerra(problemaDTOAux, tc);
}
public boolean verificaPermissaoGrupoCancelar(Integer idTipoProblema, Integer idGrupo) throws ServiceException, Exception {
boolean isOk = false;
CategoriaProblemaService categoriaProblemaService = (CategoriaProblemaService) ServiceLocator.getInstance().getService(CategoriaProblemaService.class, null);
CategoriaProblemaDTO categoriaProblemaDTO = new CategoriaProblemaDTO();
PermissoesFluxoDao permissoesDao = new PermissoesFluxoDao();
/* Desenvolvedor: euler.ramos Data: 25/10/2013 Hor�rio: 10h20min ID Citsmart: 120393 Motivo/Coment�rio: idTipoProblema era null e causava problema na hora do restore */
if ((idTipoProblema != null) && (idTipoProblema.intValue() > 0)) {
categoriaProblemaDTO.setIdCategoriaProblema(idTipoProblema);
categoriaProblemaDTO = (CategoriaProblemaDTO) categoriaProblemaService.restore(categoriaProblemaDTO);
if (categoriaProblemaDTO != null) {
PermissoesFluxoDTO permissoesDto = permissoesDao.permissaoGrupoCancelar(idGrupo, categoriaProblemaDTO.getIdTipoFluxo());
if (permissoesDto != null && permissoesDto.getCancelar() != null && permissoesDto.getCancelar().equalsIgnoreCase("S"))
isOk = true;
}
}
return isOk;
}
public boolean validacaoGrupoExecutor(ProblemaDTO problemaDto) throws Exception {
boolean resultado = false;
if (problemaDto != null && problemaDto.getIdGrupoAtual() == null)
problemaDto.setIdGrupoAtual(problemaDto.getIdGrupo());
if (problemaDto != null && problemaDto.getIdGrupoAtual() != null && problemaDto.getIdCategoriaProblema() != null) {
Integer idGrupoExecutor = problemaDto.getIdGrupoAtual();
Integer idTipoProblema = problemaDto.getIdCategoriaProblema();
PermissoesFluxoService permissoesFluxoService = (PermissoesFluxoService) ServiceLocator.getInstance().getService(PermissoesFluxoService.class, null);
resultado = permissoesFluxoService.permissaoGrupoExecutorProblema(idTipoProblema, idGrupoExecutor);
}
return resultado;
}
public void fechaProblemaERelacionamento(ProblemaDTO problemaDTO, TransactionControler tc) {
try {
this.encerra(problemaDTO, tc);
this.fechaRelacionamentoProblema(problemaDTO, tc);
} catch (Exception e) {
e.printStackTrace();
}
;
}
public void fechaRelacionamentoProblema(ProblemaDTO problemaDTO, TransactionControler tc) {
try {
if (problemaDTO != null && problemaDTO.getFecharItensRelacionados() != null) {
this.fechaSolicitacaoServicoVinculadaProblema(problemaDTO, tc);
}
} catch (Exception e) {
e.printStackTrace();
}
;
}
public void fechaSolicitacaoServicoVinculadaProblema(ProblemaDTO problemaDTO, TransactionControler tc) {
try {
SolicitacaoServicoProblemaDao solicitacaoServicoProblemaDao = new SolicitacaoServicoProblemaDao();
solicitacaoServicoProblemaDao.setTransactionControler(tc);
List<SolicitacaoServicoDTO> listSolicitacaoServicoDTO = (List<SolicitacaoServicoDTO>) solicitacaoServicoProblemaDao.listSolicitacaoServicoByIdProblema(problemaDTO.getIdProblema()
.intValue());
if (listSolicitacaoServicoDTO != null && listSolicitacaoServicoDTO.size() > 0) {
for (SolicitacaoServicoDTO solicitacaoServicoDTO : listSolicitacaoServicoDTO) {
new SolicitacaoServicoServiceEjb().fechaSolicitacaoServicoVinculadaByProblemaOrMudanca(solicitacaoServicoDTO, tc);
}
}
} catch (ServiceException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
public void fechaItemConfiguracaoVinculadoProblema(ProblemaDTO problemaDTO, TransactionControler tc) {
try {
ProblemaItemConfiguracaoDAO problemaItemConfiguracaoDao = new ProblemaItemConfiguracaoDAO();
problemaItemConfiguracaoDao.setTransactionControler(tc);
List<ItemConfiguracaoDTO> listItemConfiguracaoDTO = problemaItemConfiguracaoDao.listItemConfiguracaoByIdProblema(problemaDTO.getIdProblema().intValue());
if (listItemConfiguracaoDTO != null && listItemConfiguracaoDTO.size() > 0) {
for (ItemConfiguracaoDTO itemConfiguracaoDTO : listItemConfiguracaoDTO) {
new ItemConfiguracaoServiceEjb().finalizarItemConfiguracao(itemConfiguracaoDTO, tc);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
public void fechaErroConhecidodoProblema(ProblemaDTO problemaDTO, TransactionControler tc) {
ConhecimentoProblemaDao conhecimentoProblemaDao = new ConhecimentoProblemaDao();
try {
List<BaseConhecimentoDTO> listaBaseConhecimentoDTO = (List<BaseConhecimentoDTO>) conhecimentoProblemaDao.listaErroConhecidoByIdProblema(problemaDTO.getIdProblema());
if (listaBaseConhecimentoDTO != null && listaBaseConhecimentoDTO.size() > 0) {
for (BaseConhecimentoDTO baseConhecimentoDTO : listaBaseConhecimentoDTO) {
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
public void updateTimeAction(Integer idGrupoRedirect, Integer idPrioridadeRedirect, Integer idProblema) throws ServiceException, LogicException {
ExecucaoProblemaServiceEjb execucaoProblemaService = new ExecucaoProblemaServiceEjb();
ProblemaDAO problemaDao = this.getDao();
OcorrenciaProblemaDAO ocorrenciaProblemaDao = new OcorrenciaProblemaDAO();
TransactionControler tc = new TransactionControlerImpl(problemaDao.getAliasDB());
try {
tc.start();
// Faz validacao, caso exista.
problemaDao.setTransactionControler(tc);
ocorrenciaProblemaDao.setTransactionControler(tc);
List<ProblemaDTO> listaProblema = new ArrayList<ProblemaDTO>();
ProblemaDTO problemaAuxDto = new ProblemaDTO();
problemaAuxDto.setIdProblema(idProblema);
listaProblema = (List<ProblemaDTO>) problemaDao.find(problemaAuxDto);
if (listaProblema != null) {
problemaAuxDto = listaProblema.get(0);
}
ProblemaDTO problemaDto = new ProblemaDTO();
problemaDto.setIdGrupoAtual(idGrupoRedirect);
problemaDto.setIdGrupo(idGrupoRedirect);
problemaDto.setPrioridade(idPrioridadeRedirect);
problemaDto.setIdProblema(idProblema);
problemaDao.updateNotNull(problemaDto);
execucaoProblemaService.direcionaAtendimentoAutomatico(problemaDto, tc);
String strOcorr = "\nEscala��o autom�tica.";
JustificativaProblemaDTO justificativaDto = new JustificativaProblemaDTO();
justificativaDto.setIdJustificativaProblema(problemaDto.getIdJustificativaProblema());
justificativaDto.setDescricaoProblema(problemaDto.getComplementoJustificativa());
UsuarioDTO usuarioDTO = new UsuarioDTO();
usuarioDTO.setLogin("Autom�tico");
OcorrenciaProblemaServiceEjb.create(problemaDto, null, strOcorr, OrigemOcorrencia.OUTROS, CategoriaOcorrencia.Atualizacao, null, CategoriaOcorrencia.Atualizacao.getDescricao(),
usuarioDTO.getLogin(), 0, justificativaDto, tc);
tc.commit();
tc.close();
} catch (Exception e) {
this.rollbackTransaction(tc, e);
throw new ServiceException(e);
}
}
/**
* Adicionado para gravar anexo
*
* @author mario.junior
* @since 31/10/2013 09:00
*/
public void gravaInformacoesGED(Collection colArquivosUpload, int idEmpresa, ProblemaDTO problemaDto, TransactionControler tc) throws Exception {
// Setando a transaction no GED
ControleGEDDao controleGEDDao = new ControleGEDDao();
if (tc != null) {
controleGEDDao.setTransactionControler(tc);
}
String PRONTUARIO_GED_DIRETORIO = ParametroUtil.getValorParametroCitSmartHashMap(Enumerados.ParametroSistema.GedDiretorio, "");
if (PRONTUARIO_GED_DIRETORIO == null || PRONTUARIO_GED_DIRETORIO.trim().equalsIgnoreCase("")) {
PRONTUARIO_GED_DIRETORIO = "";
}
if (PRONTUARIO_GED_DIRETORIO.equalsIgnoreCase("")) {
PRONTUARIO_GED_DIRETORIO = Constantes.getValue("DIRETORIO_GED");
}
if (PRONTUARIO_GED_DIRETORIO == null || PRONTUARIO_GED_DIRETORIO.equalsIgnoreCase("")) {
PRONTUARIO_GED_DIRETORIO = "/ged";
}
String PRONTUARIO_GED_INTERNO = ParametroUtil.getValorParametroCitSmartHashMap(Enumerados.ParametroSistema.GedInterno, "S");
if (PRONTUARIO_GED_INTERNO == null) {
PRONTUARIO_GED_INTERNO = "S";
}
String prontuarioGedInternoBancoDados = ParametroUtil.getValorParametroCitSmartHashMap(Enumerados.ParametroSistema.GedInternoBD, "N");
if (!UtilStrings.isNotVazio(prontuarioGedInternoBancoDados))
prontuarioGedInternoBancoDados = "N";
String pasta = "";
if (PRONTUARIO_GED_INTERNO.equalsIgnoreCase("S")) {
pasta = controleGEDDao.getProximaPastaArmazenar();
File fileDir = new File(PRONTUARIO_GED_DIRETORIO);
if (!fileDir.exists()) {
fileDir.mkdirs();
}
fileDir = new File(PRONTUARIO_GED_DIRETORIO + "/" + idEmpresa);
if (!fileDir.exists()) {
fileDir.mkdirs();
}
fileDir = new File(PRONTUARIO_GED_DIRETORIO + "/" + idEmpresa + "/" + pasta);
if (!fileDir.exists()) {
fileDir.mkdirs();
}
}
for (Iterator it = colArquivosUpload.iterator(); it.hasNext();) {
UploadDTO uploadDTO = (UploadDTO) it.next();
ControleGEDDTO controleGEDDTO = new ControleGEDDTO();
controleGEDDTO.setIdTabela(ControleGEDDTO.TABELA_PROBLEMA);
controleGEDDTO.setId(problemaDto.getIdProblema());
controleGEDDTO.setDataHora(UtilDatas.getDataAtual());
controleGEDDTO.setDescricaoArquivo(uploadDTO.getDescricao());
controleGEDDTO.setExtensaoArquivo(Util.getFileExtension(uploadDTO.getNameFile()));
controleGEDDTO.setPasta(pasta);
controleGEDDTO.setNomeArquivo(uploadDTO.getNameFile());
if (!uploadDTO.getTemporario().equalsIgnoreCase("S")) { // Se nao //
// for //
// temporario
continue;
}
if (PRONTUARIO_GED_INTERNO.trim().equalsIgnoreCase("S") && "S".equalsIgnoreCase(prontuarioGedInternoBancoDados.trim())) { // Se
// utiliza
// GED
// interno e eh BD
controleGEDDTO.setPathArquivo(uploadDTO.getPath()); // Isso vai
// fazer a
// gravacao
// no BD.
// dento do
// create
// abaixo.
} else {
controleGEDDTO.setPathArquivo(null);
}
controleGEDDTO = (ControleGEDDTO) controleGEDDao.create(controleGEDDTO);
if (controleGEDDTO != null) {
uploadDTO.setIdControleGED(controleGEDDTO.getIdControleGED());
}
if (PRONTUARIO_GED_INTERNO.equalsIgnoreCase("S") && !"S".equalsIgnoreCase(prontuarioGedInternoBancoDados)) { // Se
// utiliza
// GED
// interno e nao eh BD
if (controleGEDDTO != null) {
try {
File arquivo = new File(PRONTUARIO_GED_DIRETORIO + "/" + idEmpresa + "/" + pasta + "/" + controleGEDDTO.getIdControleGED() + "."
+ Util.getFileExtension(uploadDTO.getNameFile()));
CriptoUtils.encryptFile(uploadDTO.getPath(), PRONTUARIO_GED_DIRETORIO + "/" + idEmpresa + "/" + pasta + "/" + controleGEDDTO.getIdControleGED() + ".ged", System
.getProperties().get("user.dir") + Constantes.getValue("CAMINHO_CHAVE_PUBLICA"));
arquivo.delete();
} catch (Exception e) {
}
}
} /*
* else if (!PRONTUARIO_GED_INTERNO.equalsIgnoreCase("S")) { // Se // utiliza // GED // externo // FALTA IMPLEMENTAR!!! }
*/
}
Collection<ControleGEDDTO> colAnexo = controleGEDDao.listByIdTabelaAndIdBaseConhecimento(ControleGEDDTO.TABELA_PROBLEMA, problemaDto.getIdProblema());
if (colAnexo != null) {
for (ControleGEDDTO dtoGed : colAnexo) {
boolean b = false;
for (Iterator it = colArquivosUpload.iterator(); it.hasNext();) {
UploadDTO uploadDTO = (UploadDTO) it.next();
if (uploadDTO.getIdControleGED() == null) {
b = true;
break;
}
if (uploadDTO.getIdControleGED().intValue() == dtoGed.getIdControleGED().intValue()) {
b = true;
}
if (b) {
break;
}
}
if (!b) {
controleGEDDao.delete(dtoGed);
}
}
}
}
public Collection findByProblemaRelacionado(ProblemaRelacionadoDTO bean) throws Exception {
ProblemaRelacionadoDao problemaRelacionadoDao = new ProblemaRelacionadoDao();
return problemaRelacionadoDao.findByIdProblema(bean.getIdProblema());
}
}