/// <summary>
/// Actualiza un registro a la tabla a partir de una entidad: EAlerta
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_entAlerta">Entidad con los datos a procesar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
internal static void AleUpdt(DBConn p_dbcAccess,
EAlerta p_entAlerta,
StatMsg p_smResult)
{
try {
// Validamos la integridad de la entidad
AleTInt(p_dbcAccess, p_entAlerta, p_smResult);
if (p_smResult.NOk)
{
return;
}
// Actualizamos un registro de la tabla: Alertas
Dal.Alertas.Update(p_dbcAccess,
p_entAlerta.Nroconfig,
p_entAlerta.Nroalerta,
p_entAlerta.Descripcion,
p_entAlerta.Detalle,
p_entAlerta.Importancia,
p_entAlerta.Fechadisparada,
p_entAlerta.Fechavista,
p_entAlerta.Usuariovista,
p_entAlerta.Repetirendias,
p_entAlerta.Finalizada,
p_entAlerta.Mailsenviados,
p_smResult);
}
catch (Exception l_expData) {
// Error en la operacion Updt
p_smResult.BllError(l_expData);
}
}
//---------------------------------------------------------------
// Metodos públicos de la clase (no visibles para la UIL)
//---------------------------------------------------------------
#region Metodos internos de validacion
/// <summary>
/// Valida la integridad de una entidad: Alerta
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_entAlerta">Entidad con los datos a validar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
internal static void AleTInt(DBConn p_dbcAccess,
EAlerta p_entAlerta,
StatMsg p_smResult)
{
// ********
// Validaciones de los campos sin conexion
// ********
if (p_entAlerta.Descripcion.Trim() == "")
{
// El campo [Descripción] no puede ser vacío
p_smResult.BllWarning("El dato [Descripción] no puede ser vacío", "");
return;
}
// ********
// Validaciones de los campos con conexion
// ********
// Llamamos a la funcion fija del usuario
AleTInt_f(p_dbcAccess, p_entAlerta, p_smResult);
if (p_smResult.NOk)
{
return;
}
}
/// <summary>
/// Agrega o modifica un registro de la tabla: Alertas
/// </summary>
/// <param name="p_entAlerta">Entidad con los datos a procesar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
public static void AleSave(EAlerta p_entAlerta,
StatMsg p_smResult)
{
// No hay errores aun
DBConn l_dbcAccess = null;
try {
// Obtenemos una conexion y abrimos una transaccion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
l_dbcAccess.BeginTransaction();
// Grabamos la entidad: EAlerta
AleSSav(l_dbcAccess, p_entAlerta, p_smResult);
}
catch (Exception l_expData) {
// Error en la operacion Save
p_smResult.BllError(l_expData);
}
finally {
// Si pude abrir la conexion
if (l_dbcAccess != null)
{
// Finalizo la transacción y la cierro
l_dbcAccess.EndTransaction(p_smResult);
l_dbcAccess.Close();
}
}
}
//---------------------------------------------------------------
// Metodos públicos de la clase
//---------------------------------------------------------------
#region Metodos publicos de la clase
#endregion
//---------------------------------------------------------------
// Metodos privados de la clase
//---------------------------------------------------------------
#region Metodos del Generador
/// <summary>
/// Agrega o modifica un registro de la tabla: Alertas
/// (Código Fijo)
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_entAlerta">Entidad con los datos a procesar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
internal static void AleSave_f(DBConn p_dbcAccess,
ref EAlerta p_entAlerta,
ref StatMsg p_smResult)
{
// *********
// Agregar acá los procesos adicionales
// *********
}
/// <summary>
/// Agrega validacion de integridad a una entidad: Alerta
/// (Código Fijo)
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_entAlerta">Entidad con los datos a validar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
internal static void AleTInt_f(DBConn p_dbcAccess,
EAlerta p_entAlerta,
ref StatMsg p_smResult)
{
// *********
// Agregar acá las validaciones adicionales
// *********
}
private static bool pasaronDiasYDebeRepetirse(EAlerta alerta)
{
// No puedo pasarle el statmsg por usarse en una lambda, si falla tiramos exception.
StatMsg l_smResult = new StatMsg();
DateTime fechaActual = Bll.Moviles.fGetDate(l_smResult);
if (MsgRuts.AnalizeError(App.GetMainWindow(), l_smResult))
{
throw new Exception(l_smResult.Msg);
}
return(fechaActual > alerta.Fechavista.AddDays(alerta.Repetirendias));
}
private static void mandarMailsSiCorresponde(EAlerta alerta, EMovil movil, StatMsg p_smResult)
{
if (!alerta.MailsEnviados)
{
EMovilAlerta movilAlerta = Bll.Moviles.MvalGet(movil.Patente, alerta.Nroconfig, true, p_smResult);
if (MsgRuts.AnalizeError(App.GetMainWindow(), p_smResult))
{
return;
}
EDestinatariosMail destinatariosMail = Bll.Tablas.DemGet(movilAlerta.Coddestinatarios, true, p_smResult);
if (MsgRuts.AnalizeError(App.GetMainWindow(), p_smResult))
{
return;
}
List <string> destinatarios = destinatariosMail.Destinatarios.Split(',').ToList();
destinatarios = destinatarios.Where(destinatario => destinatario.Trim() != "").ToList();
MailSender.enviarMail(destinatarios, "Alerta Automatica Sistema Móviles", getDetalleMail(alerta, movil), p_smResult);
if (MsgRuts.AnalizeError(App.GetMainWindow(), p_smResult))
{
return;
}
EAlerta alertaToupdate = Bll.Alertas.AleGet(alerta.Nroconfig, alerta.Nroalerta, true, p_smResult);
if (MsgRuts.AnalizeError(App.GetMainWindow(), p_smResult))
{
return;
}
alertaToupdate.Mailsenviados = "S";
Bll.Alertas.AleSave(alertaToupdate, p_smResult);
if (MsgRuts.AnalizeError(App.GetMainWindow(), p_smResult))
{
return;
}
}
}
/// <summary>
/// Devuelve una entidad: EAlerta
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_iNroconfig">Nro Config Alerta</param>
/// <param name="p_iNroalerta">Nro Alerta</param>
/// <param name="p_bOnlyActive">Indica si solo se analizan los registros activos</param>
/// <param name="p_smResult">Estado final de la operacion</param>
/// <returns>Entidad: EAlerta</returns>
internal static EAlerta AleSrch(DBConn p_dbcAccess,
int p_iNroconfig,
int p_iNroalerta,
bool p_bOnlyActive,
StatMsg p_smResult)
{
try {
// Pedimos el registro de la tabla: Alertas
DataSet l_dsTemp = new DataSet();
Dal.Alertas.Search(p_dbcAccess,
p_iNroconfig,
p_iNroalerta,
p_bOnlyActive,
ref l_dsTemp, "Temporal",
p_smResult);
if (p_smResult.NOk)
{
return(null);
}
// Constuimos la entidad y la devolvemos (si vino un registro)
EAlerta l_entRet = null;
if (l_dsTemp.Tables["Temporal"].Rows.Count == 1)
{
l_entRet = new EAlerta(l_dsTemp.Tables["Temporal"].Rows[0]);
}
l_dsTemp.Dispose();
return(l_entRet);
}
catch (Exception l_expData) {
// Error en la operacion Srch
p_smResult.BllError(l_expData);
return(null);
}
}
/// <summary>
/// Agrega o modifica un registro de la tabla: Alertas
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_entAlerta">Entidad con los datos a procesar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
internal static void AleSSav(DBConn p_dbcAccess,
EAlerta p_entAlerta,
StatMsg p_smResult)
{
try {
// Procesamos codigo fijo
AleSave_f(p_dbcAccess, ref p_entAlerta, p_smResult);
if (p_smResult.NOk)
{
return;
}
// Verificamos la clave a grabar
AleVKey(p_dbcAccess,
p_entAlerta.Nroconfig,
p_entAlerta.Nroalerta,
p_smResult);
if (p_smResult.NOk)
{
return;
}
// Si es una entidad nueva
if (p_entAlerta.EsNueva)
{
// Es un alta. La clave no debe existir
if (!p_smResult.ICodeEs(BllCodes.KeyDsntFound))
{
// Error. La clave ya existe
p_smResult.BllWarning("El ítem (Alerta) que intenta agregar ya existe en el sistema.", "");
return;
}
// Agregamos el registro
AleInsr(p_dbcAccess, p_entAlerta, p_smResult);
return;
}
// Es un update. La clave debe existir y estar habilitada
if (!p_smResult.ICodeEs(BllCodes.KeyExists))
{
// Error. La clave no existe o no está habilitada
p_smResult.BllWarning("El ítem (Alerta) que intenta modificar no existe en el sistema o no está habilitado.", "");
return;
}
// Debe coincidir el número de version
AleVVer(p_dbcAccess,
p_entAlerta.Nroconfig,
p_entAlerta.Nroalerta,
p_entAlerta.FxdVersion,
p_smResult);
if (p_smResult.NOk)
{
return;
}
// Actualizamos el registro
AleUpdt(p_dbcAccess, p_entAlerta, p_smResult);
}
catch (Exception l_expData) {
// Error en la operacion SSav
p_smResult.BllError(l_expData);
}
}
private static string getDetalleMail(EAlerta alerta, EMovil movil)
{
return($"Movil: {movil.Patente} <br /> <br /> Descripción: {alerta.Descripcion} <br /> <br /> Detalle: {alerta.Detalle}");
}
