private void btnSalvarCadOcorrencia_Click(object sender, EventArgs e)
{
try
{
string erro = String.Empty;
if (!ValidarCampos(out erro))
{
MessageBox.Show(erro, "Atenção");
}
OcorrenciaTO ocorrenciaTO = new OcorrenciaTO();
ocorrenciaTO.IdMorador = Convert.ToInt32(txtCodMorOcorrencia.Text);
ocorrenciaTO.Motivo = txtMotivoOcorrencia.Text;
ocorrenciaTO.DataOcorrencia = dtOcorrencia.Value.Date;
ocorrenciaTO.Descricao = rtxtDescricaoOcorrencia.Text;
OcorrenciaService.Criar(ocorrenciaTO);
if (!ocorrenciaTO.Valido)
{
MessageBox.Show(ocorrenciaTO.Mensagem, "Atenção");
return;
}
this.Close();
}
catch
{
}
}
public void Execute(IServiceProvider serviceProvider)
{
var context = (IPluginExecutionContext)serviceProvider.GetService(typeof(IPluginExecutionContext));
ITracingService trace = (ITracingService)serviceProvider.GetService(typeof(ITracingService));
IOrganizationServiceFactory serviceFactory = (IOrganizationServiceFactory)serviceProvider.GetService(typeof(IOrganizationServiceFactory));
IOrganizationService service = serviceFactory.CreateOrganizationService(null);
try
{
switch (Util.Utilitario.ConverterEnum <Domain.Enum.Plugin.MessageName>(context.MessageName))
{
#region Create
case Domain.Enum.Plugin.MessageName.Create:
if (context.InputParameters.Contains("Target") && context.InputParameters["Target"] is Entity)
{
var entidade = (Entity)context.InputParameters["Target"];
Anexo anexo = entidade.Parse <Anexo>(context.OrganizationName, context.IsExecutingOffline);
var ocorrenciaService = new OcorrenciaService(context.OrganizationName, context.IsExecutingOffline, service);
OcorrenciaBase ocorrenciaBase = ocorrenciaService.BuscaOcorrenca(anexo.EntidadeRelacionada.Id);
if (ocorrenciaService.IsContractBradesco(ocorrenciaBase) && ocorrenciaBase.ReplicadoBradesco == false && ocorrenciaBase.Id == anexo.EntidadeRelacionada.Id)
{
/*Está condição serve para realizar uma nova tentatica de criação do incidente no HPSM caso
* tenha algum problema de integração durante a execução do create Incidente*/
if (ocorrenciaBase.OsCliente == null)
{
trace.Trace("Inicio integração HPSM - Operação: REGISTRAR INCIDENTE - posCreate");
ocorrenciaBase.TipoOperacao = "REGISTRAR INCIDENTE";
ocorrenciaService.IntegracaoBradesco(ocorrenciaBase);
trace.Trace("Fim integração HPSM - Operação: REGISTRAR INCIDENTE - posCreate");
}
if (anexo.NomeArquivos == null && anexo.Texto != "")
{
trace.Trace("Inicio integração HPSM - Operação: REGISTRAR INFORMACAO COMPLEMENTAR - posCreate");
ocorrenciaBase.TipoOperacao = "REGISTRAR INFORMACAO COMPLEMENTAR";
ocorrenciaService.IntegracaoBradesco(ocorrenciaBase, anexo);
trace.Trace("Fim integração HPSM - Operação: REGISTRAR INFORMACAO COMPLEMENTAR - posCreate");
}
}
}
break;
#endregion
}
}
catch (Exception ex)
{
trace.Trace(String.Format("EXCEPTION PLUGIN {0} {1} [{2}]", context.MessageName.ToLower(), "annotation", DateTime.Now));
trace.Trace(SDKore.Helper.Error.GetMessageError(ex));
throw new InvalidPluginExecutionException(ex.Message);
}
}
public BaseWebController()
{
_empresaService = new EmpresaService();
_enderecoService = new EnderecoService();
_estacaoService = new EstacaoService();
_localizacaoService = new LocalizacaoService();
_pacoteService = new PacoteService();
_rotaService = new RotaService();
_veiculoService = new VeiculoService();
_ocorrenciaService = new OcorrenciaService();
}
public ActionResult Index()
{
_usuarioTO = (UsuarioTO)Session["UsuarioTO"];
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (_usuarioTO != null)
{
_usuarioTO = (UsuarioTO)Session["UsuarioTO"];
if (!_usuarioTO.Valido)
{
return(RedirectToActionPermanent("Login", "Home"));
}
}
else if (_moradorTO != null)
{
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (_moradorTO != null)
{
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (!_moradorTO.Valido)
{
return(RedirectToActionPermanent("Login", "Home"));
}
}
}
else
{
return(RedirectToActionPermanent("Login", "Home"));
}
ListaOcorrenciaTO listaOcorrencia = new ListaOcorrenciaTO();
try
{
if (_moradorTO != null)
{
listaOcorrencia = OcorrenciaService.ListarPorMorador(_moradorTO.Identificador);
}
else
{
listaOcorrencia = OcorrenciaService.Listar();
}
var listaOcorrenciaesVM = Mapper.Map <List <OcorrenciaTO>, List <OcorrenciaVM> >(listaOcorrencia.Lista);
NomearVariaveis(null, listaOcorrenciaesVM);
return(View(listaOcorrenciaesVM));
}
catch (Exception ex)
{
listaOcorrencia.Mensagem = $"Erro ao obter Ocorrenciaes. Erro: {ex.Message} ";
}
return(View());
}
public void Execute(IPluginExecutionContext context)
{
DateTime inicioExecucao = DateTime.Now;
try
{
if ((context.InputParameters.Properties.Contains("Target") && context.InputParameters.Properties["Target"] is DynamicEntity))
{
var entidade = context.InputParameters.Properties["Target"] as DynamicEntity;
if (entidade == null)
{
return;
}
this.Organizacao = context.OrganizationName;
DynamicEntity postimage = null;
if (context.PostEntityImages.Contains("postimage"))
{
postimage = (DynamicEntity)context.PostEntityImages["postimage"];
}
if (postimage == null)
{
return;
}
//alterar status da ocorrencia
if (postimage.Properties.Contains("new_ocorrenciaid") && entidade.Properties.Contains("statuscode"))
{
OcorrenciaService service = new OcorrenciaService(((Lookup)postimage["new_ocorrenciaid"]).Value);
service.AlterarStatusDaOcorrenciaParaOMenorStatusDosDiagnosticosRelacionados();
}
if (entidade.Properties.Contains("new_produtoid") ||
entidade.Properties.Contains("new_geratroca") ||
entidade.Properties.Contains("new_qtd_solicitada"))
{
Guid diagnosticoId = PluginHelper.GetEntityId(context);
var diagnostico = DomainService.RepositoryDiagnostico.Retrieve(diagnosticoId);
this.VerificaIntervencao(diagnostico, context);
}
}
}
catch (Exception ex)
{
PluginHelper.TratarExcecao(ex, TipoDeLog.PluginNew_diagnostico_ocorrencia);
}
}
public BaseApiController()
{
_empresaService = new EmpresaService();
_enderecoService = new EnderecoService();
_estacaoService = new EstacaoService();
_localizacaoService = new LocalizacaoService();
_pacoteService = new PacoteService();
_rotaService = new RotaService();
_veiculoService = new VeiculoService();
_ocorrenciaService = new OcorrenciaService();
_usuarioService = new UsuarioService().OpenSession();
}
public ActionResult DeleteConfirmed(int id)
{
if (ModelState.IsValid)
{
if (id > 0)
{
var retorno = OcorrenciaService.Remover(id);
Session["Mensagem"] = retorno.Mensagem;
}
}
return(RedirectToAction("Index"));
}
static void Main(string[] args)
{
try
{
GravaLog("Inicio rotina : " + DateTime.Now.ToString());
OcorrenciaService OcorrenciaServices = new OcorrenciaService(OrganizationName, IsOffline);
OcorrenciaServices.AtualizaDataSolucaoCliente();
GravaLog("Fim rotina : " + DateTime.Now.ToString());
}
catch (Exception ex)
{
GravaLog("Erro: " + ex.Message);
}
}
public ActionResult Create(OcorrenciaVM Ocorrencia)
{
if (ModelState.IsValid)
{
var OcorrenciaTO = Mapper.Map <OcorrenciaVM, OcorrenciaTO>(Ocorrencia);
OcorrenciaService.Criar(OcorrenciaTO);
Session["Mensagem"] = OcorrenciaTO.Mensagem;
return(RedirectToAction("Index"));
}
else
{
return(View(Ocorrencia));
}
}
private void btnExcluirOcorrencia_Click(object sender, EventArgs e)
{
int idOcorrencia = Convert.ToInt32(lblExcluirCodOcorrencia.Text);
RetornoTO retorno = new RetornoTO();
retorno = OcorrenciaService.Remover(idOcorrencia);
if (!retorno.Valido)
{
//Todo: Retornar mensagem se nao for valido
MessageBox.Show(retorno.Mensagem, "Atenção");
}
this.Close();
}
private void btnSalvarEdicaoOcorrencia_Click(object sender, EventArgs e)
{
OcorrenciaTO ocorrenciaTO = new OcorrenciaTO();
ocorrenciaTO.Motivo = txtEditarMotivoOcorrencia.Text;
ocorrenciaTO.Identificador = Convert.ToInt32(lblEditarCodOcorrencia.Text);
ocorrenciaTO.Descricao = rtxtEditarDescricaoOcorrencia.Text;
OcorrenciaService.Atualizar(ocorrenciaTO);
if (!ocorrenciaTO.Valido)
{
MessageBox.Show(ocorrenciaTO.Mensagem);
}
this.Close();
}
private void AtualizaVigencia(Ocorrencia ocorrencia)
{
try
{
if (ocorrencia.StatusDaOcorrencia != StatusDaOcorrencia.Fechada)
{
return;
}
OcorrenciaService service = new OcorrenciaService(ocorrencia);
service.AtualizarVigenciaContrato();
}
catch (Exception ex)
{
LogHelper.Process(ex, ClassificacaoLog.PluginIncident);
}
}
private void NomearVariaveis(AdvertenciaVM AdvertenciaVM = null, List <AdvertenciaVM> listaAdvertenciaVM = null)
{
var listaOcorrenciaTO = OcorrenciaService.Listar().Lista;
if (listaAdvertenciaVM != null && listaAdvertenciaVM.Count > 0)
{
foreach (var con in listaAdvertenciaVM)
{
con.MotivoOcorrencia = listaOcorrenciaTO.FirstOrDefault(x => x.Identificador == con.IdOcorrencia).Motivo;
con.CheckPag = "S".Equals(con.Pago);
}
}
if (AdvertenciaVM != null)
{
AdvertenciaVM.MotivoOcorrencia = listaOcorrenciaTO.FirstOrDefault(x => x.Identificador == AdvertenciaVM.IdOcorrencia).Motivo;
AdvertenciaVM.CheckPag = "S".Equals(AdvertenciaVM.Pago);
}
}
public ActionResult Edit(OcorrenciaVM OcorrenciaVM)
{
if (ModelState.IsValid)
{
var OcorrenciaTO = Mapper.Map <OcorrenciaVM, OcorrenciaTO>(OcorrenciaVM);
OcorrenciaService.Atualizar(OcorrenciaTO);
if (!OcorrenciaTO.Valido)
{
Session["Mensagem"] = OcorrenciaTO.Valido;
return(RedirectToAction("Index"));
}
OcorrenciaVM = Mapper.Map <OcorrenciaTO, OcorrenciaVM>(OcorrenciaTO);
}
return(RedirectToAction("Index"));
}
private void PreencherCampos(int id)
{
OcorrenciaTO ocorrenciaTO = new OcorrenciaTO();
ocorrenciaTO = OcorrenciaService.Obter(id);
if (!ocorrenciaTO.Valido)
{
//Todo: Exibir Mensagem e Fechar Form
MessageBox.Show(ocorrenciaTO.Mensagem, "Atenção");
this.Close();
}
txtExcluirCodMorOcorrencia.Text = Convert.ToString(ocorrenciaTO.IdMorador);
txtExcluirMotivoOcorrencia.Text = ocorrenciaTO.Motivo;
rtxtExcluirDescricaoOcorrencia.Text = ocorrenciaTO.Descricao;
lblExcluirCodOcorrencia.Text = ocorrenciaTO.Identificador.ToString();
}
public void Execute(IPluginExecutionContext context)
{
DateTime inicioExecucao = DateTime.Now;
try
{
DynamicEntity preimage = (DynamicEntity)context.PreEntityImages["preimage"];
//alterar status da ocorrencia
if (preimage.Properties.Contains("new_ocorrenciaid"))
{
PluginHelper.LogEmArquivo(context, "INICIO;", inicioExecucao.ToString(), "");
OcorrenciaService service = new OcorrenciaService(((Lookup)preimage["new_ocorrenciaid"]).Value);
service.AlterarStatusDaOcorrenciaParaOMenorStatusDosDiagnosticosRelacionados();
PluginHelper.LogEmArquivo(context, "FIM;", inicioExecucao.ToString(), DateTime.Now.ToString());
}
}
catch (Exception ex)
{
PluginHelper.TratarExcecao(ex, TipoDeLog.PluginIncident);
PluginHelper.LogEmArquivo(context, "ERRO;", inicioExecucao.ToString(), DateTime.Now.ToString());
}
}
protected override void Execute(IPluginExecutionContext context, IOrganizationServiceFactory serviceFactory, IOrganizationService adminService, IOrganizationService userService)
{
try
{
switch (Util.Utilitario.ConverterEnum <Domain.Enum.Plugin.MessageName>(context.MessageName))
{
#region Create
case Domain.Enum.Plugin.MessageName.Create:
var parameterCreate = (Entity)context.InputParameters["Target"];
Ocorrencia ocorrenciaCreate = parameterCreate.Parse <Ocorrencia>(context.OrganizationName, context.IsExecutingOffline, adminService);
var ocorrenciaService = new OcorrenciaService(context.OrganizationName, context.IsExecutingOffline);
/*
* Caso a linha de contrato seja do tipo instalação e tenha valor no campo limite
* caso ultrapssse o limite definido da erro, e não deixa criar a ocorrencia
*/
if (ocorrenciaCreate.LinhaDeContratoId != null)
{
RepositoryService repository = new Domain.Servicos.RepositoryService(context.OrganizationName, context.IsExecutingOffline);
var linhaDeContrato = repository.LinhaDoContrato.Retrieve(ocorrenciaCreate.LinhaDeContratoId.Id);
if (linhaDeContrato != null && linhaDeContrato.TipoDeOcorrencia == (int)Domain.Enum.TipoDeOcorrencia.Instalacao && linhaDeContrato.LimiteOcorrencias > 0)
{
var listOcorrencias = ocorrenciaService.ListarOcorrenciasPorLinhaDoContrato(ocorrenciaCreate.LinhaDeContratoId.Id);
if (listOcorrencias.Count >= linhaDeContrato.LimiteOcorrencias)
{
throw new ArgumentException("Erro ao criar Ocorrência. Limite de instalações atingido.");
}
}
}
ocorrenciaService.Ocorrencia = ocorrenciaCreate;
ocorrenciaService.Criar();
AtualizaCampos(ref parameterCreate, ocorrenciaService.Ocorrencia);
if (ocorrenciaCreate.Origem != null && (ocorrenciaCreate.Origem == (int)Domain.Enum.OrigemDaOcorrencia.PortalAssistenciaTencica || ocorrenciaCreate.Origem == (int)Domain.Enum.OrigemDaOcorrencia.OSIntegrada))
{
var usuario = new Guid(SDKore.Configuration.ConfigurationManager.GetSettingValue("guid_proprietario_portal_astec"));
parameterCreate.Attributes["ownerid"] = new EntityReference("systemuser", usuario);
}
break;
#endregion
#region Update
case Domain.Enum.Plugin.MessageName.Update:
var parameterUpdate = (Entity)context.InputParameters["Target"];
var entidadeComValoresFinais = (Entity)context.GetContextEntityMerge("imagem");
Ocorrencia ocorrenciaUpdate = entidadeComValoresFinais.Parse <Ocorrencia>(context.OrganizationName, context.IsExecutingOffline, adminService);
var ocorrenciaServiceUpdate = new OcorrenciaService(context.OrganizationName, context.IsExecutingOffline);
if (ocorrenciaUpdate.LinhaDeContratoId != null)
{
RepositoryService repository = new Domain.Servicos.RepositoryService(context.OrganizationName, context.IsExecutingOffline);
var linhaDeContrato = repository.LinhaDoContrato.Retrieve(ocorrenciaUpdate.LinhaDeContratoId.Id);
if (linhaDeContrato != null && linhaDeContrato.TipoDeOcorrencia == (int)Domain.Enum.TipoDeOcorrencia.Instalacao && linhaDeContrato.LimiteOcorrencias > 0)
{
var listOcorrencias = ocorrenciaServiceUpdate.ListarOcorrenciasPorLinhaDoContrato(ocorrenciaUpdate.LinhaDeContratoId.Id);
if (listOcorrencias.Count >= linhaDeContrato.LimiteOcorrencias)
{
var flag = true;
foreach (var ocorrencia in listOcorrencias)
{
if (ocorrencia.Id.Equals(ocorrenciaUpdate.Id))
{
flag = false;
break;
}
}
if (flag)
{
throw new ArgumentException("Erro ao atualizar Ocorrência. Limite de instalações atingido.");
}
}
}
}
ocorrenciaServiceUpdate.Ocorrencia = ocorrenciaUpdate;
ocorrenciaServiceUpdate.Atualizar();
if (parameterUpdate.Attributes.Contains("statuscode"))
{
ocorrenciaServiceUpdate.AtualizarValorDoServicoASTEC();
}
AtualizaCampos(ref parameterUpdate, ocorrenciaServiceUpdate.Ocorrencia);
break;
#endregion
#region SetState
case Domain.Enum.Plugin.MessageName.SetStateDynamicEntity:
var state = (OptionSetValue)context.InputParameters["State"];
var status = (OptionSetValue)context.InputParameters["Status"];
var parameter = context.GetContextEntity("imagem");
Ocorrencia ocorrenciaSetState = parameter.Parse <Ocorrencia>(context.OrganizationName, context.IsExecutingOffline, adminService);
ocorrenciaSetState.Status = state.Value;
if (status.Value == 200040)
{
ocorrenciaSetState.StatusDaOcorrencia = Domain.Enum.StatusDaOcorrencia.Auditoria;
ocorrenciaSetState.RazaoStatus = status.Value;
var ocorrenciaServiceSetState = new OcorrenciaService(context.OrganizationName, context.IsExecutingOffline);
ocorrenciaServiceSetState.Ocorrencia = ocorrenciaSetState;
if (context.InputParameters.Contains("Status"))
{
ocorrenciaServiceSetState.AtualizarValorDoServicoASTEC();
new RepositoryService(context.OrganizationName, context.IsExecutingOffline, adminService).Ocorrencia.Update(ocorrenciaServiceSetState.Ocorrencia);
}
}
break;
#endregion
}
}
catch (Exception ex)
{
throw new InvalidPluginExecutionException(ex.Message);
}
}
private static void Executar()
{
bool reaberta = false;
//Cria pasta de armazenamento de log caso não exista.
if (!Directory.Exists(Settings.Default.Log))
{
Directory.CreateDirectory(Settings.Default.Log);
}
//Cria o arquivo de log da execução
if (Settings.Default.HabilitarLog)
{
ostrm = new FileStream(Settings.Default.Log + @"\Log_" + DateTime.Now.ToString("yyyy-MM-dd-HH.mm") + ".txt", FileMode.OpenOrCreate, FileAccess.Write);
writer = new StreamWriter(ostrm);
oldOut = Console.Out;
Console.SetOut(writer);
}
Console.WriteLine("******************************************************************************");
Console.WriteLine(" Serviço - Integração Chat x CRM");
Console.WriteLine("******************************************************************************");
Console.WriteLine();
try
{
foreach (var item in ListaAtendimentosFinalizados())
{
List <Ocorrencia> lstOcorrencias = new List <Ocorrencia>();
try
{
lstOcorrencias = new OcorrenciaService(OrganizationName, IsOffline).BuscarOcorrenciaPorProtocoloChat(item.protocolNumber);
if (lstOcorrencias.Count == 0)
{
Console.WriteLine("--Atendimento nº " + item.protocolNumber + " não foi encontrado no CRM!");
}
}
catch (Exception e)
{
Console.WriteLine("--Erro ao buscar no CRM o nº " + item.protocolNumber + ", " + e.Message);
}
//Registra os dados da ocorrencia
foreach (var ocorrencia in lstOcorrencias)
{
bool ocorrenciaEstavaFechada = (ocorrencia.Status.Value == 1 || ocorrencia.Status.Value == 2); // Cancelada ou Resolvida
if (ocorrenciaEstavaFechada)
{
(new CRM2013.Domain.Servicos.RepositoryService()).Ocorrencia.ReabrirOcorrencia(ocorrencia);
ocorrencia.RazaoStatus = (int)StatusDaOcorrencia.Aberta;
ocorrencia.ManterAberto = true;
reaberta = true;
ocorrencia.Atualizar();
}
Console.WriteLine("> Ocorrência nº " + ocorrencia.Numero + " encontrada, atendimento nº " + item.protocolNumber);
ocorrencia.OrigemChat = item.origin;
ocorrencia.DataEntradaChat = Util.Utilitario.ConverterEmData(item.onSystemDate);
ocorrencia.DataInicioAtendimento = Util.Utilitario.ConverterEmData(item.contactStartedDate);
ocorrencia.DataFinalAtendimento = Util.Utilitario.ConverterEmData(item.contactFinishedDate);
ocorrencia.StatusAtendimentoChat = item.contactState;
ocorrencia.TempoNaFilaChat = item.customerInQueueTime;
ocorrencia.TempoAtendimentoAtivo = item.agentServingTime;
ocorrencia.DuracaoAtendimento = item.contactTotalTime;
foreach (var formulario in item.formAnswers)
{
ocorrencia.FormularioAtendimento = "Questão: " + formulario.question + "\n" + "Resposta:" + formulario.answer + "\n";
}
foreach (var nota in item.ratings)
{
ocorrencia.NotaPesquisa = Convert.ToInt32(nota.answer);
}
if (Settings.Default.HabilitarLog == false)
{
Console.WriteLine("** Atualizando Ocorrencia **");
}
if (reaberta == true) // Entrou no if de cancelada e resolvida
{
ocorrencia.ManterAberto = false;
reaberta = false;
ocorrencia.Atualizar();
}
//Antes de resolver a ocorrência, precisa preencher a resolução
SolucaoOcorrencia solucaoOcorrencia = new SolucaoOcorrencia(OrganizationName, IsOffline)
{
DataHoraConclusao = DateTime.Now,
Nome = "Rotina Histórico do chat",
OcorrenciaId = ocorrencia.Id
};
//Fecha a ocorrência, caso ela já estivesse fechada.
if (ocorrenciaEstavaFechada)
{
(new CRM2013.Domain.Servicos.RepositoryService()).Ocorrencia.FecharOcorrencia(ocorrencia, solucaoOcorrencia);
}
if (Settings.Default.HabilitarLog == false)
{
Console.WriteLine("** Gravando Data do Atendimento **");
}
if (Settings.Default.HabilitarLog == false)
{
Console.WriteLine("** Registrando Conversa no CRM **");
}
try
{
RegistrarConversaCRM(item.protocolNumber, ocorrencia);
}
catch (System.Exception e)
{
Console.WriteLine("--Atendimento nº " + item.protocolNumber + " não foi possivel atualizar atendimento, " + e.Message + "!");
}
}
GravaDataAtendimento(Util.Utilitario.ConverterEmData(item.onSystemDate).ToString());
}
}
//Entra no catch caso encontre alguma inconsistência na execução de atualização de informações da ocorrencia
catch (Exception ex)
{
SDKore.Helper.Error.Create("AtualizarAtendimentoChat: " + ex.Message, System.Diagnostics.EventLogEntryType.Error);
Console.WriteLine("Erro a executar a aplicação");
Console.WriteLine(ex.Message);
}
finally
{
Console.WriteLine();
Console.WriteLine("******************************************************************************");
Console.WriteLine(" Fim da execução");
if (Settings.Default.HabilitarLog)
{
Console.SetOut(oldOut);
writer.Close();
ostrm.Close();
}
}
}
public void Execute(IServiceProvider serviceProvider)
{
var context = (IPluginExecutionContext)serviceProvider.GetService(typeof(IPluginExecutionContext));
ITracingService trace = (ITracingService)serviceProvider.GetService(typeof(ITracingService));
IOrganizationServiceFactory serviceFactory = (IOrganizationServiceFactory)serviceProvider.GetService(typeof(IOrganizationServiceFactory));
IOrganizationService service = serviceFactory.CreateOrganizationService(null);
try
{
switch (Util.Utilitario.ConverterEnum <Domain.Enum.Plugin.MessageName>(context.MessageName))
{
case Domain.Enum.Plugin.MessageName.Create:
if (context.InputParameters.Contains("Target") && context.InputParameters["Target"] is Entity)
{
var entidade = (Entity)context.InputParameters["Target"];
Domain.Model.Diagnostico diagnosticoCreate = entidade.Parse <Domain.Model.Diagnostico>(context.OrganizationName, context.IsExecutingOffline, service);
OcorrenciaService ocorrenciaService = new OcorrenciaService(context.OrganizationName, context.IsExecutingOffline, service);
ocorrenciaService.Ocorrencia = new Domain.Servicos.RepositoryService(context.OrganizationName, context.IsExecutingOffline, service).Ocorrencia.Retrieve(diagnosticoCreate.OcorrenciaId.Id);
ocorrenciaService.AlterarStatusDaOcorrenciaParaOMenorStatusDosDiagnosticosRelacionados();
//this.VerificaIntervencao(diagnosticoCreate, context, service);
}
break;
case Domain.Enum.Plugin.MessageName.Update:
if (context.PostEntityImages.Contains("imagem") && context.PostEntityImages["imagem"] is Entity)
{
var entidade = context.PostEntityImages["imagem"];
Domain.Model.Diagnostico diagnosticoUpdate = entidade.Parse <Domain.Model.Diagnostico>(context.OrganizationName, context.IsExecutingOffline, service);
OcorrenciaService ocorrenciaService = new OcorrenciaService(context.OrganizationName, context.IsExecutingOffline, service);
ocorrenciaService.Ocorrencia = new Domain.Servicos.RepositoryService(context.OrganizationName, context.IsExecutingOffline, service).Ocorrencia.Retrieve(diagnosticoUpdate.OcorrenciaId.Id);
ocorrenciaService.AlterarStatusDaOcorrenciaParaOMenorStatusDosDiagnosticosRelacionados();
//this.VerificaIntervencao(diagnosticoUpdate, context, service);
}
break;
case Domain.Enum.Plugin.MessageName.Delete:
if (context.PreEntityImages.Contains("imagem") && context.PreEntityImages["imagem"] is Entity)
{
var entidade = context.PreEntityImages["imagem"];
Domain.Model.Diagnostico diagnosticoUpdate = entidade.Parse <Domain.Model.Diagnostico>(context.OrganizationName, context.IsExecutingOffline, service);
OcorrenciaService ocorrenciaService = new OcorrenciaService(context.OrganizationName, context.IsExecutingOffline, service);
ocorrenciaService.Ocorrencia = new Domain.Servicos.RepositoryService(context.OrganizationName, context.IsExecutingOffline, service).Ocorrencia.Retrieve(diagnosticoUpdate.OcorrenciaId.Id);
ocorrenciaService.AlterarStatusDaOcorrenciaParaOMenorStatusDosDiagnosticosRelacionados();
}
break;
case Domain.Enum.Plugin.MessageName.SetStateDynamicEntity:
if (context.PostEntityImages.Contains("imagem") && context.PostEntityImages["imagem"] is Entity)
{
var entidade = context.PostEntityImages["imagem"];
Domain.Model.Diagnostico diagnosticoUpdate = entidade.Parse <Domain.Model.Diagnostico>(context.OrganizationName, context.IsExecutingOffline, service);
Diagnostico diagnostico = new Domain.Servicos.RepositoryService(context.OrganizationName, context.IsExecutingOffline, service).Diagnostico.Retrieve(diagnosticoUpdate.Id);
OcorrenciaService ocorrenciaService = new OcorrenciaService(context.OrganizationName, context.IsExecutingOffline, service);
ocorrenciaService.Ocorrencia = new Domain.Servicos.RepositoryService(context.OrganizationName, context.IsExecutingOffline, service).Ocorrencia.Retrieve(diagnostico.OcorrenciaId.Id);
ocorrenciaService.AlterarStatusDaOcorrenciaParaOMenorStatusDosDiagnosticosRelacionados();
}
break;
}
}
catch (Exception ex)
{
trace.Trace(String.Format("EXCEPTION PLUGIN {0} {1} [{2}]", context.MessageName.ToLower(), "new_diagnostico_ocorrencia", DateTime.Now));
trace.Trace(SDKore.Helper.Error.GetMessageError(ex));
throw new InvalidPluginExecutionException(ex.Message);
}
}
public ActionResult Details(int id)
{
_usuarioTO = (UsuarioTO)Session["UsuarioTO"];
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (_usuarioTO != null)
{
_usuarioTO = (UsuarioTO)Session["UsuarioTO"];
if (!_usuarioTO.Valido)
{
return(RedirectToActionPermanent("Login", "Home"));
}
}
else if (_moradorTO != null)
{
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (_moradorTO != null)
{
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (!_moradorTO.Valido)
{
return(RedirectToActionPermanent("Login", "Home"));
}
}
}
else
{
return(RedirectToActionPermanent("Login", "Home"));
}
if (Session["UsuarioTO"] != null)
{
_usuarioTO = (UsuarioTO)Session["UsuarioTO"];
if (!_usuarioTO.Valido)
{
return(RedirectToActionPermanent("Login", "Home"));
}
}
else if (Session["MoradorTO"] != null)
{
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (!_moradorTO.Valido)
{
return(RedirectToActionPermanent("Login", "Home"));
}
}
OcorrenciaTO OcorrenciaTO = new OcorrenciaTO();
try
{
OcorrenciaTO = OcorrenciaService.Obter(id);
if (!OcorrenciaTO.Valido)
{
Session["Mensagem"] = OcorrenciaTO.Mensagem;
return(RedirectToActionPermanent("Index"));
}
var OcorrenciaVM = Mapper.Map <OcorrenciaTO, OcorrenciaVM>(OcorrenciaTO);
NomearVariaveis(OcorrenciaVM, null);
return(View(OcorrenciaVM));
}
catch (Exception ex)
{
OcorrenciaTO.Mensagem = $"Erro ao obter Ocorrencia. Erro: {ex.Message}";
}
return(View());
}
public ActionResult Delete(int id)
{
_usuarioTO = (UsuarioTO)Session["UsuarioTO"];
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (_usuarioTO != null)
{
_usuarioTO = (UsuarioTO)Session["UsuarioTO"];
if (!_usuarioTO.Valido)
{
return(RedirectToActionPermanent("Login", "Home"));
}
}
else if (_moradorTO != null)
{
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (_moradorTO != null)
{
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (!_moradorTO.Valido)
{
return(RedirectToActionPermanent("Login", "Home"));
}
}
}
else
{
return(RedirectToActionPermanent("Login", "Home"));
}
if (Session["UsuarioTO"] != null)
{
_usuarioTO = (UsuarioTO)Session["UsuarioTO"];
if (!_usuarioTO.Valido)
{
return(RedirectToActionPermanent("Login", "Home"));
}
}
else if (Session["MoradorTO"] != null)
{
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (!_moradorTO.Valido)
{
return(RedirectToActionPermanent("Login", "Home"));
}
}
if (id > 0)
{
var OcorrenciaTO = OcorrenciaService.Obter(id);
var OcorrenciaVM = Mapper.Map <OcorrenciaTO, OcorrenciaVM>(OcorrenciaTO);
NomearVariaveis(OcorrenciaVM, null);
return(View(OcorrenciaVM));
}
else
{
return(RedirectToAction("Index"));
}
}
private void CarregarDados()
{
ListaMoradorTO listaMoradoresTO = new ListaMoradorTO();
listaMoradoresTO = MoradorService.Listar();
dgMoradores.DataSource = listaMoradoresTO.Lista;
dgMoradores.Columns["Identificador"].Visible = false;
dgMoradores.Columns["Valido"].Visible = false;
dgMoradores.Columns["Mensagem"].Visible = false;
dgMoradores.ReadOnly = true;
ListaContratoTO listaContratosTO = new ListaContratoTO();
listaContratosTO = ContratoService.Listar();
dgContratos.DataSource = listaContratosTO.Lista;
dgContratos.Columns["Identificador"].Visible = false;
dgContratos.Columns["Valido"].Visible = false;
dgContratos.Columns["Mensagem"].Visible = false;
dgContratos.ReadOnly = true;
ListaDependenteTO listaDependentesTO = new ListaDependenteTO();
listaDependentesTO = DependenteService.Listar();
dgDependentes.DataSource = listaDependentesTO.Lista;
dgDependentes.Columns["Identificador"].Visible = false;
dgDependentes.Columns["Valido"].Visible = false;
dgDependentes.Columns["Mensagem"].Visible = false;
dgDependentes.ReadOnly = true;
ListaEstacionamentoTO listaEstacionamentosTO = new ListaEstacionamentoTO();
listaEstacionamentosTO = EstacionamentoService.Listar();
ListaOcorrenciaTO listaOcorrenciasTO = new ListaOcorrenciaTO();
listaOcorrenciasTO = OcorrenciaService.Listar();
dgAdmOcorrencias.DataSource = listaOcorrenciasTO.Lista;
dgAdmOcorrencias.Columns["Identificador"].Visible = false;
dgAdmOcorrencias.Columns["Valido"].Visible = false;
dgAdmOcorrencias.Columns["Mensagem"].Visible = false;
dgAdmOcorrencias.ReadOnly = true;
ListaReservaTO listaReservasTO = new ListaReservaTO();
listaReservasTO = ReservaService.Listar();
dgReservas.DataSource = listaReservasTO.Lista;
dgReservas.Columns["Identificador"].Visible = false;
dgReservas.Columns["Valido"].Visible = false;
dgReservas.Columns["Mensagem"].Visible = false;
dgReservas.ReadOnly = true;
ListaAdvertenciaTO listaAdvertenciasTO = new ListaAdvertenciaTO();
listaAdvertenciasTO = AdvertenciaService.Listar();
}
public ActionResult Edit(int id)
{
_usuarioTO = (UsuarioTO)Session["UsuarioTO"];
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (_usuarioTO != null)
{
_usuarioTO = (UsuarioTO)Session["UsuarioTO"];
if (!_usuarioTO.Valido)
{
return(RedirectToActionPermanent("Login", "Home"));
}
}
else if (_moradorTO != null)
{
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (_moradorTO != null)
{
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (!_moradorTO.Valido)
{
return(RedirectToActionPermanent("Login", "Home"));
}
}
}
else
{
return(RedirectToActionPermanent("Login", "Home"));
}
if (Session["UsuarioTO"] != null)
{
_usuarioTO = (UsuarioTO)Session["UsuarioTO"];
if (!_usuarioTO.Valido)
{
return(RedirectToActionPermanent("Login", "Home"));
}
}
else if (Session["MoradorTO"] != null)
{
_moradorTO = (MoradorTO)Session["MoradorTO"];
if (!_moradorTO.Valido)
{
return(RedirectToActionPermanent("Login", "Home"));
}
}
ViewBag.Morador = ListarMoradores();
if (ModelState.IsValid)
{
var OcorrenciaTO = OcorrenciaService.Obter(id);
if (!OcorrenciaTO.Valido)
{
Session["Mensagem"] = OcorrenciaTO.Mensagem;
return(RedirectToAction("Index"));
}
var OcorrenciaVM = Mapper.Map <OcorrenciaTO, OcorrenciaVM>(OcorrenciaTO);
NomearVariaveis(OcorrenciaVM, null);
return(View(OcorrenciaVM));
}
return(RedirectToAction("Index"));
}
protected override void Execute(IPluginExecutionContext context, IOrganizationServiceFactory serviceFactory, IOrganizationService adminService, IOrganizationService userService)
{
IOrganizationService service = serviceFactory.CreateOrganizationService(null);
try
{
switch (context.GetMessageName())
{
case PluginBase.MessageName.Create:
if (context.PostEntityImages.Contains("imagem") && context.PostEntityImages["imagem"] is Entity)
{
var entidade = context.PostEntityImages["imagem"];
Ocorrencia ocorrencia = entidade.Parse <Ocorrencia>(context.OrganizationName, context.IsExecutingOffline, adminService);
//Verifica se tem intervenção técnica
var e = context.GetContextEntity();
Ocorrencia ocorrenciacreate = (new Domain.Servicos.RepositoryService(context.OrganizationName, false, service)).Ocorrencia.Retrieve(e.Id);
VerificaIntervencao(ocorrenciacreate, context, service);
VerificaDataDeIntalacao(ocorrenciacreate, context, service);
if (ocorrencia.IntegraAstec == (int)IntegrarASTEC.Sim)
{
string lstResposta = new Domain.Servicos.OcorrenciaService(context.OrganizationName, context.IsExecutingOffline, service).IntegracaoBarramento(ocorrencia);
}
if (ocorrencia.RazaoStatus.Value != (int)StatusDaOcorrencia.Fechada)
{
return;
}
var ocorrenciaService = new OcorrenciaService(context.OrganizationName, context.IsExecutingOffline);
ocorrenciaService.Ocorrencia = ocorrencia;
Areas area = ocorrenciaService.IdentificarAreaDeAtendimento();
if (area == Areas.ISOL)
{
ocorrenciaService.AtualizarVigenciaContrato();
}
}
break;
case PluginBase.MessageName.Update:
if (context.PostEntityImages.Contains("imagem") && context.PostEntityImages["imagem"] is Entity)
{
var entidade = context.PostEntityImages["imagem"];
Ocorrencia ocorrencia = entidade.Parse <Ocorrencia>(context.OrganizationName, context.IsExecutingOffline, adminService);
//Verifica se tem intervenção técnica
var eupdate = context.GetContextEntity();
Ocorrencia ocorrenciaupdate = (new Domain.Servicos.RepositoryService(context.OrganizationName, false, service)).Ocorrencia.Retrieve(eupdate.Id);
VerificaIntervencao(ocorrenciaupdate, context, service);
VerificaDataDeIntalacao(ocorrenciaupdate, context, service);
if (ocorrencia.IntegraAstec == (int)IntegrarASTEC.Sim)
{
string lstResposta = new Domain.Servicos.OcorrenciaService(context.OrganizationName, context.IsExecutingOffline, service).IntegracaoBarramento(ocorrencia);
}
Ocorrencia entidadePre = ((Entity)context.PreEntityImages["imagem"]).Parse <Ocorrencia>(context.OrganizationName, context.IsExecutingOffline, adminService);
if (ocorrencia.EmpresaExecutanteId == null && entidadePre.EmpresaExecutanteId != null)
{
ocorrencia.AtualizarOperacoesSuporte = true;
ocorrencia.Atualizar();
}
if (ocorrencia.RazaoStatus.Value != (int)StatusDaOcorrencia.Fechada)
{
return;
}
var ocorrenciaService = new OcorrenciaService(context.OrganizationName, context.IsExecutingOffline);
ocorrenciaService.Ocorrencia = ocorrencia;
Areas area = ocorrenciaService.IdentificarAreaDeAtendimento();
if (area == Areas.ISOL)
{
ocorrenciaService.AtualizarVigenciaContrato();
}
}
break;
}
}
catch (Exception ex)
{
throw new InvalidPluginExecutionException(ex.Message);
}
}
