// <--- Botón "iconSave". ---> //
/*
* Este botón permitirá guardar y registrar un nuevo usuario.
*/
private void iconbtnSave_Click(object sender, EventArgs e)
{
registro_usuarios user = new registro_usuarios(); // Creación de un objeto de la clase "registro_usuarios".
/*
* Asiganción de los datos de los "textbox" del formulario de registro a las propiedades
* del objeto "usuario".
*/
user.Name1 = txtName.Text;
user.Last_name1 = txtLastName.Text;
user.Username1 = txtUsername.Text;
user.Email1 = txtEmail.Text;
user.Password1 = txtPass.Text;
try{
Control ctrl = new Control(); // Creación de un objeto de la clase "Control".
string respuesta = ctrl.ctrlregisterAdmins(user); // Llamada al método "ctrlRegistro", enviandole como parámetro el objeto "usuario".
// "MessageBox" que se mostrará al usuario para avisar de algun error.
if (respuesta.Length > 0)
{
MessageBox.Show(respuesta, "Aviso.", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
// "MessageBox" que se mostrará al usuario para confirmar su registro.
MessageBox.Show("¡Usuario registrado con éxito!", "Datos registrados.", MessageBoxButtons.OK, MessageBoxIcon.Information);
Clean(); // Llamada al método para limpiar los textbox.
ReloadUsersTable(null); // Llamada al método que permite actualizar la tabla.
}
}
// Catch que sólo se activará si el administrador presenta algún tipo de error al registrar un usuario.
catch (Exception ex) {
MessageBox.Show(ex.Message); // Mensaje de error.
}
}
// <---------------------------------------> //
// <---------- MÉTODOS / METHODS ----------> //
// <---------------------------------------> //
// <--- Método #1: Retornar mensajes de error para el formulario de registro. ---> //
public string ctrlRegister(registro_usuarios user) // Recibe como parámetro una variable de tipo "registro_usuarios".
{
Model model = new Model(); // Se crea una instancia de la clase "Model".
// Declaración de variable de tipo string que almacenará los mensajes de error que correspondan.
string errorMessage = "";
// <--- Validación #1: Llenar todos los campos de formulario de registro. ---> //
// Condición que se activará sí y sólo sí alguno de los campos están vacíos.
/*
* ".IsNullOrEmpty() verifica que el campo esté vacío o sea "nulo". de ser así, la condición se cumple.
*/
if (string.IsNullOrEmpty(user.Name1) || string.IsNullOrEmpty(user.Last_name1) ||
string.IsNullOrEmpty(user.Username1) || string.IsNullOrEmpty(user.Password1) ||
string.IsNullOrEmpty(user.ConPassword1) || string.IsNullOrEmpty(user.Email1))
{
errorMessage = "Debe llenar todos los campos"; // Mensaje de error.
}
// <--- Validación #2: Revisión de coincidencia en contraseñas. ---> //
else
{
// Condición que hace una revisión de las contraseñas, confirmando que coincidan.
if (user.Password1 == user.ConPassword1)
{
// Mensaje de error que se mostrará sólo si el nombre de usuario insertado ya existe.
if (model.existUser(user.Username1))
{
errorMessage = "El nombre de usuario ya existe. \nFavor de elegir otro nombre...";
}
else
{
/*
* La contraseña insertada por el usuario se encriptará (para eso se llama al método
* de nombre "Encrypt") y lo asignará a la variable "Password1" del objeto "user".
*/
user.Password1 = Encrypt(user.Password1);
/*
* Los usuarios que se registren serán solamente "Usuarios", ya que:
* id 1 = "Administrador".
* id 2 = "Usuario".
*/
user.Id_tipo = 2;
/*
* Se llama al método "registro" mediante un objeto correspondiante a la clase "Model",
* al cual se le enviará el objeto "user", ya que, ese objeto contiene todos los datos registrados por el usuario.
*/
model.register(user);
}
}
else
{
// Mensaje de error que se mostrará si las contraseñas no coinciden.
errorMessage = "Las contraseñas no coinciden. \nFavor de interntarlo nuevamente =).";
}
}
return(errorMessage); // Retorno del mensaje de error.
}
// <--- Método #6: Asignación de los usuarios registrados a una lista ---> //
public List <Object> userQuery(string data)
{
// Este objeto permite leer todos los datos que se encuentren en la base de datos.
MySqlDataReader reader;
// Creación d eun objeto de la clase "Lista<Object>".
List <Object> List = new List <object>();
// Inserción a Sql.
string sql;
// Condición que sólo es válida sí y sólo la tabla se carga por primera vez.
if (data == null)
{
// Inserción.
sql = "SELECT id, Name, Last_name, Username, Email, Password, id_tipo FROM registro_usuarios ORDER BY Username ASC";
}
// Condición que permitirá visualizar los datos registrados.
else
{
// Inserción.
sql = "SELECT id, Name, Last_name, Username, Email, Password, id_tipo FROM registro_usuarios WHERE id LIKE '%" + data + "%' OR Name LIKE '%" + data + "%' OR Last_name LIKE '%" + data + "%' OR Username LIKE '%" + data + "%' OR Email LIKE '%" + data + "%' OR Password LIKE '%" + data + "%' OR id_tipo LIKE '%" + data + "%' ORDER BY Username ASC";
}
try{
MySqlConnection connection = SQLConnection.getConnection();
connection.Open(); // Esta función permite abrir la conexión.
// Se crea un objeto de la clase "MySqlCommand", enviandole como parámetros "sql" y "conexion".
MySqlCommand command = new MySqlCommand(sql, connection);
reader = command.ExecuteReader(); // ".ExecuteReader() es el método que permite realizar la lectura de datos.
while (reader.Read())
{
// Creación de un objeto de la clase "registro_usuarios".
registro_usuarios User = new registro_usuarios();
// Asignación de propiedades.
User.Id = Convert.ToInt32(reader.GetString(0));
User.Name1 = reader[1].ToString();
User.Last_name1 = reader[2].ToString();
User.Username1 = reader[3].ToString();
User.Email1 = reader[4].ToString();
User.Password1 = reader[5].ToString();
User.Id_tipo = Convert.ToInt32(reader[6].ToString());
List.Add(User); // Los datos que se leyeron se agregarán a la lista.
}
}
// "catch" que sólo se activará si se presenta algún tipo de excepción de MySql.
catch (MySqlException ex) {
Console.WriteLine(ex.Message.ToString()); // Mensaje de error.
}
return(List); // Retorno de la lista.
}
// <--- Método #2: Retornar mensajes de error para el formulario de Control de Usuarios (Sólo para administradores). ---> //
public string ctrlregisterAdmins(registro_usuarios userAdmin) // Recibe como parámetro una variable de tipo "registro_usuarios".
{
Model model = new Model(); // Se crea una instancia de la clase "Model".
// Declaración de variable. Esta almacenará los mensajes de error que correspondan.
string errorMessage = "";
// <--- Validación #1: Llenar todos los campos de formulario de registro. ---> //
// Condición que se activará sí y sólo sí alguno de los campos están vacíos.
/*
* ".IsNullOrEmpty() verifica que el campo esté vacío o sea "nulo". de ser así, la condición se cumple.
*/
if (string.IsNullOrEmpty(userAdmin.Name1) || string.IsNullOrEmpty(userAdmin.Last_name1) ||
string.IsNullOrEmpty(userAdmin.Username1) || string.IsNullOrEmpty(userAdmin.Password1) ||
string.IsNullOrEmpty(userAdmin.Email1))
{
errorMessage = "Debe llenar todos los campos"; // Mensaje de error.
}
// <--- Validación #2: Revisión de usuario existente. ---> //
else
{
// Mensaje de error que se mostrará sólo si el nombre de usuario insertado ya existe.
if (model.existUser(userAdmin.Username1))
{
errorMessage = "El nombre de usuario ya existe. \nFavor de elegir otro nombre...";
}
else
{
/*
* La contraseña insertada por el usuario se encriptará (para eso se llama al método
* de nombre "Encypt") y lo asignará a la variable "Password1" del objeto "userAdmin".
*/
userAdmin.Password1 = Encrypt(userAdmin.Password1);
/*
* Los usuarios que se registren serán solamente "Administradores".
*/
userAdmin.Id_tipo = 1;
/*
* Se llama al método "registro" de la clase "model" que se le enviará el objeto "userAdmin",
* ya que, ese objeto contiene todos los datos registrados por el usuario.
*/
model.register(userAdmin);
}
}
return(errorMessage); // Retorno del mensaje de error.
}
// <--- Método #4: Recuperación de contraseña. ---> //
public string ctrlRecoverPassword(string username, string email, string emailpass) // Recibe como parámetros 3 variables de tipo "string", que son "username", "email", "emailpass".
{
Model model = new Model(); // Se crea una instancia de la clase "Model".
// Declaración de variable. Esta almacenará los mensajes de error que correspondan.
string errorMessage = "";
registro_usuarios userData = null;
// <--- Validación #1: Verificar que los campos estén vacíos. ---> //
// Condición que solo es válida sí y sólo sí el usuario no ha insertado su "username" y "password".
if (string.IsNullOrEmpty(username) || string.IsNullOrEmpty(email) || string.IsNullOrEmpty(emailpass))
{
errorMessage = "Debe llenar todos los campos..."; // Mensaje de error.
}
// <--- Validación #2: Traer datos de Sql a mi consulta. ---> //
else
{
// El dato que se recupere de la base de datos se le asignará a la variable "userData".
/*
* Para eso se hace la llamada al método "RecoverPass()", que se encarga de recuperar la contraseña que
* se encuentre registrada en la base de datos.
*/
userData = model.RecoverPass(username);
// <--- Validación #3: Usuario no registrado.. ---> //
// Condición que sólo sea válida sí y sólo sí el usuario no se encuentra o no existe.
if (userData == null)
{
errorMessage = "Lo sentimos, no tenemos a algún usuario registrado con ese nombre."; // Mensaje de error.
}
else
{
// A las propiedades "username" y "password" se les asigna los datos correspondientes.
Session.username = username;
/*
* Para la contraseña, se llama al método "Desencypt", debido a que la contraseña que se encuentra registrada
* en la base de datos, está encriptada.
*/
Session.password = Desencrypt(userData.Password1);
}
}
return(errorMessage); // Retorno del mensaje de error.
}
// <--- Método #3: Validación de nombre de usuario ya existente para el "login" y acceso a la aplicación. ---> //
/*
* Este método es muy parecido al método "existeUsuario". Las diferencias que tiene este método con el mencionado
* son las siguientes:
* 1.- El nombre de este método es "LoginUsuario".
* 2.- Ya no es de tipo "bool", sino de tipo "registro_usuarios" (clase donde se encuentran las propiedades
* de los campos de la tabla "registro_usuarios" de "MySql".
* 3.- Nueva condición "While()".
*/
public registro_usuarios LoginUser(string user)
{
// Este objeto permite leer todos los datos que se encuentren en la base de datos.
MySqlDataReader reader;
MySqlConnection conexion = SQLConnection.getConnection();
conexion.Open(); // Esta función permite abrir la conexión.
// Declaración de variable.
/*
* Esta variable selecciona de la tabla "registro_usuarios" los siguientes datos de los campos correspondientes:
* 1. id. 3. Last_name. 5. Email. 7. id_tipo.
* 2. Name. 4. Username. 6. Password.
* Los selecciona cuando en el campo de la base de datos "username" sea igual al parámetros que está
* iniciando sesión.
*/
string sql = "SELECT id, Name, Last_name, Username, Email, Password, id_tipo FROM registro_usuarios WHERE Username LIKE @Username";
// Se crea un objeto de la clase "MySqlCommand", enviandole como parámetros "sql" y "conexion".
MySqlCommand command = new MySqlCommand(sql, conexion);
command.Parameters.AddWithValue("@Username", user); // Comando para el campo "Username".
reader = command.ExecuteReader(); // ".ExecuteReader() es el método que permite realizar la lectura de datos.
registro_usuarios usr = null; // Declaración de una variable de tipo "registro_usuarios".
while (reader.Read())
{
usr = new registro_usuarios(); // Se crea una instancia de la clase "registro_usuarios".
// Asignación de propiedades.
usr.Id = Convert.ToInt32(reader["id"].ToString());
usr.Name1 = reader["Name"].ToString();
usr.Last_name1 = reader["Last_name"].ToString();
usr.Email1 = reader["Email"].ToString();
usr.Password1 = reader["Password"].ToString();
usr.Id_tipo = Convert.ToInt32(reader["id_tipo"].ToString());
}
return(usr); // Retorno de los datos acumulados en la variable, correspondientes a la consulta.
}
// <---------------------------------------> //
// <---------- MÉTODOS / METHODS ----------> //
// <---------------------------------------> //
// <--- Método #1: Validación de datos y registro de usuarios ---> //
public int register(registro_usuarios user) // Recibe como parámetro una variable del tipo "registro_usuarios".
// Referencia a la clase de nombre "SQLConnection".
{
MySqlConnection conexion = SQLConnection.getConnection();
conexion.Open(); // Esta función permite abrir la conexión.
// Inserción a "SQL".
/*
* "INSERT INTO" se utiliza para "seleccionar" los campos de la tabla "registro_usuarios"
* donde se insertarán los datos que registre el usuario.
* "VALUES" son los valores que se van a registrar en la tabla de "MySql".
*/
string sql = "INSERT INTO registro_usuarios (Name, Last_name, Username, Email, Password, id_tipo) VALUES (@Name, @Last_name, @Username, @Email, @Password, @id_tipo)";
// Se crea un objeto de la clase "MySqlCommand", enviandole como parámetros "sql" y "conexion".
MySqlCommand command = new MySqlCommand(sql, conexion);
/*
* Se crean "comandos" que realizan la acción de enviar los datos que el ususario registre
* a "MySql", permitiendo así, guardar su información.
*
* ".AddWithValue() recibe dos parámetros, el primero es el valor que recibirá el comando
* (Valores con "@") y el segundo es el dato que el usuario haya ingresado (un dato de tipo "usuario"
* con la propiedad de la clase "registro_usuario").
*/
command.Parameters.AddWithValue("@Name", user.Name1); // Comando para el campo "Name".
command.Parameters.AddWithValue("@Last_name", user.Last_name1); // Comando para el campo "Last_name".
command.Parameters.AddWithValue("@Username", user.Username1); // Comando para el campo "Username".
command.Parameters.AddWithValue("@Email", user.Email1); // Comando para el campo "Email".
command.Parameters.AddWithValue("@Password", user.Password1); // Comando para el campo "Password".
command.Parameters.AddWithValue("@id_tipo", user.Id_tipo); // Comando para el campo "id_tipo".
// Declaración de variables.
int resultado = command.ExecuteNonQuery(); // Te devuelve el número de "filas" que se hayan insertado.
return(resultado); // Retorno de valor.
}
// <---------------------------------------> //
// <---------- BOTONES / BUTTONS ----------> //
// <---------------------------------------> //
// <--- Botón "btnRegister" ---> //
private void btnRegister_Click(object sender, EventArgs e)
{
registro_usuarios user = new registro_usuarios(); // Creación de un objeto de la clase "registro_usuarios".
/*
* Asiganción de los datos de los "textbox" del formulario de registro a las propiedades
* del objeto "usuario".
*/
user.Name1 = txtSignName.Text;
user.Last_name1 = txtSignLastName.Text;
user.Username1 = txtSignUsername.Text;
user.Email1 = txtSignEmail.Text;
user.Password1 = txtSignPassword.Text;
user.ConPassword1 = txtConfirmPass.Text;
try{
Control control = new Control(); // Creación de un objeto de la clase "Control".
string answer = control.ctrlRegister(user); // Llamada al método "ctrlRegistro", enviandole como parámetro el objeto "usuario".
if (answer.Length > 0)
{
// "MessageBox" que se mostrará al usuario para avisar de algun error.
MessageBox.Show(answer, "Aviso.", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
// "MessageBox" que se mostrará al usuario para confirmar su registro.
if (MessageBox.Show("¡Usuario registrado! \n¡Ya puede iniciar sesión y empezar a utilizar nuestra aplicación!", "Datos registrados.", MessageBoxButtons.OK, MessageBoxIcon.Information) == DialogResult.OK)
{
Login LoginForm = new Login(); // Creación de un objeto de la clase "Login".
LoginForm.Show(); // ".Show()" permitirá mostrar el formulario de inicio de sesión.
this.Hide(); // ".Hide() ocultará el formulario actual (RegistrerUsers).
}
}
}
catch (Exception ex) {
MessageBox.Show(ex.Message);
}
}
// <--- Método #4: Recuperación de contraseña. ---> //
/*
* Este método permite recuperar la contraseña de usuario.
*/
public registro_usuarios RecoverPass(string usuario)
{
// Este objeto permite leer todos los datos que se encuentren en la base de datos.
MySqlDataReader reader;
MySqlConnection conexion = SQLConnection.getConnection();
conexion.Open(); // Esta función permite abrir la conexión.
// Declaración de variable.
/*
* Esta variable selecciona de la tabla "registro_usuarios" los siguientes datos de los campos correspondientes:
* 1. Username.
* Los selecciona cuando en el campo de la base de datos "username" sea igual al parámetros que está
* tratando de recuperar su contraseña.
*/
string sql = "SELECT id, username, password FROM registro_usuarios WHERE Username LIKE @Username";;
// Se crea un objeto de la clase "MySqlCommand", enviandole como parámetros "sql" y "conexion".
MySqlCommand command = new MySqlCommand(sql, conexion);
command.Parameters.AddWithValue("@Username", usuario); // Comando para el campo "Username".
reader = command.ExecuteReader(); // ".ExecuteReader() es el método que permite realizar la lectura de datos.
registro_usuarios usr = null; // Declaración de una variable de tipo "registro_usuarios".
while (reader.Read())
{
usr = new registro_usuarios(); // Se crea una instancia de la clase "registro_usuarios".
// Asignación de propiedades.
usr.Username1 = reader["Username"].ToString();
usr.Password1 = reader["Password"].ToString();
}
return(usr); // Retorno de los datos acumulados en la variable, correspondientes a la consulta.
}
// <--- Método #3: Comprobación de usuario existente para el inicio de sesión. ---> //
public string crtlLogin(string username, string password) // Recibe como parámetros 2 variables de tipo "string": "usuario" y "password".
{
Model model = new Model(); // Se crea una instancia de la clase "Model".
// Declaración de variable. Esta almacenará los mensajes de error que correspondan.
string errorMessage = "";
registro_usuarios userData = null;
// <--- Validación #1: Verificar que los campos estén vacíos. ---> //
// Condición que solo es válida sí y sólo sí el usuario no ha insertado su "username" y "password".
if (string.IsNullOrEmpty(username) || string.IsNullOrEmpty(password))
{
errorMessage = "Debe llenar todos los campos..."; // Mensaje de error.
}
// <--- Validación #2: Traer datos de Sql a mi consulta. ---> //
else
{
// El dato que se recupere de la base de datos se le asignará a la variable "datosUsuario".
/*
* Para eso se hace la llamada al método "LoginUsuario()", que se encarga de hacer las consultas a la
* base de datos "registro_usuarios", enviandole como parámetro la variable "username".
*/
userData = model.LoginUser(username);
// <--- Validación #3: Usuario no registrado.. ---> //
// Condición que sólo sea válida sí y sólo sí el usuario no se encuentra o no existe.
if (userData == null)
{
errorMessage = "El usuario no existe."; // Mensaje de error.
}
// <--- Validación #3: Usuario registrado. ---> //
else
{
/*
* Condición que sólo sea válida sí y sólo sí la contraseña registrada en la base de datos (Base 64)
* es diferente a la contraseña ingresada por el usuario.
* Como la contraseña que ingresa el usuario no está en formato "Base 64", se llamará al método "Encrypt"
* para realizar dicha conversión, permitiendo que el método funcione correctamente.
*/
if (userData.Password1 != Encrypt(password))
{
errorMessage = "El usuario y/o contraseñas no coinciden..."; // Mensaje de error.
}
// <--- Validación #4: Datos de usuario que está iniciando sesión. ---> //
else
{
/*
* Asignación de la propiedad de la clase "registro_usuarios" al objeto "datosUsuario"
* a las variables de la clase "Session".
*/
Session.id = userData.Id;
Session.name = userData.Name1;
Session.last_name = userData.Last_name1;
Session.email = userData.Email1;
Session.password = userData.Password1;
Session.id_tipo = userData.Id_tipo;
/*
* A este objeto se le asigna la variable "username" directamente ya que se envía como
* parámetro al método "ctrlLogin()".
*/
Session.username = username;
}
}
}
return(errorMessage); // Retorno del mensaje de error.
}