/// <summary> /// consulta si se encuentra registrada una alerta con una descripcion y modulo especificos /// </summary> /// <param name="alerta">descripcion y modulo de la alerta que se verificara existencia</param> /// <returns>Regresa true si existe la alerta proporcionada</returns> internal bool AlertaExiste(AlertaInfo alerta) { try { Logger.Info(); var parameters = AuxAlertaDAL.ObtenerParametrosAlertaValida(alerta); var result = RetrieveValue <int>("Alertas_AlertaValida", parameters); return(result == 1); } catch (SqlException ex) { Logger.Error(ex); throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex); } catch (DataException ex) { Logger.Error(ex); throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex); } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } }
/// <summary> /// Metodo para Guardar/Modificar una alerta /// </summary> /// <param name="info">Representa la entidad que se va a grabar</param> internal static int GuardarCambios(AlertaInfo info) { try { Logger.Info(); var alertaDAL = new AlertaDAL(); int result = info.AlertaID; if (info.AlertaID == 0)//si es un registro nuevo se manda guardar { result = alertaDAL.Crear(info); } else { alertaDAL.Actualizar(info);//si es una edicion se manda modificar } return(result); } catch (ExcepcionGenerica) { throw; } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } }
/// <summary> /// Obtiene un lista paginada /// </summary> /// <param name="pagina">informacion de paginacion que se usara para la consulta</param> /// <param name="filtro">filtros de busqueda para la busqueda</param> /// <returns>Regresa una lista de alertas que concuerden con los filtros de busqueda proporcionados</returns> internal ResultadoInfo <AlertaInfo> ObtenerPorPagina(PaginacionInfo pagina, AlertaInfo filtro) { try { Dictionary <string, object> parameters = AuxAlertaDAL.ObtenerParametrosPorPagina(pagina, filtro); DataSet ds = Retrieve("Alerta_ObtenerPorPagina", parameters); ResultadoInfo <AlertaInfo> result; if (ValidateDataSet(ds)) { result = MapAlertaDAL.ObtenerPorPagina(ds); } else { result = new ResultadoInfo <AlertaInfo>(); result.Lista = new List <AlertaInfo>(); } return(result); } catch (SqlException ex) { Logger.Error(ex); throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex); } catch (DataException ex) { Logger.Error(ex); throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex); } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } }
/// <summary> /// Inicializa la alerta que se enlazara a la interfaz /// </summary> private void InicializaContexto() { if (operacion == Operation.Registrar) { Contexto = new AlertaInfo { UsuarioCreacionID = AuxConfiguracion.ObtenerUsuarioLogueado(), TerminadoAutomatico = EstatusEnum.Inactivo, Modulo = new ModuloInfo { ModuloID = 0 } }; ContextoSinEditar = new AlertaInfo(); } else { Contexto = new AlertaInfo { UsuarioModificacionID = AuxConfiguracion.ObtenerUsuarioLogueado(), Modulo = new ModuloInfo { ModuloID = 0 } }; } }
/// <summary> /// Metodo para Crear un registro de Alerta /// </summary> /// <param name="info">Valores de la entidad que será creada</param> internal int Crear(AlertaInfo info) { try { Logger.Info(); Dictionary <string, object> parameters = AuxAlertaDAL.ObtenerParametrosCrear(info); int result = Create("Alerta_Crear", parameters); return(result); } catch (SqlException ex) { Logger.Error(ex); throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex); } catch (DataException ex) { Logger.Error(ex); throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex); } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } }
/// <summary> /// obtiene una alerta por medio de su ID /// </summary> /// <param name="idAlerta"></param> /// <returns>regresa el folio consultado</returns> internal AlertaInfo ObtenerAlertaPorId(long idAlerta) { AlertaInfo result = null; try { Logger.Info(); Dictionary <string, object> parameters = AuxConfiguracionAlertasDAL.ConsultaAlerta(idAlerta); DataSet ds = Retrieve("ConfiguracionAlerta_ObtenerAlertaPorID", parameters); if (ValidateDataSet(ds)) { result = MapConfiguracionAlertasDAL.ObtenerAlertaPorId(ds); } } catch (SqlException ex) { Logger.Error(ex); throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex); } catch (DataException ex) { Logger.Error(ex); throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex); } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } return(result); }
///<summary> /// Metodo para limpiar los campos despues de un registro /// </summary> private void LimpiarCampos() { InicializaContexto(); accionesDgAux.Clear(); gridDatos.ItemsSource = null; var accion = new AccionInfo { AccionID = 0, Descripcion = Properties.Resources.cbo_Seleccione, }; cmbAcciones.SelectedItem = accion; var alerta = new AlertaInfo { AlertaID = 0, Descripcion = Properties.Resources.cbo_Seleccione, }; cmbAlerta.SelectedItem = alerta; var nivelAlerta = new NivelAlertaInfo { NivelAlertaId = 0, Descripcion = Properties.Resources.cbo_Seleccione, }; cmbNivelAlerta.SelectedItem = nivelAlerta; }
/// <summary> /// Metodo para cargar el comboBox de Alertas /// </summary> private void ConsultarAlertas() { try { var configAlertasPL = new ConfiguracionAlertasPL(); var alerta = new AlertaInfo { AlertaID = 0, Descripcion = Properties.Resources.cbo_Seleccione, }; IList <AlertaInfo> alertasActivasCB = configAlertasPL.ObtenerTodasLasAlertasActivas(); alertasActivasCB.Insert(0, alerta); cmbAlerta.ItemsSource = alertasActivasCB; cmbAlerta.SelectedItem = alerta; cmbAlerta.SelectedIndex = 0; if (Contexto.AlertaInfo.Descripcion == null || Contexto.AlertaInfo.AlertaID == 0) { Contexto.AlertaInfo = alerta; } } catch (Exception ex) { Logger.Error(ex); SkMessageBox.Show(this, Properties.Resources.ConfiguracionAlerta_ErrorConsultarTodasLasAlertasActivas, MessageBoxButton.OK, MessageImage.Error); } }
/// <summary> /// valida si la ya hay una alerta registrada al modulo especificado /// </summary> /// <param name="filtro">alerta cuya descripcion y modulo asignado se validaran</param> /// <returns></returns> private bool ExisteAlerta(AlertaInfo filtro) { try { if (filtro.Modulo.ModuloID == ContextoSinEditar.Modulo.ModuloID && filtro.Descripcion == ContextoSinEditar.Descripcion)//si el registro no se modifico en el modulo ni descripcion { return(false); } var filtrosAlertas = (AlertaInfo)Extensor.ClonarInfo(filtro); bool result = AlertaPL.ExisteAlerta(filtrosAlertas); return(result); //regresa true si se encontro la alerta } catch (ExcepcionGenerica) { SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.Alerta_ErrorBuscar, MessageBoxButton.OK, MessageImage.Error); return(false); } catch (Exception ex) { Logger.Error(ex); SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.Alerta_ErrorBuscar, MessageBoxButton.OK, MessageImage.Error); return(false); } }
private void btnCadastrar_Click(object sender, EventArgs e) { IServicoAlertas servicoAlerta = Ativador.Get <IServicoAlertas>(); AlertaInfo alerta = new AlertaInfo(); alerta.IdAlerta = "0"; alerta.IdCliente = txtIdCliente.Text; alerta.Instrumento = txtInstrumento.Text; if (radbtnPreco.Checked) { alerta.TipoOperando = Operando.Preco; } else if (radbtnOscilacao.Checked) { alerta.TipoOperando = Operando.Oscilacao; } else if (radbtnMaximo.Checked) { alerta.TipoOperando = Operando.Maximo; } else if (radbtnMinimo.Checked) { alerta.TipoOperando = Operando.Minimo; } if (radbtnMenorIgual.Checked) { alerta.TipoOperador = Operador.MenorIgual; } else if (radbtnMaiorIgual.Checked) { alerta.TipoOperador = Operador.MaiorIgual; } else if (radbtnAlcancado.Checked) { alerta.TipoOperador = Operador.Atingido; } alerta.Valor = Convert.ToDecimal(txtValor.Text); CadastrarAlertaRequest reqCadastrarAlerta = new CadastrarAlertaRequest(); reqCadastrarAlerta.Alerta = alerta; CadastrarAlertaResponse respCadastrarAlerta = servicoAlerta.CadastrarAlerta(reqCadastrarAlerta); if (respCadastrarAlerta.StatusResposta == Gradual.OMS.Library.MensagemResponseStatusEnum.OK) { txtIdAlerta.Text = respCadastrarAlerta.IdAlerta; } else { txtIdAlerta.Text = "Cadastro Não OK. Desc=[" + respCadastrarAlerta.DescricaoErro + "]"; } disableNewAlertaTxts(); }
public AlertaEdicion(AlertaInfo alertaInfo) { InitializeComponent(); CargaComboModulos(); ContextoSinEditar = (AlertaInfo)Extensor.ClonarInfo(alertaInfo); Contexto = alertaInfo; //la ventana recibe la alerta que se editara Contexto.UsuarioCreacionID = 0; //si la operacion es edicion se borra el parametro de id del usuario que lo registra Contexto.UsuarioModificacionID = AuxConfiguracion.ObtenerUsuarioLogueado(); //el registro que se editara recibira este valor para registrarlo como el usuario que edito dicho registro operacion = Operation.Editar; }
/// <summary> /// valida si ya se encuentra registrada una alerta con una descripcion y modulo especificos /// </summary> /// <param name="info">descripcion y modulo de la alerta que se verificara existencia</param> /// <returns>Regresa true si existe la alerta proporcionada</returns> public static bool ExisteAlerta(AlertaInfo info) { try { Logger.Info(); //var alertaBL = new AlertaBL(); bool result = AlertaBL.ExisteAlerta(info); return(result); } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } }
/// <summary> /// valida si ya se encuentra registrada la alerta en el modulo especificado /// </summary> /// <param name="filtro">descripcion y modulo de la alerta que se verificara existencia</param> /// <returns>regresa true si una alerta con esa descripcion ya esta registrada</returns> internal static bool ExisteAlerta(AlertaInfo filtro) { try { Logger.Info(); var alertaDAL = new AlertaDAL(); bool result = alertaDAL.AlertaExiste(filtro); return(result);//regresa true si una alerta con esa descripcion ya esta registrada } catch (Exception ex) { Logger.Error(ex); return(false); } }
public Alertas.Lib.Mensagens.VerificarAlertasResponse VerificarAlertas(Alertas.Lib.Mensagens.VerificarAlertasRequest request) { VerificarAlertasResponse response = new VerificarAlertasResponse(); if (ConfigurationManager.AppSettings["DebugVerificacaoAlertas"] != null && ConfigurationManager.AppSettings["DebugVerificacaoAlertas"].ToString().Equals("true")) { logger.Debug("VerificarAlertas: IdCliente=[" + request.IdCliente + "]"); } List <AlertaInfo> listaAlertasResponse = new List <AlertaInfo>(); Dictionary <String, DadosAlerta> listaAlertas = gerenciadorAlertas.VerificarAlertas(request.IdCliente); foreach (KeyValuePair <string, DadosAlerta> kvAlerta in listaAlertas) { if (kvAlerta.Value.IdCliente.Equals(request.IdCliente) && kvAlerta.Value.Atingido == true && kvAlerta.Value.Exibido == false) { AlertaInfo respAlertaInfo = new AlertaInfo(); respAlertaInfo.IdAlerta = kvAlerta.Key; respAlertaInfo.IdCliente = kvAlerta.Value.IdCliente; respAlertaInfo.Instrumento = kvAlerta.Value.Instrumento; respAlertaInfo.TipoOperador = kvAlerta.Value.TipoOperador; respAlertaInfo.TipoOperando = kvAlerta.Value.TipoOperando; respAlertaInfo.Valor = kvAlerta.Value.Valor; respAlertaInfo.Atingido = kvAlerta.Value.Atingido; respAlertaInfo.Exibido = kvAlerta.Value.Exibido; respAlertaInfo.DataCadastro = kvAlerta.Value.DataCadastro; respAlertaInfo.DataAtingimento = kvAlerta.Value.DataAtingimento; respAlertaInfo.Cotacao = kvAlerta.Value.Cotacao; listaAlertasResponse.Add(respAlertaInfo); } } if (ConfigurationManager.AppSettings["DebugVerificacaoAlertas"] != null && ConfigurationManager.AppSettings["DebugVerificacaoAlertas"].ToString().Equals("true")) { logger.Debug("VerificarAlertas: IdCliente=[" + request.IdCliente + "] " + listaAlertasResponse.Count + " disparados"); } response.Alertas = listaAlertasResponse; return(response); }
///<summary> /// Metodo que valida que una alerta no tenga una configuracion /// </summary> private void ValidarAlertaRegistrada(ConfiguracionAlertasGeneraInfo filtros) { var configAlertaPl = new ConfiguracionAlertasPL(); AlertaInfo alertaInfo = filtros.AlertaInfo; AlertaInfo result = configAlertaPl.ObtenerAlertaPorId(alertaInfo); if (result != null && boolEditar == false) { SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.ConfiguracionAlerta_AlertaYaConfigurada, MessageBoxButton.OK, MessageImage.Error); } else { ValidarQuery(); } boolEditar = false; }
/// <summary> /// Confirma o valida si el usuario desea cerrar la ventana antes de proseguir /// </summary> /// <param name="e"></param> protected override void OnClosing(CancelEventArgs e) { if (Cancelar)//despliega el mensaje de confirmacion de cancelar el registro { MessageBoxResult result; if (operacion == Operation.Registrar) { result = SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.Msg_AlertaCancelarRegistro, MessageBoxButton.YesNo, MessageImage.Question); } else //si operacion es editar { result = SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.Msg_AlertaCancelarEdicion, MessageBoxButton.YesNo, MessageImage.Question); } if (result == MessageBoxResult.Yes) { Contexto = null; InitializeComponent(); } else { e.Cancel = true; } } if (ForzarCierre) { Contexto = null; InitializeComponent(); } if (confirmaSalir) { MessageBoxResult result = SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], Properties.Resources.Msg_CerrarSinGuardar, MessageBoxButton.YesNo, MessageImage.Question); if (result == MessageBoxResult.Yes) { Contexto = null; } else { e.Cancel = true; } } }
/// <summary> /// Metodo para Guardar/Modificar una alerta /// </summary> /// <param name="info">Representa la entidad que se va a grabar o actualizar</param> public static int Guardar(AlertaInfo info) { try { Logger.Info(); //var alertaBL = new AlertaBL(); int result = AlertaBL.GuardarCambios(info); return(result); } catch (ExcepcionGenerica) { throw; } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } }
/// <summary> /// Obtiene parametros para validar si ya esta registrada una alerta a un modulo /// </summary> /// <param name="filtro">alerta de donde se obtienen los valores para los parametros</param> /// <returns>Regresa una lista de parametros para consultar la existencia de una alerta con una descripcion y modulo proporcionados</returns> internal static Dictionary <string, object> ObtenerParametrosAlertaValida(AlertaInfo filtro) { try { Logger.Info(); var parametros = new Dictionary <string, object> { { "@Descripcion", string.IsNullOrWhiteSpace(filtro.Descripcion) ? string.Empty : filtro.Descripcion.Trim() }, { "@ModuloID", filtro.Modulo.ModuloID } }; return(parametros); } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } }
///<summary> /// Metodo que valida que una alerta no tenga una configuracion /// </summary> /// <returns>Regresa true si no esta configurada esta alerta para poder desactivarla</returns> private bool Validar_DesactivacionAlerta(int alertaId) { try { var configAlertaPl = new ConfiguracionAlertasPL(); AlertaInfo alerta = new AlertaInfo() { AlertaID = alertaId }; AlertaInfo alerta_result = configAlertaPl.ObtenerAlertaPorId(alerta); return(alerta_result == null); } catch (Exception ex) { Logger.Error(ex); SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal], ex.Message, MessageBoxButton.OK, MessageImage.Error); return(false); } }
/// <summary> /// metodo que obtiene por id una alerta /// </summary> /// <param name="idAlerta"></param> /// <returns>regresa el folio consultado</returns> public AlertaInfo ObtenerAlertaPorId(AlertaInfo idAlerta) { AlertaInfo info; try { Logger.Info(); var configAlertaBL = new ConfiguracionAlertasBL(); info = configAlertaBL.ObtenerAlertaPorId(Convert.ToInt64(idAlerta.AlertaID)); } catch (ExcepcionGenerica) { throw; } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } return(info); }
public Alertas.Lib.Mensagens.ListarAlertasResponse ListarAlertas(Alertas.Lib.Mensagens.ListarAlertasRequest request) { logger.Debug("ListarAlertas: IdCliente=[" + request.IdCliente + "]"); ListarAlertasResponse response = new ListarAlertasResponse(); List <AlertaInfo> listaAlertasResponse = new List <AlertaInfo>(); Dictionary <String, DadosAlerta> listaAlertas = gerenciadorAlertas.VerificarAlertas(request.IdCliente); foreach (KeyValuePair <string, DadosAlerta> kvAlerta in listaAlertas) { if (kvAlerta.Value.IdCliente.Equals(request.IdCliente)) { AlertaInfo respAlertaInfo = new AlertaInfo(); respAlertaInfo.IdAlerta = kvAlerta.Key; respAlertaInfo.IdCliente = kvAlerta.Value.IdCliente; respAlertaInfo.Instrumento = kvAlerta.Value.Instrumento; respAlertaInfo.TipoOperador = kvAlerta.Value.TipoOperador; respAlertaInfo.TipoOperando = kvAlerta.Value.TipoOperando; respAlertaInfo.Valor = kvAlerta.Value.Valor; respAlertaInfo.Atingido = kvAlerta.Value.Atingido; respAlertaInfo.Exibido = kvAlerta.Value.Exibido; respAlertaInfo.DataCadastro = kvAlerta.Value.DataCadastro; respAlertaInfo.DataAtingimento = kvAlerta.Value.DataAtingimento; listaAlertasResponse.Add(respAlertaInfo); } } logger.Debug("ListarAlertas: IdCliente=[" + request.IdCliente + "] com " + listaAlertas.Count + " itens"); response.Alertas = listaAlertasResponse; response.StatusResposta = Library.MensagemResponseStatusEnum.OK; return(response); }
public Lib.Mensagens.VerificarAlertasResponse VerificarAlertas( Lib.Mensagens.VerificarAlertasRequest request) { logger.Debug("VerificarAlertas iniciado"); VerificarAlertasResponse response = new VerificarAlertasResponse(); List <AlertaInfo> listaAlertasResponse = new List <AlertaInfo>(); Dictionary <String, DadosAlerta> listaAlertas = gerenciadorAlertas.VerificarAlertas(request.IdCliente); foreach (KeyValuePair <string, DadosAlerta> kvAlerta in listaAlertas) { if (kvAlerta.Value.IdCliente.Equals(request.IdCliente) && kvAlerta.Value.Atingido == true && kvAlerta.Value.Exibido == false) { AlertaInfo respAlertaInfo = new AlertaInfo(); respAlertaInfo.IdAlerta = kvAlerta.Key; respAlertaInfo.IdCliente = kvAlerta.Value.IdCliente; respAlertaInfo.Instrumento = kvAlerta.Value.Instrumento; respAlertaInfo.TipoOperador = kvAlerta.Value.TipoOperador; respAlertaInfo.TipoOperando = kvAlerta.Value.TipoOperando; respAlertaInfo.Valor = kvAlerta.Value.Valor; respAlertaInfo.Atingido = kvAlerta.Value.Atingido; respAlertaInfo.Exibido = kvAlerta.Value.Exibido; respAlertaInfo.DataCadastro = kvAlerta.Value.DataCadastro; respAlertaInfo.DataAtingimento = kvAlerta.Value.DataAtingimento; respAlertaInfo.Cotacao = kvAlerta.Value.Cotacao; listaAlertasResponse.Add(respAlertaInfo); } } response.Alertas = listaAlertasResponse; return(response); }
/// <summary> /// Obtiene parametros para registrar una alerta /// </summary> /// <param name="filtro">alerta de donde se obtienen los valores para los parametros</param> /// <returns>regresa una lista de parametros para guardar una alerta</returns> internal static Dictionary <string, object> ObtenerParametrosCrear(AlertaInfo filtro) { try { Logger.Info(); var parametros = new Dictionary <string, object> { { "@ModuloID", filtro.Modulo.ModuloID }, { "@Descripcion", string.IsNullOrWhiteSpace(filtro.Descripcion) ? string.Empty : filtro.Descripcion.Trim() }, { "@HorasRespuesta", filtro.HorasRespuesta }, { "@TerminadoAutomatico", filtro.TerminadoAutomatico }, { "@Activo", filtro.Activo }, { "@UsuarioCreacionID", filtro.UsuarioCreacionID } }; return(parametros); } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } }
/// <summary> /// Metodo para actualizar un registro de Alerta /// </summary> /// <param name="info">Valores de la entidad que se actualizarán</param> internal void Actualizar(AlertaInfo info) { try { Logger.Info(); Dictionary <string, object> parameters = AuxAlertaDAL.ObtenerParametrosActualizar(info); Update("Alerta_actualizar", parameters); } catch (SqlException ex) { Logger.Error(ex); throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex); } catch (DataException ex) { Logger.Error(ex); throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex); } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } }
/// <summary> /// Obtiene por paginado las alertas activas para la ayuda de configuracion alerta /// </summary> /// <param name="pagina"></param> /// <param name="filtro"></param> /// <returns>una lista de folios del dia</returns> internal ResultadoInfo <AlertaInfo> ObtenerPorPaginaFiltroAlertas(PaginacionInfo pagina, AlertaInfo filtro) { ResultadoInfo <AlertaInfo> lista = null; try { Dictionary <string, object> parameters = AuxConfiguracionAlertasDAL.ObtenerParametrosPorPaginaFiltroAlertas(pagina, filtro); DataSet ds = Retrieve("ConfiguracionAlertas_ObtenerAlertasPorPaginas", parameters); if (ValidateDataSet(ds)) { lista = MapConfiguracionAlertasDAL.ObtenerAlertaPorPaginaCompleto(ds); } } catch (System.Data.SqlClient.SqlException ex) { Logger.Error(ex); throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex); } catch (DataException ex) { Logger.Error(ex); throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex); } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } return(lista); }
/// <summary> /// Procese las incidencias para verificar el estado y fecha vencimiento /// </summary> internal void ProcesarIncicencias() { var incidenciaBl = new IncidenciasBL(); try { var listaIncidencias = new List <IncidenciasInfo>(); listaIncidencias = ObtenerIncidenciasActivas(); if (listaIncidencias != null) { listaIncidencias = listaIncidencias.Where(x => x.Estatus.EstatusId != Estatus.CerrarAler.GetHashCode()).ToList(); if (listaIncidencias.Any()) { foreach (var incidencia in listaIncidencias) { try { AlertaInfo alertaInfo = listaAlertaConfiguracion.FirstOrDefault( x => x.AlertaID == incidencia.Alerta.AlertaID); IncidenciasInfo incidenciaInfo; switch (incidencia.Estatus.EstatusId) { case (int)Estatus.NuevaAlert: case (int)Estatus.RechaAlert: //Cambiar estatus a vencidas if (incidencia.FechaVencimiento <= DateTime.Now && incidencia.Accion.AccionID == 0) { incidenciaInfo = new IncidenciasInfo { IncidenciasID = incidencia.IncidenciasID, Estatus = new EstatusInfo { EstatusId = Estatus.VenciAlert.GetHashCode() }, Alerta = new AlertaInfo { AlertaID = incidencia.Alerta.AlertaID, HorasRespuesta = incidencia.Alerta.HorasRespuesta }, Folio = incidencia.Folio, Fecha = incidencia.Fecha, Comentarios = null, UsuarioModificacionID = usuario.UsuarioID, IncidenciaSeguimiento = new IncidenciaSeguimientoInfo { EstatusAnterior = new EstatusInfo { EstatusId = incidencia.Estatus.EstatusId }, AccionAnterior = new AccionInfo { AccionID = incidencia.Accion.AccionID }, UsuarioResponsableAnterior = new UsuarioInfo { UsuarioID = incidencia.UsuarioResponsable.UsuarioID }, NivelAlertaAnterior = new NivelAlertaInfo { NivelAlertaId = incidencia.NivelAlerta.NivelAlertaId }, FechaVencimientoAnterior = incidencia.FechaVencimiento } }; incidenciaBl.IncidenciaVencida(incidenciaInfo); } //Cambiar estatus a registrada else if (incidencia.FechaVencimiento <= DateTime.Now && incidencia.Accion.AccionID > 0) { incidenciaInfo = new IncidenciasInfo { IncidenciasID = incidencia.IncidenciasID, Estatus = new EstatusInfo { EstatusId = Estatus.RegisAlert.GetHashCode() }, Alerta = new AlertaInfo { AlertaID = incidencia.Alerta.AlertaID, HorasRespuesta = incidencia.Alerta.HorasRespuesta }, Folio = incidencia.Folio, Fecha = incidencia.Fecha, Comentarios = null, UsuarioModificacionID = usuario.UsuarioID, IncidenciaSeguimiento = new IncidenciaSeguimientoInfo { EstatusAnterior = new EstatusInfo { EstatusId = incidencia.Estatus.EstatusId }, AccionAnterior = new AccionInfo { AccionID = incidencia.Accion.AccionID }, UsuarioResponsableAnterior = new UsuarioInfo { UsuarioID = incidencia.UsuarioResponsable.UsuarioID }, NivelAlertaAnterior = new NivelAlertaInfo { NivelAlertaId = incidencia.NivelAlerta.NivelAlertaId }, FechaVencimientoAnterior = incidencia.FechaVencimiento } }; incidenciaBl.RegistrarIncidencia(incidenciaInfo); } break; case (int)Estatus.VenciAlert: case (int)Estatus.RegisAlert: //Cambiar la incidencia a vencida if (incidencia.FechaVencimiento <= DateTime.Now) { incidenciaInfo = new IncidenciasInfo { IncidenciasID = incidencia.IncidenciasID, Estatus = new EstatusInfo { EstatusId = Estatus.VenciAlert.GetHashCode() }, Alerta = new AlertaInfo { AlertaID = incidencia.Alerta.AlertaID, HorasRespuesta = incidencia.Alerta.HorasRespuesta }, Folio = incidencia.Folio, Fecha = incidencia.Fecha, Comentarios = Properties.ResourceServices.Incidencia_Vencida, UsuarioModificacionID = usuario.UsuarioID, IncidenciaSeguimiento = new IncidenciaSeguimientoInfo { EstatusAnterior = new EstatusInfo { EstatusId = incidencia.Estatus.EstatusId }, AccionAnterior = new AccionInfo { AccionID = incidencia.Accion.AccionID }, UsuarioResponsableAnterior = new UsuarioInfo { UsuarioID = incidencia.UsuarioResponsable.UsuarioID }, NivelAlertaAnterior = new NivelAlertaInfo { NivelAlertaId = incidencia.NivelAlerta.NivelAlertaId }, FechaVencimientoAnterior = incidencia.FechaVencimiento } }; incidenciaBl.IncidenciaVencida(incidenciaInfo); } break; } } catch (ExcepcionDesconocida ex) { var bitacoraBL = new BitacoraIncidenciasBL(); var bitacora = new BitacoraIncidenciaInfo { Alerta = new AlertaInfo { AlertaID = incidencia.Alerta.AlertaID }, Folio = incidencia.Folio, Organizacion = new OrganizacionInfo { OrganizacionID = incidencia.Organizacion.OrganizacionID }, Error = ex.Message }; bitacoraBL.GuardarErrorIncidencia(bitacora); } } } } } catch (ExcepcionGenerica) { throw; } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } }
/// <summary> /// Obtiene un diccionario con los parametros /// necesarios para la ejecucion del procedimiento /// almacenado ConfiguracionAlertas_ObtenerAlertasPorPaginas /// </summary> /// <param name="pagina"></param> /// <param name="filtro"></param> /// <returns>los parametros para ejecutar el procedimiento almacenado</returns> internal static Dictionary <string, object> ObtenerParametrosPorPaginaFiltroAlertas(PaginacionInfo pagina, AlertaInfo filtro) { Dictionary <string, object> parametros; try { Logger.Info(); parametros = new Dictionary <string, object> { { "@Inicio", pagina.Inicio }, { "@Limite", pagina.Limite }, { "@Descripcion", filtro.Descripcion } }; } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } return(parametros); }
/// <summary> /// Obtiene un lista paginada de alertas para el modulo configuracion alerta /// </summary> /// <param name="pagina"></param> /// <param name="filtro"></param> /// <returns>una lista de Alertas</returns> internal ResultadoInfo <AlertaInfo> ObtenerPorPaginaAlertas(PaginacionInfo pagina, AlertaInfo filtro) { ResultadoInfo <AlertaInfo> result; try { Logger.Info(); ConfiguracionAlertasDAL configAlertasDal = new ConfiguracionAlertasDAL(); result = configAlertasDal.ObtenerPorPaginaFiltroAlertas(pagina, filtro); } catch (ExcepcionGenerica ex) { Logger.Error(ex); throw; } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } return(result); }
/// <summary> /// Obtiene parametros para obtener lista paginada /// </summary> /// <param name="pagina">informacion de paginacion a usar para la consulta de las alertas</param> /// <param name="filtro">alerta de donde se obtienen los valores para los parametros</param> /// <returns>regresa una lista de parametros para consultar alertas usando paginacion</returns> internal static Dictionary <string, object> ObtenerParametrosPorPagina(PaginacionInfo pagina, AlertaInfo filtro) { try { Logger.Info(); var parametros = new Dictionary <string, object> { { "@Descripcion", string.IsNullOrWhiteSpace(filtro.Descripcion) ? string.Empty : filtro.Descripcion.Trim() }, { "@AlertaID", filtro.AlertaID }, { "@Activo", filtro.Activo }, { "@Inicio", pagina.Inicio }, { "@Limite", pagina.Limite } }; return(parametros); } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } }
/// <summary> /// Obtiene un lista de Alertas paginada /// </summary> /// <param name="pagina">informacion de paginacion de los alertas a mostrar</param> /// <param name="filtro">filtros de busqueda de alertas</param> /// <returns>Regresa una lista de alertas que concuerden con los filtros de busqueda proporcionados</returns> internal static ResultadoInfo <AlertaInfo> ObtenerPorPagina(PaginacionInfo pagina, AlertaInfo filtro) { try { Logger.Info(); var AlertaDAL = new AlertaDAL(); ResultadoInfo <AlertaInfo> result = AlertaDAL.ObtenerPorPagina(pagina, filtro); return(result); } catch (ExcepcionGenerica) { throw; } catch (Exception ex) { Logger.Error(ex); throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex); } }