/// <summary>
/// Método ConfirmarCambios_Click.
/// Permite confirmar los cambios de una cuenta en particular y persistirlos en la base de datos.
/// </summary>
public void ConfirmarCambios_Click(object pSender, EventArgs pEvento)
{
ControladorCuenta iControladorC = ControladorCuenta.Instancia;
CuentaDTO iCuentaAModificar = iControladorC.BuscarCuenta(dataGridViewDatosCuentas.CurrentRow.Cells[0].Value.ToString());
CuentaDTO iCuentaNueva = new CuentaDTO(textBoxNombre.Text, textBoxDireccion.Text, comboBoxServicios.SelectedItem.ToString(), textBoxContraseña.Text, true);
bool iNombreValido = ValidarCuenta(iCuentaNueva.Nombre);
bool iNombreValido2 = ValidarCuentaEnTodas(iCuentaNueva.Nombre);
DialogResult iConfirmar = MessageBox.Show("¿Está seguro que desea modificar los datos de la cuenta?", "Confirmar cambios", MessageBoxButtons.YesNo);
if (iConfirmar == DialogResult.Yes)
{
if (iNombreValido == false)
{
MessageBox.Show("El nombre de la cuenta ya existe. Por favor elija uno distinto e intente nuevamente", "Nombre de cuenta existente", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else if (iNombreValido2 == false)
{
MessageBox.Show("El nombre de la cuenta ya existe y corresponde a una cuenta inactiva. Por favor elija uno distinto e intente nuevamente", "Nombre de cuenta existente", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else
{
iControladorC.ModificarCuenta(iCuentaAModificar.ID, iCuentaNueva);
MessageBox.Show("La operación se llevó a cabo con éxito", "Cuenta modificada");
}
}
}
/// <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 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>
/// Permite modificar los datos de una cuenta de correo en la base de datos
/// </summary>
/// <param name="pCuenta">Cuenta que vamos a modificar</param>
public void Modificar(int pIDCuenta, CuentaDTO pCuenta)
{
NpgsqlCommand comando = new NpgsqlCommand("UPDATE cuenta SET nombre=@nombre, direccion= @direccion, servicio=@servicio, contrasenia=@contrasenia, activo=@activo WHERE idCuenta=@idCuenta", this.iConexion, this.iTransaccion);
comando.Parameters.AddWithValue("@idCuenta", pIDCuenta);
comando.Parameters.AddWithValue("@nombre", pCuenta.Nombre);
comando.Parameters.AddWithValue("@servicio", pCuenta.Servicio);
comando.Parameters.AddWithValue("@direccion", pCuenta.Direccion);
comando.Parameters.AddWithValue("@contrasenia", pCuenta.Contraseña);
comando.Parameters.AddWithValue("@activo", pCuenta.Activo);
try
{
comando.ExecuteNonQuery();
}
catch (NpgsqlException ex)
{
throw new Exception(ex.Message);
throw new DAOException("No se pudo modificar los datos de la cuenta");
}
}
/// <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>
/// Método AgregarCuenta_Click.
/// Permite agregar una cuenta a la base de datos.
/// </summary>
public void AgregarCuenta_Click(object pSender, EventArgs pEvento)
{
if (Validar() == true)
{
MessageBox.Show("Verifique que existen campos incompletos", "Campos incompletos", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
ControladorCuenta iControladorC = ControladorCuenta.Instancia;
string iNombreCuenta = textBoxNombreCuenta.Text;
string iDireccion = textBoxDireccionCuenta.Text;
bool iMailValido = ValidarMail(iDireccion);
bool iNombreValido = ValidarCuenta(iNombreCuenta);
bool iNombreValido2 = ValidarCuentaEnTodas(textBoxNombreCuenta.Text);
if (iNombreValido == false)
{
MessageBox.Show("El nombre de cuenta ya existe. Utilice un nombre diferente", "Nombre de cuenta existente", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else if (iNombreValido2 == false)
{
DialogResult iResultado = MessageBox.Show("La cuenta se encuentra inactiva. ¿Desea reactivar la cuenta?", "Cuenta inactiva", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning);
if (iResultado == DialogResult.OK)
{
iControladorC.ReactivarCuenta(iNombreCuenta);
MessageBox.Show("La cuenta ha sido reactivada.", "Cuenta reactivada", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
else if (iMailValido == false)
{
MessageBox.Show("El formato del mail es inválido. Escríbalo nuevamente", "Mail inválido", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning);
}
else
{
CuentaDTO iNuevaCuenta = new CuentaDTO(iNombreCuenta, iDireccion, comboBoxServicio.SelectedItem.ToString(), textBoxContraseña.Text, true);
iControladorC.CrearCuenta(iNuevaCuenta);
MessageBox.Show("La cuenta se ha agregado con éxito", "¡Cuenta agregada!", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
}
/// <summary>
/// Permite insertar una nueva Cuenta de correo en la base de datos
/// </summary>
/// <param name="pCuenta">Cuenta que vamos a insertar en la base de datos</param>
public void Insertar(CuentaDTO pCuenta)
{
try
{
// Obtengo el máximo idCuenta que se encuentra en la base de datos
// que corresponde la última cuenta que inserté
// En el caso de que la tabla cuenta esté vacía, entonces
// inicializamos idCuenta en 1.
NpgsqlCommand cmd = new NpgsqlCommand("select max(idcuenta) from cuenta", this.iConexion, this.iTransaccion);
NpgsqlCommand command = new NpgsqlCommand("select count(*) from cuenta", this.iConexion, this.iTransaccion);
int iCantidadRegistros = Convert.ToInt32(command.ExecuteScalar());
int idCuenta;
if (iCantidadRegistros == 0)
{
idCuenta = 1;
}
else
{
idCuenta = Convert.ToInt32(cmd.ExecuteScalar());
idCuenta++;
}
NpgsqlCommand comando = this.iConexion.CreateCommand();
comando.CommandText = @"insert into Cuenta(idcuenta,nombre,direccion,servicio,contrasenia,activo) values(@idCuenta,@nombre,@direccion,@servicio,@contrasenia,@activo)";
comando.Parameters.AddWithValue("@idcuenta", idCuenta);
comando.Parameters.AddWithValue("@nombre", pCuenta.Nombre);
comando.Parameters.AddWithValue("@direccion", pCuenta.Direccion);
comando.Parameters.AddWithValue("@servicio", pCuenta.Servicio);
comando.Parameters.AddWithValue("@contrasenia", pCuenta.Contraseña);
comando.Parameters.AddWithValue("@activo", pCuenta.Activo);
comando.Transaction = iTransaccion;
comando.ExecuteNonQuery();
}
catch (NpgsqlException)
{
throw new DAOException("No se pudo insertar la cuenta correctamente en la base de datos");
}
}
/// <summary>
/// Método EnviarCorreo.
/// Permite enviar un correo desde una casilla de Gmail.
/// </summary>
/// <param name="pCuenta">Cuenta para enviar el correo</param>
/// <param name="pMensaje">Mensaje que se construye para ser enviado</param>
public override void EnviarCorreo(CuentaDTO pCuenta, MailMessage pMensaje)
{
try
{
SmtpClient iCliente = new SmtpClient("smtp.gmail.com");
iCliente.EnableSsl = true;
iCliente.Port = 587;
iCliente.Credentials = new System.Net.NetworkCredential(pCuenta.Direccion, pCuenta.Contraseña);
iCliente.Send(pMensaje);
}
catch (FormatException)
{
throw new ServiciosCorreoException("No se pudo enviar su correo. Revise si el correo del destinatario no está mal escrito e intente nuevamente");
}
catch (SmtpException)
{
throw new ServiciosCorreoException("No se pudo enviar su correo. Revise que su conexión a Internet esté funcionando e intente nuevamente");
}
catch (Exception)
{
throw new ServiciosCorreoException("No se pudo enviar su correo");
}
}
/// <summary>
/// Método DescargarCorreos.
/// Permite descargar los correos de una casilla de correo del tipo Gmail.
/// </summary>
/// <param name="pCuenta">Cuenta para descargar correos</param>
/// <returns>Lista de emails descargados</returns>
public override List<EmailDTO> DescargarCorreos(CuentaDTO pCuenta)
{
List<EmailDTO> iListaCorreosDescargados = new List<EmailDTO>();
Pop3Client iPop = new Pop3Client();
int iCantidadMensajes;
string iIDMensaje;
try
{
iPop.Connect("pop.gmail.com", 995, true);
iPop.Authenticate(pCuenta.Direccion, pCuenta.Contraseña);
iCantidadMensajes = iPop.GetMessageCount();
string iCuerpo = "";
string iTipoCorreo = "";
List<String> iDestino = new List<String>();
List<String> iCC = new List<String>();
List<String> iCCO = new List<String>();
List<MessagePart> iListaAdjuntos = new List<MessagePart>();
for (int i = iCantidadMensajes; i > 0; i--)
{
iDestino.Clear();
iCC.Clear();
iCCO.Clear();
Message iMensaje = iPop.GetMessage(i);
iIDMensaje = iPop.GetMessageHeaders(i).MessageId;
if (iIDMensaje == null)
{
iIDMensaje = "";
}
MessagePart iTexto = iMensaje.FindFirstPlainTextVersion();
if (iTexto != null)
{
iCuerpo = iTexto.GetBodyAsText();
}
else
{
MessagePart iHTML = iMensaje.FindFirstHtmlVersion();
if (iHTML != null)
{
iCuerpo = iHTML.GetBodyAsText();
}
}
if (iMensaje.Headers.From.Address == pCuenta.Direccion)
{
iTipoCorreo = "Enviado";
}
else
{
iTipoCorreo = "Recibido";
}
foreach (RfcMailAddress direccionCorreo in iMensaje.Headers.To)
{
iDestino.Add(direccionCorreo.Address);
}
foreach (RfcMailAddress direccionCC in iMensaje.Headers.Cc)
{
iCC.Add(direccionCC.Address);
}
foreach (RfcMailAddress direccionCCO in iMensaje.Headers.Bcc)
{
iCCO.Add(direccionCCO.Address);
}
EmailDTO iNuevoMail = new EmailDTO(
pCuenta.ID,
iTipoCorreo,
iMensaje.Headers.From.Address,
iDestino,
iMensaje.Headers.Subject,
iCuerpo,
iMensaje.Headers.DateSent.ToString(),
true,
iCC,
iCCO,
iIDMensaje,
"No leído"
);
iListaCorreosDescargados.Add(iNuevoMail);
}
}
catch (InvalidLoginException)
{
throw new ServiciosCorreoException("No se puede actualizar la bandeja de la cuenta " + pCuenta.Direccion + ". Hubo un problema en el acceso");
}
catch (PopServerNotFoundException)
{
throw new ServiciosCorreoException("No se puede actualizar la bandeja de la cuenta " + pCuenta.Direccion + ". Hubo un error en el acceso al servidor POP3 de Gmail");
}
catch (Exception)
{
throw new ServiciosCorreoException("No se puede actualizar la bandeja de la cuenta " + pCuenta.Direccion + ".");
}
return iListaCorreosDescargados;
}
public void ModificarCuenta()
{
CuentaDTO CuentaAModificar = new CuentaDTO("Sergio Cabral", "*****@*****.**", "Gmail", "cacaconchoclo", true);
ControladorCuenta Controlador = ControladorCuenta.Instancia;
Controlador.ModificarCuenta(2, CuentaAModificar);
}
/// <summary>
/// Método ObtenerCorreosPorCuenta.
/// Permite obtener todos los correos de una cuenta específica.
/// </summary>
/// <param name="pCuenta">Cuenta de la cual queremos obtener sus correos</param>
/// <returns>Lista de todos los emails obtenidos</returns>
public List<EmailDTO> ObtenerCorreosPorCuenta(CuentaDTO pCuenta)
{
try
{
iFactory = DAOFactory.Instancia();
iFactory.IniciarConexion();
iFactory.ComenzarTransaccion();
List<EmailDTO> iListaCorreosObtenidos = iFactory.MailDAO().Obtener(pCuenta.ID);
return iListaCorreosObtenidos;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
iFactory.FinalizarConexion();
}
}
/// <summary>
/// Método DescargarCorreos.
/// El método permite descargar los correos de la bandeja de una cuena específica.
/// </summary>
/// <param name="pCuenta">Cuenta de la cual vamos a descargar los correos</param>
public void DescargarCorreos(CuentaDTO pCuenta)
{
List<EmailDTO> CorreosDescargados = FactoryServicios.Instancia.Servicio(pCuenta.Servicio).DescargarCorreos(pCuenta);
foreach (EmailDTO pEmailDescargado in CorreosDescargados)
{
// Si el correo ya existe, no lo guarda
// En caso contrario, lo guardará sin problema
if (!ExisteCorreo(pEmailDescargado))
{
GuardarCorreo(pEmailDescargado);
}
}
//// El while sirve para poder seguir circulando en la bandeja de correo de la cuenta especificada
//// en el caso de que existan mas correos para descargar. Cuando no hay mas correos nuevos para descargar
//// se sale del ciclo y termina.
//while (iCorreosGuardados != iCantidadCorreosADescargar)
//{
// pCuenta.CantidadCorreos = pCuenta.CantidadCorreos + 1;
// List<EmailDTO> CorreosDescargadosNuevamente = FactoryServicios.Instancia.Servicio(pCuenta.Servicio).DescargarCorreos(pCuenta);
// int iCorreosDescargadosNuevamente = CorreosDescargadosNuevamente.Count();
// // Pregunta si la cantidad de correos descargado nuevamente es igual a los correos descargados inicialmente.
// // En caso que suceda, quiere decir que no hay mas correos para descargar en la bandeja de correo.
// if (iCorreosDescargadosNuevamente == iCorreosDescargados)
// {
// iCorreosGuardados = iCantidadCorreosADescargar;
// }
// else
// {
// // En el caso de que todavía no sean iguales, toma el último mail obtenido
// // e intenta insertarlo en la base de datos
// if (!ExisteCorreo(CorreosDescargadosNuevamente[0]))
// {
// GuardarCorreo(CorreosDescargadosNuevamente[0]);
// iCorreosGuardados++;
// }
// }
//}
}
/// <summary>
/// Método BuscarPorEmail.
/// Obtiene la cuenta que buscamos mediante su dirección de mail.
/// </summary>
/// <param name="pDireccion">Dirección de mail que estamos buscando</param>
/// <returns>Cuenta encontrada</returns>
public CuentaDTO BuscarPorEmail(string pDireccion)
{
NpgsqlCommand comando = new NpgsqlCommand("SELECT * FROM cuenta WHERE direccion ILIKE '" + pDireccion + "%' and activo = 'true';", this.iConexion, this.iTransaccion);
try
{
CuentaDTO cuenta = null;
DataTable tabla = new DataTable();
NpgsqlDataAdapter operacion = new NpgsqlDataAdapter(comando);
operacion.Fill(tabla);
foreach (DataRow fila in tabla.Rows)
{
cuenta = new CuentaDTO(Convert.ToInt32(fila["idcuenta"]), Convert.ToString(fila["nombre"]), Convert.ToString(fila["direccion"]), Convert.ToString(fila["servicio"]), Convert.ToString(fila["contrasenia"]), Convert.ToBoolean(fila["activo"]));
}
return cuenta;
}
catch (NpgsqlException ex)
{
throw new Exception(ex.Message);
throw new DAOException("No se pudo obtener los datos de la cuenta");
}
}
/// <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 AgregarCuenta()
{
ControladorCuenta Controlador = ControladorCuenta.Instancia;
CuentaDTO Cuenta = new CuentaDTO("Sergio Dennis", "*****@*****.**", "tuvieja", "LACONCHADETUMADREALLBOYS", true);
Controlador.CrearCuenta(Cuenta);
}
/// <summary> /// Método EnviarCorreo. /// Permite enviar un correo mediante una cuenta especificada. /// </summary> /// <param name="pCuenta">Cuenta de la cual queremos enviar el mail</param> /// <param name="pMensaje">Mail que construimos para enviarlo</param> public abstract void EnviarCorreo(CuentaDTO pCuenta, MailMessage pMensaje);
/// <summary> /// Método abstracto DescargarCorreos. /// Permite descargar los correos de una cuenta específica. /// </summary> /// <param name="pCuenta">Cuenta para descargar correos</param> /// <returns>Lista de emails descargados</returns> public abstract List<EmailDTO> DescargarCorreos(CuentaDTO pCuenta);
