//---------------------------------------------------------------
// Metodos públicos de la clase (no visibles para la UIL)
//---------------------------------------------------------------
#region Metodos internos de validacion
/// <summary>
/// Valida la integridad de una entidad: Servicio
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_entServicio">Entidad con los datos a validar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
internal static void TInt(DBConn p_dbcAccess,
EServicio p_entServicio,
StatMsg p_smResult)
{
// ********
// Validaciones de los campos sin conexion
// ********
if (p_entServicio.Cod.Trim() == "")
{
// El campo [Código] no puede ser vacío
p_smResult.BllWarning("El dato [Código] no puede ser vacío", "");
return;
}
if (p_entServicio.Des.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
TInt_f(p_dbcAccess, p_entServicio, p_smResult);
if (p_smResult.NOk)
{
return;
}
}
/// <summary>
/// Recupera los datos de un usuario de la base Idn
/// </summary>
/// <param name="p_cnInfo">Codigo para identificar la string de conexion</param>
/// <param name="p_strUser">Codigo del usuario</param>
/// <param name="p_bChekSup">Verificar supervisor en Sist/Prog</param>
/// <param name="p_strSist">Sigla del sistema</param>
/// <param name="p_strPrg">Sigla del programa</param>
/// <param name="p_smResult">Estado final de la operacion</param>
/// <returns>Entidad con los datos del usuario</returns>
public static EIdnUsuario UserFullGet(string p_strUser,
StatMsg p_smResult)
{
// No hay errores aun
DBConn l_dbcAccess = null;
try
{
// Obtenemos una conexion a la base de datos
l_dbcAccess = DBRuts.GetConection(Connections.Idn);
// Verificamos si existe el usuario y si esta habilitado
DataSet l_dsTemp = new DataSet();
int l_iRet = Vendedores.UserFullSearch(l_dbcAccess, p_strUser, ref l_dsTemp, "Temporal1", p_smResult);
if (p_smResult.NOk)
{
return(null);
}
if (l_iRet == 0)
{
p_smResult.BllWarning("Acceso denegado (Internal Error 1)");
l_dsTemp.Dispose();
return(null);
}
// Construimos la entidad del usuario
EIdnUsuario l_entUser = new EIdnUsuario(l_dsTemp.Tables["Temporal1"].Rows[0]);
if (l_entUser.EstaBorrada)
{
// No puede volver
p_smResult.BllWarning("Acceso denegado (Internal Error 2)");
l_entUser.Dispose();
l_dsTemp.Dispose();
return(null);
}
return(l_entUser);
}
catch (Exception l_expData)
{
// Error al obtener el usuario
p_smResult.BllError(l_expData);
return(null);
}
finally
{
// Si logramos abrir la conexion-> la cerramos
if (l_dbcAccess != null)
{
l_dbcAccess.Close();
}
}
}
//---------------------------------------------------------------
// Metodos públicos de la clase (no visibles para la UIL)
//---------------------------------------------------------------
#region Metodos internos de validacion
/// <summary>
/// Valida la integridad de una entidad: Supervisor
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_entSupervisor">Entidad con los datos a validar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
internal static void TInt(DBConn p_dbcAccess,
ESupervisor p_entSupervisor,
StatMsg p_smResult)
{
// ********
// Validaciones de los campos sin conexion
// ********
if (p_entSupervisor.Cod.Trim() == "")
{
// El campo [Código] no puede ser vacío
p_smResult.BllWarning("El dato [Código] no puede ser vacío", "");
return;
}
if (p_entSupervisor.Apellido.Trim() == "")
{
// El campo [Apellido] no puede ser vacío
p_smResult.BllWarning("El dato [Apellido] no puede ser vacío", "");
return;
}
if (p_entSupervisor.Nombre.Trim() == "")
{
// El campo [Nombre] no puede ser vacío
p_smResult.BllWarning("El dato [Nombre] no puede ser vacío", "");
return;
}
if (p_entSupervisor.Usuario.Trim() == "")
{
// El campo [Usuario del Sistema] no puede ser vacío
p_smResult.BllWarning("El dato [Usuario del Sistema] no puede ser vacío", "");
return;
}
// ********
// Validaciones de los campos con conexion
// ********
// Llamamos a la funcion fija del usuario
TInt_f(p_dbcAccess, p_entSupervisor, p_smResult);
if (p_smResult.NOk)
{
return;
}
}
/// <summary>
/// Borra físicamente un registro de a tabla: Alertas
/// </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_iFxdVersion">Versión del registro a borrar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
internal static void AleDrop(DBConn p_dbcAccess,
int p_iNroconfig,
int p_iNroalerta,
int p_iFxdVersion,
StatMsg p_smResult)
{
try {
// Verificamos la clave a borrar
AleVKey(p_dbcAccess,
p_iNroconfig,
p_iNroalerta,
p_smResult);
if (p_smResult.NOk)
{
return;
}
// El registro tiene que existir
if (p_smResult.ICodeEs(BllCodes.KeyDsntFound))
{
// Error. La clave no existe
p_smResult.BllWarning("El ítem (Alerta) que intenta borrar no existe en el sistema.", "");
return;
}
// Debe coincidir el número de version
AleVVer(p_dbcAccess,
p_iNroconfig,
p_iNroalerta,
p_iFxdVersion,
p_smResult);
if (p_smResult.NOk)
{
return;
}
// Borramos físicamente el registro
Dal.Alertas.Drop(p_dbcAccess,
p_iNroconfig,
p_iNroalerta,
p_smResult);
}
catch (Exception l_expData) {
// Error en la operacion Remove
p_smResult.BllError(l_expData);
}
}
public static void enviarMail(List <string> destinatarios, string titulo, string textoMail, StatMsg p_smResult)
{
try
{
cargarParametros(p_smResult);
// Creamos el objeto mensaje de mail.
MailMessage msg = new MailMessage();
// Agregamos todos los destinatarios del mail.
foreach (string destinatario in destinatarios)
{
msg.To.Add(new MailAddress(destinatario));
}
// Cargamos el emisor
msg.From = new MailAddress(MailSender.mailRemitente);
// Cargamos el subject del mail y el cuerpo, sacados de la pantalla.
msg.Subject = titulo;
msg.Body = textoMail;
msg.IsBodyHtml = true;
// Recuperamos a partir de los aprametros el servidor a utilizar.
string servidorCorreo = MailSender.direccionSMTP;
int puerto = MailSender.puertoSMTP;
SmtpClient client = new SmtpClient(servidorCorreo, puerto);
client.EnableSsl = (MailSender.safeMail == "S");
client.DeliveryMethod = System.Net.Mail.SmtpDeliveryMethod.Network;
client.UseDefaultCredentials = false;
NetworkCredential credentials = new NetworkCredential(MailSender.mailCredential, MailSender.passCredential, "");
client.Credentials = credentials;
client.Send(msg);
}
catch (Exception e)
{
p_smResult.BllWarning(e.ToString());
}
}
/// <summary>
/// Agrega o modifica un registro de la tabla: Servicios
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_entServicio">Entidad con los datos a procesar</param>
/// <param name="p_smResult">Estado final de la operacion</param>
internal static void SSav(DBConn p_dbcAccess,
EServicio p_entServicio,
StatMsg p_smResult)
{
try {
// Procesamos codigo fijo
Save_f(p_dbcAccess, ref p_entServicio, p_smResult);
if (p_smResult.NOk)
{
return;
}
// Verificamos la clave a grabar
VKey(p_dbcAccess,
p_entServicio.Cod,
p_smResult);
if (p_smResult.NOk)
{
return;
}
// Si es una entidad nueva
if (p_entServicio.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 (Servicio) que intenta agregar ya existe en el sistema.", "");
return;
}
// Agregamos el registro
Insr(p_dbcAccess, p_entServicio, 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 (Servicio) que intenta modificar no existe en el sistema o no está habilitado.", "");
return;
}
// Debe coincidir el número de version
VVer(p_dbcAccess,
p_entServicio.Cod,
p_entServicio.FxdVersion,
p_smResult);
if (p_smResult.NOk)
{
return;
}
// Actualizamos el registro
Updt(p_dbcAccess, p_entServicio, p_smResult);
}
catch (Exception l_expData) {
// Error en la operacion SSav
p_smResult.BllError(l_expData);
}
}
/// <summary>
/// Verifica el número de version de una tabla
/// </summary>
/// <param name="p_dbcAccess">Conexion a la base de datos</param>
/// <param name="p_strCod">Código</param>
/// <param name="p_iFxdVersion">Número de version</param>
/// <param name="p_smResult">Estado final de la operacion</param>
internal static void VVer(DBConn p_dbcAccess,
string p_strCod,
int p_iFxdVersion,
StatMsg p_smResult)
{
// No hay errores aun
DataSet l_dsTemp = new DataSet();
// Verificamos el número de versión
Dal.Servicios.ChkVersion(p_dbcAccess,
p_strCod,
p_iFxdVersion,
ref l_dsTemp,
"Temporal",
p_smResult);
if (p_smResult.NOk)
{
return;
}
// Verificamos el resultado que vino
if (l_dsTemp.Tables["Temporal"].Rows.Count != 0)
{
// Verificamos si la cantidad es 1
if ((int)l_dsTemp.Tables["Temporal"].Rows[0]["cantidad"] == 1)
{
// La versión coincide
l_dsTemp.Dispose();
return;
}
}
// El número de versión no coincide
StreamWriter l_swErrorFile = null;
string l_strErrFName = String.Format("C:\\V{0:ddMMyyyyHHmmss}.Err",
DateTime.Now);
try {
// Creamos el archivo del error
l_swErrorFile = new StreamWriter(File.Create(l_strErrFName),
System.Text.Encoding.ASCII);
// Grabamos los datos del error
l_swErrorFile.WriteLine("Instante : {0:dd/MM/yyyy HH:mm:ss}", DateTime.Now);
l_swErrorFile.WriteLine("Metodo : {0}", p_smResult.Method);
l_swErrorFile.WriteLine("Message : No coincide el numero de version");
}
catch (Exception l_expData) {
// Error en el acceso al archivo.
string l_strLinea = l_expData.Message;
}
finally {
// Si llegamos a abrir el archivo -> lo cerramos
if (l_swErrorFile != null)
{
l_swErrorFile.Close();
l_swErrorFile.Dispose();
}
}
// El número de versión no coincide
l_dsTemp.Dispose();
p_smResult.BllWarning("El número de versión del registro del ítem (Servicio) no coincide.\r\nOperación cancelada.", "");
}
/// <summary>
/// Habilita/Deshabilita un registro de la tabla: Servicios
/// </summary>
/// <param name="p_bEnable">Tipo de operacion</param>
/// <param name="p_strCod">Código</param>
/// <param name="p_smResult">Estado final de la operacion</param>
public static void Enabled(bool p_bEnable,
string p_strCod,
int p_iFxdVersion,
StatMsg p_smResult)
{
// No hay errores aun
DBConn l_dbcAccess = null;
// Ajustamos codigos alineados a derecha
p_strCod = EServicio.FrmtCod(p_strCod);
try {
// Obtenemos una conexion
l_dbcAccess = DBRuts.GetConection(Connections.Dat);
l_dbcAccess.BeginTransaction();
// Procesamos codigo fijo
Enabled_f(l_dbcAccess,
p_bEnable,
p_strCod,
ref p_iFxdVersion,
p_smResult);
if (p_smResult.NOk)
{
return;
}
// Verificamos la clave a modificar
VKey(l_dbcAccess,
p_strCod,
p_smResult);
if (p_smResult.NOk)
{
return;
}
// El registro tiene que existir
if (p_smResult.ICodeEs(BllCodes.KeyDsntFound))
{
// Error. La clave no existe
p_smResult.BllWarning("El ítem (Servicio) que intenta modificar no existe en el sistema.", "");
return;
}
// Debe coincidir el número de version
VVer(l_dbcAccess,
p_strCod,
p_iFxdVersion,
p_smResult);
if (p_smResult.NOk)
{
return;
}
// Segun el modo
if (p_bEnable)
{
// Hay que habilitar el registro
Dal.Servicios.Recall(l_dbcAccess,
p_strCod,
p_smResult);
}
else
{
// Hay que deshabilitar el registro
Dal.Servicios.Delete(l_dbcAccess,
p_strCod,
p_smResult);
}
}
catch (Exception l_expData) {
// Error en la operacion Enabled
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();
}
}
}
