/// <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);
}
}
