/// <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();
}
/// <summary>
/// Devuelve una instancia de DAOFactory para realizar operaciones en la base de datos
/// </summary>
public static DAOFactory Instancia()
{
if (iInstaciaDAO == null)
{
iInstaciaDAO = new PostgreSQLDAOFactory();
}
return iInstaciaDAO;
}
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 ObtenerCuenta.
/// Obtiene todas las cuentas de la base de datos para mostrarlas luego
/// </summary>
/// <returns>Lista de cuentas almacenadas</returns>
public List<CuentaDTO> ObtenerCuenta()
{
try
{
iFactory = DAOFactory.Instancia();
iFactory.IniciarConexion();
iFactory.ComenzarTransaccion();
return iFactory.CuentaDAO().Obtener();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
iFactory.FinalizarConexion();
}
}
/// <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 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 ObtenerUnCorreo.
/// Obtiene un único correo mediante su ID para poder extraer la información necesaria de él.
/// </summary>
/// <param name="pIDMail">ID del mail que necesitamos obtener</param>
/// <returns>Email encontrado</returns>
public EmailDTO ObtenerUnCorreo(int pIDMail)
{
try
{
iFactory = DAOFactory.Instancia();
iFactory.IniciarConexion();
iFactory.ComenzarTransaccion();
EmailDTO iEmail = iFactory.MailDAO().ObtenerMail(pIDMail);
return iEmail;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
iFactory.FinalizarConexion();
}
}
/// <summary>
/// Método ObtenerTodosLosCorreos.
/// Obtiene todos los correos que están persistidos en la base de datos, de todas las cuentas disponibles.
/// </summary>
/// <returns>Lista de todos los correos persistidos en la base de datos</returns>
public List<EmailDTO> ObtenerTodosLosCorreos()
{
try
{
iFactory = DAOFactory.Instancia();
iFactory.IniciarConexion();
iFactory.ComenzarTransaccion();
List<EmailDTO> iListaCorreosObtenidos = iFactory.MailDAO().ObtenerTodos();
return iListaCorreosObtenidos;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
iFactory.FinalizarConexion();
}
}
/// <summary>
/// Método BuscarCuenta.
/// Obtiene una cuenta almacenada en la base de datos, mediante la búsqueda por su nombre.
/// Si coincide el nombre con el almacenado en la base de datos, la devuelve.
/// En caso contrario, lanzará una excepción
/// </summary>
/// <param name="pNombreCuenta">Nombre de la cuenta a buscar</param>
/// <returns>Cuenta deseada</returns>
public CuentaDTO BuscarCuenta(string pNombreCuenta)
{
try
{
iFactory = DAOFactory.Instancia();
iFactory.IniciarConexion();
iFactory.ComenzarTransaccion();
return iFactory.CuentaDAO().BuscarCuenta(pNombreCuenta);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
iFactory.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();
}
}
public void EliminarCuenta()
{
DAO = DAOFactory.Instancia();
DAO.IniciarConexion();
DAO.ComenzarTransaccion();
DAO.CuentaDAO().Eliminar("Nahuel Leiva");
DAO.Commit();
}
/// <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 BuscarCuenta()
{
DAO = DAOFactory.Instancia();
DAO.IniciarConexion();
DAO.ComenzarTransaccion();
CuentaDTO cuenta = DAO.CuentaDAO().BuscarCuenta("Nahuel Pacheco");
}
/// <summary>
/// Metodo para completar la información de una cuenta de la Base de Datos.
/// </summary>
/// <param name="pId">Id de la cuenta a ser completada.</param>
/// <returns></returns>
public CuentaDTO ObtenerCuenta(int pId)
{
try
{
factory = DAOFactory.Instancia;
factory.IniciarConexion();
CuentaDTO cuenta = new CuentaDTO();
cuenta.Id = pId;
return factory.CuentaDAO.ObtenerCuenta(cuenta);
}
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();
}
}
/// <summary>
/// Método para listar todos los correos de la cuenta <paramref name="pCuenta"/>.
/// </summary>
/// <returns>Una lista con todos los correos de la cuenta <paramref name="pCuenta"/>.</returns>
public IList<CorreoDTO> ListarCorreos(string pCuenta)
{
try
{
factory = DAOFactory.Instancia;
factory.IniciarConexion();
//Se devuelven los correos.
return factory.CorreoDAO.ObtenerCorreos(pCuenta);
}
finally
{
//Haya o no un error, se cierra la transacción.
factory.FinalizarConexion();
}
}
/// <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();
}
}
public void ObtenerCuentas()
{
DAO = DAOFactory.Instancia();
DAO.IniciarConexion();
DAO.ComenzarTransaccion();
List<CuentaDTO> cuenta = new List<CuentaDTO>();
cuenta = DAO.CuentaDAO().Obtener();
}
/// <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 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 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();
}
}
public void ObtenerMail()
{
DAO = DAOFactory.Instancia();
DAO.IniciarConexion();
DAO.ComenzarTransaccion();
List<EmailDTO> email = new List<EmailDTO>();
email = DAO.MailDAO().Obtener(1);
}
/// <summary>
/// Método para listar todas las cuentas de correo de la Base de Datos.
/// </summary>
/// <returns>Una lista con todos las cuentas de la base de datos.</returns>
public IList<CuentaDTO> ListarCuentas()
{
try
{
factory = DAOFactory.Instancia;
factory.IniciarConexion();
//Se devuelven las cuentas
return factory.CuentaDAO.ObtenerCuentas();
}
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();
}
}