/// <summary>
/// Metodo que se dispara al hacer click en el boton "Actualizar".
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btActualizar_Click(object sender, EventArgs e)
{
//Busca la o las cuentas seleccionadas en listaCuentas
Int32 row = listaCuentas.SelectedIndex;
string cuentaSeleccionada = Convert.ToString(listaCuentas.Items[row]);
//Muestra el mensaje de información al usuario
mensajeActualizando.Visible = true;
mensajeActualizando.Update();
try
{
// Si la cuenta seleccionada es distinta de "Todas las cuentas"
if (cuentaSeleccionada.CompareTo("Todas las cuentas") != 0)
{
CuentaDTO pCuenta = FachadaABMCuenta.Instancia.ObtenerCuenta(cuentaSeleccionada);
ActualizarCuenta(pCuenta);
}
else
{
foreach (CuentaDTO aCuenta in FachadaABMCuenta.Instancia.ListarCuentas())
{
ActualizarCuenta(aCuenta);
}
}
}
catch (Exception exeption)
{
MessageBox.Show(exeption.Message, "PostApp", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
//Oculta el mensaje de información al usuario
mensajeActualizando.Visible = false;
// Actualiza las listas Recibidos y Enviados
MostrarCorreos();
}
public async Task <string> DeleteCuenta(CuentaDTO cuenta)
{
CuentaDTO account = await GetCuentabyId(cuenta.idCuenta);
try
{
return(await _commonRepository.DeleteLogicoObjeto(cuenta, new Cuenta()
{
idCuenta = account.idCuenta,
diminutivo = account.diminutivo,
correo = account.correo,
//netflix = account.netflix,
//amazon = account.amazon,
//disney = account.disney,
//hbo = account.hbo,
//youtube = account.youtube,
//spotify = account.spotify,
idEstado = 2
}, _context));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(_commonRepository.ExceptionMessage(cuenta, "D"));
}
}
public int clear(CuentaDTO cuenta)
{
int res = 0;
try {
connection.Open();
MySqlCommand myCommand = new MySqlCommand();
myCommand.Connection = connection;
myCommand.CommandText = "DELETE FROM correo WHERE cuenta_idcuenta=?idcuenta";
myCommand.Parameters.Add("?idcuenta", MySqlDbType.Int16).Value = cuenta.IdCuenta;
myCommand.ExecuteNonQuery();
myCommand.CommandText = "DELETE FROM origendestino WHERE 1=1";
myCommand.ExecuteNonQuery();
myCommand.CommandText = "DELETE FROM adjunto WHERE 1=1";
myCommand.ExecuteNonQuery();
connection.Close();
res = 1;
return(res);
}
catch (MySqlException ex) {
return(-1);
}
}
public int LastId(CuentaDTO cuenta)
{
int res = 0;
try
{
connection.Open();
MySqlCommand myCommand = new MySqlCommand();
myCommand.Connection = connection;
myCommand.CommandText = "SELECT MAX(idcorreo) FROM correo WHERE cuenta_idcuenta=?cuentaidd";
myCommand.Parameters.Add("?cuentaidd", MySqlDbType.Int16).Value = cuenta.IdCuenta;
string idStr = myCommand.ExecuteScalar().ToString();
try
{
int i = int.Parse(idStr);
res = i;
}
catch (Exception e) {
res = 0;
}
connection.Close();
return(res);
}
catch (MySqlException ex) {
return(0);
}
}
/// <summary>
/// Actualiza una Cuenta almacenada en la Base de Datos
/// </summary>
/// <param name="cuenta"></param>
/// <returns></returns>
public int update(CuentaDTO cuenta)
{
int generatedKey;
try
{
connection.Open();
MySqlCommand myCommand = new MySqlCommand();
myCommand.Connection = connection;
myCommand.CommandText = "UPDATE cuenta SET usuario = ?user,password = ?pwd,server_idserver = ?server) WHERE " +
"idcuenta = ?idcuenta";
myCommand.Parameters.Add("?user", MySqlDbType.VarChar).Value = cuenta.User;
myCommand.Parameters.Add("?pwd", MySqlDbType.VarChar).Value = cuenta.Password;
myCommand.Parameters.Add("?server", MySqlDbType.VarChar).Value = cuenta.Server;
myCommand.Parameters.Add("?idcuenta", MySqlDbType.VarChar).Value = cuenta.IdCuenta;
generatedKey = myCommand.ExecuteNonQuery();
connection.Close();
}
catch (Exception)
{
throw;
}
return(generatedKey);
}
public async Task <IActionResult> Edit(int id, [Bind("idCuenta,correo,diminutivo,netflix,amazon,disney,hbo,youtube,spotify,idEstado")] CuentaDTO cuenta)
{
if (id != cuenta.idCuenta)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
await _context.UpdateCuenta(cuenta);
}
catch (DbUpdateConcurrencyException)
{
if (!await _context.CuentaExists(cuenta.idCuenta))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(cuenta));
}
public int mailCount(CuentaDTO cuenta)
{
int res = 0;
try
{
connection.Open();
MySqlCommand myCommand = new MySqlCommand();
myCommand.Connection = connection;
myCommand.CommandText = "SELECT COUNT(*) FROM correo WHERE cuenta_idcuenta=?idcuenta";
myCommand.Parameters.Add("?idcuenta", MySqlDbType.Int16).Value = cuenta.IdCuenta;
string resStr = myCommand.ExecuteScalar().ToString();
res = int.Parse(resStr);
connection.Close();
return(res);
}
catch (MySqlException ex) {
return(res);
}
}
/// <summary>
/// Método que se dispara al hacer click en el botón Borrar del Menú
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void borrarToolStripMenuItem_Click(object sender, EventArgs e)
{
if (MessageBox.Show("¿Está seguro que desea eliminar esta cuenta?", "PostApp", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
if (cuenta_id.Text == "")
{
listaCuentas.Rows.Remove(listaCuentas.SelectedRows[0]);
// Marca como seleccionada la ultima fila
listaCuentas.Rows[listaCuentas.Rows.Count - 1].Selected = true;
}
else
{
CuentaDTO pCuenta = new CuentaDTO();
pCuenta.Id = Convert.ToInt32(cuenta_id.Text);
pCuenta.Direccion = Convert.ToString(cuenta_usuario);
try
{
FachadaABMCuenta.Instancia.EliminarCuenta(pCuenta);
}
catch (Exception exeption)
{
MessageBox.Show(exeption.Message, "PostApp", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
// Actualiza la lista de cuentas
MostrarCuentas();
}
}
}
/// <summary>
/// Elimina una cuenta de la Base de Datos
/// </summary>
/// <param name="cuenta"></param>
/// <returns></returns>
public int delete(CuentaDTO cuenta)
{
int generatedKey = 0;
try
{
connection.Open();
MySqlCommand myCommand = new MySqlCommand();
myCommand.Connection = connection;
myCommand.CommandText = "DELETE FROM cuenta WHERE cuenta_idcuenta = ?idcuenta";
myCommand.Parameters.Add("?idcuenta", MySqlDbType.VarChar).Value = cuenta.IdCuenta;
generatedKey = myCommand.ExecuteNonQuery();
connection.Close();
}
catch (MySqlException ex)
{
}
return(generatedKey);
}
/// <summary>
/// Crea una nueva Cuenta en la Base de Datos
/// </summary>
/// <param name="cuenta"></param>
/// <returns></returns>
public int create(CuentaDTO cuenta)
{
int generatedKey;
try
{
connection.Open();
MySqlCommand myCommand = new MySqlCommand();
myCommand.Connection = connection;
myCommand.CommandText = "INSERT INTO cuenta (usuario,password,server_idserver) VALUES " +
"(?user, ?pwd, ?server)";
myCommand.Parameters.Add("?user", MySqlDbType.VarChar).Value = cuenta.User;
myCommand.Parameters.Add("?pwd", MySqlDbType.VarChar).Value = cuenta.Password;
myCommand.Parameters.Add("?server", MySqlDbType.VarChar).Value = cuenta.Server;
generatedKey = myCommand.ExecuteNonQuery();
connection.Close();
}
catch (Exception)
{
throw;
}
return(generatedKey);
}
/// <summary>
/// Metodo para actualizar la informacion de una cuenta de correo de la Base de Datos.
/// </summary>
/// <param name="pCuentaCorreo"></param>
public void ModificarCuenta(CuentaDTO pCuentaCorreo)
{
try
{
SqlCommand comando = this.iConexion.CreateCommand();
comando.CommandText = @"update Cuenta set direccion= @Direccion, contraseña= @Contraseña,
nombre = @Nombre, servicio = @Servicio
where cuentaId = @ID";
comando.Parameters.AddWithValue("@Nombre", pCuentaCorreo.Nombre);
comando.Parameters.AddWithValue("@Direccion", pCuentaCorreo.Direccion);
comando.Parameters.AddWithValue("@Contraseña", pCuentaCorreo.Contraseña);
comando.Parameters.AddWithValue("@ID", pCuentaCorreo.Id);
comando.Parameters.AddWithValue("@Servicio", pCuentaCorreo.Servicio);
comando.Transaction = iTransaccion;
comando.ExecuteNonQuery();
}
catch (SqlException pSqlException)
{
if (pSqlException.Errors[0].Number == 2627)
{
throw new DAOException("Error de datos duplicados. Modifique el nombre y vuelva a intentarlo.", pSqlException);
}
throw new DAOException("Error en la actualizacion de datos de cuenta de correo. Revise la configuración de su servidor de Base de Datos y el nombre de su base de datos. Para más información consulte el manual de PostApp.", pSqlException);
}
}
public Usuario CreateUserAccount(RequestPost requestPost)
{
Usuario user = null;
ResultPost StateDireccion = PostDireccionApi(requestPost.Direccion).First();
if (StateDireccion.Id != null || StateDireccion.Id != "null")
{
user = Conversion.ConverUser(requestPost);
user.IdDireccion = int.Parse(StateDireccion.Id);
_repository.Add(user);
if (user != null)
{
CuentaDTO account = Conversion.ConverAccount(requestPost, user.IdUsuario);
ResultPost StateCuenta = PostCuentaApi(account).First();
if (StateCuenta.Id != null || StateCuenta.Id != "null")
{
user.IdCuenta = int.Parse(StateCuenta.Id);
_repository.Edit(user);
}
else
{
_repository.Delete(user);
user = null;
}
}
}
return(user);
}
/// <summary>
/// Metodo para obtener una cuenta de correo de la Base de Datos.
/// </summary>
/// <param name="pCuentaCorreo"></param>
/// <returns></returns>
public CuentaDTO ObtenerCuenta(CuentaDTO pCuentaCorreo)
{
try
{
SqlCommand comando = this.iConexion.CreateCommand();
comando.CommandText = @"select * from Cuenta where cuentaId = @ID or nombre = @Nombre";
comando.Parameters.AddWithValue("@ID", pCuentaCorreo.Id);
comando.Parameters.AddWithValue("@Nombre", pCuentaCorreo.Nombre);
DataTable tabla = new DataTable();
using (SqlDataAdapter adaptador = new SqlDataAdapter(comando))
{
adaptador.Fill(tabla);
foreach (DataRow fila in tabla.Rows)
{
pCuentaCorreo.Nombre = Convert.ToString(fila["nombre"]);
pCuentaCorreo.Direccion = Convert.ToString(fila["direccion"]);
pCuentaCorreo.Contraseña = Convert.ToString(fila["contraseña"]);
pCuentaCorreo.Id = Convert.ToInt32(fila["cuentaId"]);
pCuentaCorreo.Servicio = Convert.ToString(fila["servicio"]);
}
}
return(pCuentaCorreo);
}
catch (SqlException pSqlException)
{
throw new DAOException("Error en la obtención de una cuenta de correo", pSqlException);
}
}
/// <summary>
/// Método para obtener todos los datos existentes de una cuenta
/// </summary>
/// <param name="cuenta"></param>
/// <returns></returns>
public CuentaDTO ObtenerCuenta(CuentaDTO cuenta)
{
factory.startConnection();
CuentaDTO cuentaObtenida = factory.getCuenta().get(cuenta);
factory.closeConnection();
return(cuentaObtenida);
}
public void limpiar(CuentaDTO cuenta)
{
factory.startConnection();
factory.getCorreo().clear(cuenta);
factory.closeConnection();
}
public int CantidadCorreos(CuentaDTO cuenta)
{
factory.startConnection();
int cantidad = factory.getCorreo().mailCount(cuenta);
factory.closeConnection();
return(cantidad);
}
public int UltimoIdCorreo(CuentaDTO cuenta)
{
factory.startConnection();
int id = factory.getCorreo().LastId(cuenta);
factory.closeConnection();
return(id);
}
/// <summary>
/// Método para obtener la fecha del último mensaje descargado.
/// </summary>
/// <param name="cuenta">Cuenta destino</param>
/// <returns></returns>
public DateTime fechaUltimoMensaje(CuentaDTO cuenta)
{
factory.startConnection();
DateTime fecha = factory.getCorreo().lastMail(cuenta);
factory.closeConnection();
return(fecha);
}
/// <summary>
/// Metodo que se dispara al hacer click en el boton ENVIAR para enviar un correo.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btEnviar_Click(object sender, EventArgs e)
{
//Muestra el mensaje de información al usuario.
mensajeEnviando.Visible = true;
mensajeEnviando.Update();
CorreoDTO pCorreo = new CorreoDTO();
pCorreo.Leido = false;
pCorreo.CuentaOrigen = Convert.ToString(listaCuentas.SelectedItem);
pCorreo.CuentaDestino = correo_Destino.Text;
pCorreo.Asunto = correo_Asunto.Text;
pCorreo.Fecha = DateTime.Today;
pCorreo.Texto = correo_Texto.Text;
pCorreo.TipoCorreo = "Enviado";
pCorreo.Adjuntos = archivos;
pCorreo.Eliminado = false;
try
{
//Obtenemos la cuenta con la que se envía el correo
CuentaDTO pCuenta = FachadaABMCuenta.Instancia.ObtenerCuenta(pCorreo.CuentaOrigen);
if (pCuenta.Contraseña == "" || pCuenta.Contraseña == null)
{
FormContraseña f2 = new FormContraseña(pCuenta);
DialogResult res = f2.ShowDialog(); //abrimos el formulario contraseña como cuadro de dialogo modal
if (res == DialogResult.OK)
{
// Recuperando la variable publica del formulario contraseña
// asignamos al texbox el dato de la variable
pCuenta.Contraseña = f2.varf2;
}
}
//Enviamos el correo.
FachadaCorreo.Instancia.EnviarCorreo(pCorreo, pCuenta);
//Guardamos el correo en la base de datos.
// Actualiza el valor del campo CuentaOrigen, ya que tiene el nombre de la cuenta pero se debe guardar con la direccion.
pCorreo.CuentaOrigen = FachadaABMCuenta.Instancia.ObtenerCuenta(pCorreo.CuentaOrigen).Direccion;
//Setea el valor del campo servicioid
pCorreo.ServicioId = "Correo enviado por el Cliente de Correo";
FachadaCorreo.Instancia.CrearCorreo(pCorreo);
MessageBox.Show("Enviado con exito.", "Envio de mail", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception exeption)
{
MessageBox.Show(exeption.Message, "PostApp", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
//Oculta el mensaje de información al usuario
mensajeEnviando.Visible = false;
this.Close();
}
public IEnumerable <ResultPost> PostCuentaApi(CuentaDTO cuentaDTO)
{
string uri = _request.GetUri(2);
RestRequest request = new RestRequest(Method.POST);
request.AddJsonBody(cuentaDTO);
IEnumerable <ResultPost> user = _request.ConsultarApiRest <ResultPost>(uri, request);
return(user);
}
/// <summary>
/// Método para obtener la cuenta a partir de un correo.
/// </summary>
/// <param name="correo">Correo del que se quiere obtener la cuenta</param>
/// <returns>CuentaDTO del correo</returns>
public CuentaDTO ObtenerCuentaDeCorreo(CorreoDTO correo)
{
CuentaDTO cuentaObtenida = new CuentaDTO();
cuentaObtenida.IdCuenta = correo.IdCuenta;
factory.startConnection();
cuentaObtenida = factory.getCuenta().get(cuentaObtenida);
factory.closeConnection();
return(cuentaObtenida);
}
public async Task <IActionResult> Create([Bind("idCuenta,correo,diminutivo,netflix,amazon,disney,hbo,youtube,spotify,idEstado")] CuentaDTO cuenta)
{
if (ModelState.IsValid)
{
await _context.InsertCuenta(cuenta);
return(RedirectToAction(nameof(Index)));
}
return(View(cuenta));
}
public void ConectarSmtp(ServerDTO server, CuentaDTO cuenta)
{
cliente = new SmtpClient();
cliente.Host = server.SmtpServer;
cliente.Port = server.SmtpPort;
cliente.DeliveryMethod = SmtpDeliveryMethod.Network;
cliente.EnableSsl = server.Ssl;
cliente.Credentials = new NetworkCredential(cuenta.User, cuenta.Password);
}
public void ConectarPop(ServerDTO server, CuentaDTO cuenta)
{
cliente = new Pop3Client();
try {
cliente.Connect(server.PopServer, server.PopPort, server.Ssl);
cliente.Authenticate(cuenta.User, cuenta.Password);
}
catch (OpenPop.Pop3.Exceptions.PopClientException ex) {
Console.WriteLine(ex.Message);
}
}
public static CuentaDTO ConverAccount(RequestPost entity, int iduser)
{
CuentaDTO account = new CuentaDTO()
{
Contraseña = entity.Cuenta.Password,
Mail = entity.Cuenta.Email,
IdTipoCuenta = 1,
IdUsuario = iduser
};
return(account);
}
public void enviarCorreo(CorreoDTO correo)
{
try
{
CuentaDTO cuenta = Cuenta.getInstance().ObtenerCuentaDeCorreo(correo);
ServerDTO server = new ServerDTO();
server.Id = cuenta.Server;
server = Server.getInstance().ObtenerServer(server);
//Sesión
MailMessage mensaje = new MailMessage();
//Agrego destinatarios, guardados en la lista de OrigenDestino
foreach (OrigenDestinoDTO od in correo.OrigenDestino)
{
//Si es CC
if (od.Cc == true)
{
mensaje.CC.Add(new MailAddress(od.Direccion));
}
//Si es CCO
else if (od.Cco == true)
{
mensaje.Bcc.Add(new MailAddress(od.Direccion));
}
//Sino, es Para
else
{
mensaje.To.Add(new MailAddress(od.Direccion));
}
}
mensaje.Subject = correo.Asunto;
mensaje.Body = correo.Detalle;
//Adjuntos
//foreach (AttachmentDTO adjunto in correo.Adjuntos) {
//}
mensaje.From = new MailAddress(cuenta.User);
AdminSmtp smtp = new AdminSmtp();
smtp.ConectarSmtp(server, cuenta);
//If enviado < 0 -> error al enviar
int enviado = smtp.Enviar(mensaje, false);
}
catch (Exception ex) { }
}
/// <summary>
/// Metodo para descargar los correos de una cuenta y cargarlos en la base de datos.
/// </summary>
/// <param name="pCorreo"></param>
public void DescargarCorreos(CuentaDTO pCuenta)
{
// Obtiene una instancia del servicio al que pertenece la cuenta e invoca al metodo
// DescargarCorreos pasandole como parametro la cuenta de la cual se desea descargar los correos
IList <CorreoDTO> pCorreos = FabricaServicios.Instancia.GetServicio(pCuenta.Servicio).DescargarCorreos(pCuenta);
foreach (CorreoDTO pCorreo in pCorreos)
{
if (!(Existe(pCorreo)))
{
CrearCorreo(pCorreo);
}
}
}
// POST: api/Cuenta
//[ResponseType(typeof(Cuenta))]
//public IHttpActionResult PostCuenta(Cuenta cuenta)
//{
// if (!ModelState.IsValid)
//{
// return BadRequest(ModelState);
///}
//db.Cuenta.Add(cuenta);
//db.SaveChanges();
//return CreatedAtRoute("DefaultApi", new { id = cuenta.Pin }, cuenta);
//}
public IHttpActionResult Create(CuentaDTO cuentaDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var cuenta = Mapper.Map <CuentaDTO, Cuenta>(cuentaDTO);
_UnityOfWork.Cuenta.Add(cuenta);
_UnityOfWork.SaveChanges();
cuentaDTO.CuentaId = cuenta.CuentaId;
return(Created(new Uri(Request.RequestUri + "/" + cuenta.CuentaId), cuentaDTO));
}
public async Task <ActionResult <CuentaDTO> > GetCuenta([FromBody] CuentaDTO cuenta)
{
CuentaDTO account = null;
if (cuenta.idCuenta != 0)
{
account = await _context.GetCuentabyId(cuenta.idCuenta);
}
if (account == null)
{
return(NotFound());
}
return(account);
}
public List <CuentaDTO> ObtenerCuentaPorPrecliente(string idprecliente)
{
var dt = new CapturaClienteRepository().ObtenerCtasBancPECACliente(idprecliente);
List <CuentaDTO> lista = new List <CuentaDTO>();
foreach (DataRow dr in dt.Rows)
{
CuentaDTO cta = new CuentaDTO();
cta.Banco = dr["banco"].ToString();
cta.NumeroCuenta = Convert.ToInt32(dr["numero_cuenta"]);
cta.Identificador = dr["identificador"].ToString();
cta.PatentesAutorizadas = dr["patentes_autorizadas"].ToString();
cta.Aduana = dr["aduana"].ToString();
cta.IdBanco = Convert.ToInt32(dr["id_banco"]);
lista.Add(cta);
}
return(lista);
}
