/// <summary>
/// Método EnviarEmail.
/// Permite enviar un email desde de una cuenta de correo específica.
/// </summary>
/// <param name="pEmail">Email que se guardará en la base de datos</param>
/// <param name="pCuenta">Cuenta desde la cual enviamos el mail</param>
/// <param name="pMensaje">Objeto tipo MailMessage para armar el mensaje a enviar</param>
public void EnviarEmail(EmailDTO pEmail, CuentaDTO pCuenta, MailMessage pMensaje)
{
try
{
iFactory = DAOFactory.Instancia();
iFactory.IniciarConexion();
iFactory.ComenzarTransaccion();
FactoryServicios.Instancia.Servicio(pCuenta.Servicio).EnviarCorreo(pCuenta, pMensaje);
if (pEmail.IDMensaje == null)
{
pEmail.IDMensaje = "";
}
if (pEmail.Leido == null)
{
pEmail.Leido = "Leído";
}
iFactory.MailDAO().Insertar(pEmail);
iFactory.Commit();
}
catch (Exception ex)
{
iFactory.RollBack();
throw new Exception(ex.Message);
}
finally
{
iFactory.FinalizarConexion();
}
}
public void EliminarMail()
{
DAO = DAOFactory.Instancia();
DAO.IniciarConexion();
DAO.ComenzarTransaccion();
DAO.MailDAO().Eliminar(1);
DAO.Commit();
}
public void MarcarLeidoMail()
{
DAO = DAOFactory.Instancia();
DAO.IniciarConexion();
DAO.ComenzarTransaccion();
DAO.MailDAO().MarcarLeido(1);
DAO.Commit();
}
public void ModificarCuenta()
{
iCuenta = new CuentaDTO("Nahuel Pacheco", "*****@*****.**", "Gmail", "Machupichu", true);
DAO = DAOFactory.Instancia();
DAO.IniciarConexion();
DAO.ComenzarTransaccion();
DAO.CuentaDAO().Modificar(1, iCuenta);
DAO.Commit();
}
public void GuardarCuenta()
{
iCuenta = new CuentaDTO("Taller", "*****@*****.**", "Gmail", "diplomatic", true);
DAO = DAOFactory.Instancia();
DAO.IniciarConexion();
DAO.ComenzarTransaccion();
DAO.CuentaDAO().Insertar(iCuenta);
DAO.Commit();
}
/// <summary>
/// Método CrearCuenta.
/// Inserta una nueva cuenta en la base de datos intentando realizar la conexión con la misma.
/// En caso contrario, realiza un rollback y por último una vez realizada la transacción
/// cierra la conexión.
/// </summary>
/// <param name="pCuenta">Cuenta a insertar</param>
public void CrearCuenta(CuentaDTO pCuenta)
{
try
{
iFactory = DAOFactory.Instancia();
iFactory.IniciarConexion();
iFactory.ComenzarTransaccion();
iFactory.CuentaDAO().Insertar(pCuenta);
iFactory.Commit();
}
catch (Exception ex)
{
iFactory.RollBack();
throw new Exception(ex.Message);
}
finally
{
iFactory.FinalizarConexion();
}
}
/// <summary>
/// Metodo para dar de alta una cuenta de correo.
/// </summary>
/// <param name="pCuenta">Clase DTO con los datos de la cuenta a dar de alta.</param>
public void CrearCuenta(CuentaDTO pCuenta)
{
try
{
factory = DAOFactory.Instancia;
factory.IniciarConexion();
factory.ComenzarTransaccion();
factory.CuentaDAO.AgregarCuenta(pCuenta);
factory.Commit();
}
catch (Exception exception)
{
factory.RollBack();
//Se relanza la excepción porque en este punto no se puede tratar
throw exception;
}
finally
{
// Haya o no un error, se cierra la transacción.
factory.FinalizarConexion();
}
}
public void EnviarMailPrueba()
{
SmtpClient iCliente = new SmtpClient();
iCliente.Port = 587;
iCliente.Host = "smtp.gmail.com";
iCliente.EnableSsl = true;
iCliente.Timeout = 10000;
iCliente.DeliveryMethod = SmtpDeliveryMethod.Network;
iCliente.UseDefaultCredentials = false;
iCliente.Credentials = new System.Net.NetworkCredential("*****@*****.**", "AlexanderAnderson");
MailMessage iMensaje = new MailMessage("*****@*****.**", "*****@*****.**", "Prueba", "Te mando un cosito");
iCliente.Send(iMensaje);
List<String> iDestinatarios = new List<String>();
List<String> iCCO = new List<String>();
List<String> iCC = new List<String>();
iDestinatarios.Add("*****@*****.**");
iDestinatarios.Add("*****@*****.**");
iEmail = new EmailDTO(1 ,"enviado", "*****@*****.**", iDestinatarios, "Prueba", "Te mando un cosito", iFecha, true, iCC, iCCO);
DAO = DAOFactory.Instancia();
DAO.IniciarConexion();
DAO.ComenzarTransaccion();
DAO.MailDAO().Insertar(iEmail);
DAO.Commit();
}
/// <summary>
/// Método GuardarCorreo.
/// El método permite guardar los emails en la base de datos y persistirlos.
/// </summary>
/// <param name="pEmail">Email que vamos a persistir en la base de datos</param>
public void GuardarCorreo(EmailDTO pEmail)
{
try
{
iFactory = DAOFactory.Instancia();
iFactory.IniciarConexion();
iFactory.ComenzarTransaccion();
iFactory.MailDAO().Insertar(pEmail);
iFactory.Commit();
}
catch (Exception ex)
{
iFactory.RollBack();
throw new Exception(ex.Message);
}
finally
{
iFactory.FinalizarConexion();
}
}
/// <summary>
/// Método MarcarLeido.
/// Permite marcar como leído un mail.
/// </summary>
/// <param name="pIDMail">ID del mail que se marcará como leído.</param>
public void MarcarLeido(int pIDMail)
{
try
{
iFactory = DAOFactory.Instancia();
iFactory.IniciarConexion();
iFactory.ComenzarTransaccion();
iFactory.MailDAO().MarcarLeido(pIDMail);
iFactory.Commit();
}
catch (Exception Ex)
{
iFactory.RollBack();
throw new Exception(Ex.Message);
}
finally
{
iFactory.FinalizarConexion();
}
}
/// <summary>
/// Método ExisteCorreo.
/// El método controla si existen o no los correos en la base de datos.
/// </summary>
/// <param name="pEmail">Email que se verifica si existe o no en la base de datos</param>
/// <returns>TRUE en caso de que exista. FALSE en caso contrario</returns>
public bool ExisteCorreo(EmailDTO pEmail)
{
bool iEncontrado = false;
try
{
iFactory = DAOFactory.Instancia();
iFactory.IniciarConexion();
iFactory.ComenzarTransaccion();
iEncontrado = iFactory.MailDAO().ExisteCorreo(pEmail);
iFactory.Commit();
return iEncontrado;
}
catch (Exception Ex)
{
iFactory.RollBack();
throw new Exception(Ex.Message);
}
finally
{
iFactory.FinalizarConexion();
}
}
/// <summary>
/// Método ReactivarCuenta.
/// Permite reactivar una cuenta que se ha marcado como inactiva.
/// </summary>
/// <param name="pNombreCuenta">Nombre de la cuenta que deseamos reactivar</param>
public void ReactivarCuenta(string pNombreCuenta)
{
try
{
iFactory = DAOFactory.Instancia();
iFactory.IniciarConexion();
iFactory.ComenzarTransaccion();
iFactory.CuentaDAO().ReactivarCuenta(pNombreCuenta);
iFactory.Commit();
}
catch (Exception ex)
{
iFactory.RollBack();
throw new Exception(ex.Message);
}
finally
{
iFactory.FinalizarConexion();
}
}
/// <summary>
/// Método ModificarCuenta.
/// Mediante el id de la cuenta a modificar, se busca en la base de datos y el usuario
/// tiene la posibilidad de modificar los datos que desee. Luego se modifica la cuenta especificada.
/// </summary>
/// <param name="pIdCuenta">Id de la cuenta a modificar</param>
/// <param name="pCuentaAModificar">Objeto CuentaDTO que tendrá cargados los datos a modificar en la BD</param>
public void ModificarCuenta(int pIdCuenta, CuentaDTO pCuentaAModificar)
{
try
{
iFactory = DAOFactory.Instancia();
iFactory.IniciarConexion();
iFactory.ComenzarTransaccion();
iFactory.CuentaDAO().Modificar(pIdCuenta, pCuentaAModificar);
iFactory.Commit();
}
catch (Exception ex)
{
iFactory.RollBack();
throw new Exception(ex.Message);
}
finally
{
iFactory.FinalizarConexion();
}
}
public void EliminarCuenta()
{
DAO = DAOFactory.Instancia();
DAO.IniciarConexion();
DAO.ComenzarTransaccion();
DAO.CuentaDAO().Eliminar("Nahuel Leiva");
DAO.Commit();
}
/// <summary>
/// Método para modificar un correo.
/// </summary>
/// <param name="pCorreo">Objeto DTO con los datos del correo a modificar.</param>
public void ModificarCorreo(CorreoDTO pCorreo)
{
try
{
factory = DAOFactory.Instancia;
factory.IniciarConexion();
factory.ComenzarTransaccion();
factory.CorreoDAO.ModificarCorreo(pCorreo);
factory.Commit();
}
catch (Exception e)
{
factory.RollBack();
//Se relanza la excepción porque en este punto no se puede tratar
throw e;
}
finally
{
// Haya o no un error, se cierra la transacción.
factory.FinalizarConexion();
}
}
/// <summary>
/// Metodo para determinar si un correo ya existe en la base de datos.
/// </summary>
/// <param name="pCorreo">Correo a buscar en la base de datos.</param>
/// <returns>False si el correo no existe en la base, true de lo contrario.</returns>
public bool Existe(CorreoDTO pCorreo)
{
bool encontrado = false;
try
{
factory = DAOFactory.Instancia;
factory.IniciarConexion();
factory.ComenzarTransaccion();
encontrado = factory.CorreoDAO.Existe(pCorreo);
factory.Commit();
return encontrado;
}
catch (Exception exception)
{
factory.RollBack();
//Se relanza la excepción porque en este punto no se puede tratar
throw exception;
}
finally
{
// Haya o no un error, se cierra la transacción.
factory.FinalizarConexion();
}
}