//MySqlConnection conex = new MySqlConnection(Properties.Settings.Default.connectionStringJ);
// connectionStringJ (Juan Diego)
// connectionStringM (Melany)
// connectionString (Asoc. Acompañame)
/// <summary>
/// Retorna los datos de la cuenta asociada al nombre de usuario y la contraseña
/// </summary>
/// <param name="id">Nombre de usuario de la cuenta</param>
/// <param name="contra">Contraseña asociada al nombre de usuario</param>
/// <returns>Demás datos de la cuenta</returns>
public TOCuenta buscarCuenta(string id, string contra)
{
TOCuenta cuenta = new TOCuenta();
MySqlCommand buscar = new MySqlCommand("select * from cuenta where idUsuario = @id and contrasenna = @contra", conex);
buscar.Parameters.AddWithValue("@id", id);
buscar.Parameters.AddWithValue("@contra", contra);
if (conex.State != ConnectionState.Open)
{
conex.Open();
}
MySqlDataReader reader = buscar.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
cuenta.idUsuario = reader.GetString(0);
cuenta.nombreEmpleado = reader.GetString(1);
cuenta.contrasenna = reader.GetString(2);
cuenta.privilegio = reader.GetString(3);
cuenta.estado = reader.GetBoolean(4);
}
}
if (conex.State != ConnectionState.Closed)
{
conex.Close();
}
return(cuenta);
}
/// <summary>
/// Retorna una lista con todas las cuentas existentes en el sistema
/// </summary>
/// <returns>Lista de cuentas en el sistema</returns>
public List <TOCuenta> listaCuentas()
{
if (conex.State != ConnectionState.Open)
{
conex.Open();
}
String qry = "select * from cuenta;";
MySqlCommand cmd = new MySqlCommand(qry, conex);
MySqlDataReader reader = cmd.ExecuteReader();
List <TOCuenta> lista = new List <TOCuenta>();
if (reader.HasRows)
{
while (reader.Read())
{
TOCuenta to = new TOCuenta();
to.idUsuario = reader.GetString(0);
to.nombreEmpleado = reader.GetString(1);
to.contrasenna = reader.GetString(2);
to.privilegio = reader.GetString(3);
to.estado = reader.GetBoolean(4);
lista.Add(to);
}
}
if (conex.State != ConnectionState.Closed)
{
conex.Close();
}
return(lista);
}
/// <summary>
/// Ingresa una nueva cuenta de usuario al sistema
/// </summary>
/// <param name="cuenta">Cuenta a ingresar. Objeto que contiene los datos de la cuenta</param>
public void insertarCuenta(TOCuenta cuenta)
{
//String query = "begin tran if exists(select * from cuenta with (updlock, serializable) where idUsuario = @id) " +
// "begin update cuenta set nombreEmpleado = @nombre, contrasenna = @contra, privilegio = @priv, estado = @estado where " +
// "idUsuario = @id; end else begin insert into cuenta(idUsuario, nombreEmpleado, contrasenna, privilegio, estado) " +
// "values (@id, @nombre, @contra, @priv, @estado); end commit tran;";
String query = "insert into cuenta(idUsuario, nombreEmpleado, contrasenna, privilegio, estado) values (@id, @nombre, @contra, @priv, @estado);";
MySqlCommand sentencia = new MySqlCommand(query, conex);
sentencia.Parameters.AddWithValue("@id", cuenta.idUsuario);
sentencia.Parameters.AddWithValue("@contra", cuenta.contrasenna);
sentencia.Parameters.AddWithValue("@nombre", cuenta.nombreEmpleado);
sentencia.Parameters.AddWithValue("@priv", cuenta.privilegio);
sentencia.Parameters.AddWithValue("@estado", cuenta.estado);
if (conex.State != ConnectionState.Open)
{
conex.Open();
}
sentencia.ExecuteNonQuery();
if (conex.State != ConnectionState.Closed)
{
conex.Close();
}
}
private TOCuenta ValidarCuenta(TOCuenta toCuenta)
{
if ((!toCuenta.Correo.Contains("@")) || (toCuenta.Correo == null) || (toCuenta.Correo.Equals("")) ||
(toCuenta.Contrasenna == null) || (toCuenta.Contrasenna.Equals("")) ||
(toCuenta.Rol == null) || (toCuenta.Rol.Equals("")) || (toCuenta.Rol.Equals("nulo")) ||
(toCuenta.Estado == null) || (toCuenta.Estado.Equals("")) ||
(toCuenta.IdCuenta == null) || (toCuenta.IdCuenta.Equals("")))
{
return(null);
}
return(toCuenta);
}
public BLCuenta buscarCuenta(string idCuenta, string contra)
{
//try
//{
DAOCuenta daoCuent = new DAOCuenta();
TOCuenta cuentaTO = daoCuent.buscarCuenta(idCuenta, contra);
if (cuentaTO == null)
{
return(null);
}
return(convert(cuentaTO));
}
public string ActualizarEstados(List <BLCuenta> cuentas)
{
List <TOCuenta> to = new List <TOCuenta>();
foreach (BLCuenta c in cuentas)
{
TOCuenta nueva = new TOCuenta();
nueva.IdCuenta = c.IdCuenta;
nueva.Estado = c.Estado;
to.Add(nueva);
}
DAOCuenta daoCuenta = new DAOCuenta();
return(daoCuenta.ActualizarEstados(to));
}
public string ActualizarCuenta(BLCuenta blCuenta, BLUsuario blUsuario, BLMedico blMedico)
{
string confirmacion = "Error: Indefinido.";
if (blCuenta != null && blUsuario != null)
{
TOCuenta toCuenta = new TOCuenta(blCuenta.IdCuenta.Trim(), blCuenta.Correo.Trim(), blCuenta.Contrasenna.Trim(),
blCuenta.Rol.Trim(), blCuenta.Estado.Trim());
TOUsuario toUsuario = new TOUsuario(blUsuario.Cedula.Trim(), blUsuario.Nombre.Trim(),
blUsuario.PrimerApellido.Trim(), blUsuario.SegundoApellido.Trim(),
blUsuario.Telefono, blUsuario.CodigoAsistente);
TOMedico toMedico = null;
toCuenta = ValidarCuenta(toCuenta);
if (toCuenta != null)
{
toUsuario = ValidarUsuario(toUsuario, toCuenta.Rol);
}
if (toCuenta != null && toUsuario != null)
{
if (toCuenta.Rol.Equals("medico") && blMedico != null)
{
toMedico = new TOMedico(blMedico.IdMedico.Trim(), blMedico.CodigoMedico.Trim(),
blMedico.Especialidad.Trim(), blMedico.DuracionCita.Trim());
toMedico = ValidarMedico(toMedico);
if (toMedico == null)
{
return("Error: Puede que algunos datos se encuentren vacíos o con un formato incorrecto.");
}
}
DAOCuenta daoCuenta = new DAOCuenta();
return(daoCuenta.ActualizarCuenta(toCuenta, toUsuario, toMedico));
}
else
{
return("Error: Puede que algunos datos se encuentren vacíos o con un formato incorrecto.");
}
}
return(confirmacion);
}
//catch (Exception)
//{
// throw;
//}
//}
public BLCuenta obtenerCuenta(string idCuenta)
{
//try
//{
DAOCuenta daoCuenta = new DAOCuenta();
TOCuenta empleadoTO = daoCuenta.obtenerCuenta(idCuenta);
//if (empleadoTO == null)
//{
// return null;
//}
return(convert(empleadoTO));
//}
//catch (Exception)
//{
// throw;
//}
}
//catch (Exception)
//{
// throw;
//}
//}
public TOCuenta obtenerCuenta(string id)
{
//try
//{
TOCuenta cuenta = new TOCuenta();
MySqlCommand buscar = new MySqlCommand("SELECT * FROM cuenta WHERE idcuenta = @id", conexion);
buscar.Parameters.AddWithValue("@id", id);
if (conexion.State != ConnectionState.Open)
{
conexion.Open();
}
MySqlDataReader reader = buscar.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
cuenta.id = reader.GetString(0);
cuenta.contrasenna = reader.GetString(1);
cuenta.nombreEmpleado = reader.GetString(2);
cuenta.rol = reader.GetString(3);
cuenta.estado = reader.GetBoolean(4);
}
}
if (conexion.State != ConnectionState.Closed)
{
conexion.Close();
}
return(cuenta);
//}
//catch (Exception)
//{
// throw;
//}
}
public string CargarUsuario(BLCuenta cuenta, BLUsuario usuario, BLMedico medico)
{
string confirmacion = "Error: Indefinido.";
TOCuenta toCuenta = new TOCuenta();
toCuenta.IdCuenta = cuenta.IdCuenta;
TOUsuario toUsuario = new TOUsuario();
TOMedico toMedico = new TOMedico();
DAOCuenta dao = new DAOCuenta();
confirmacion = dao.CargarUsuario(toCuenta, toUsuario, toMedico);
if (!confirmacion.Contains("Error:"))
{
cuenta.Correo = toCuenta.Correo;
cuenta.Rol = toCuenta.Rol;
cuenta.Estado = toCuenta.Estado;
cuenta.Contrasenna = toCuenta.Contrasenna;
usuario.Cedula = toUsuario.Cedula;
usuario.Nombre = toUsuario.Nombre;
usuario.PrimerApellido = toUsuario.PrimerApellido;
usuario.SegundoApellido = toUsuario.SegundoApellido;
usuario.Telefono = toUsuario.Telefono;
usuario.CodigoAsistente = toUsuario.CodigoAsistente;
if (toCuenta.Rol.Equals("medico"))
{
medico.IdMedico = toMedico.IdMedico;
medico.CodigoMedico = toMedico.CodigoMedico;
medico.Especialidad = toMedico.Especialidad;
medico.DuracionCita = toMedico.DuracionCita;
}
}
return(confirmacion);
}
public List <TOCuenta> listaCuentas()
{
//try
//{
string select = "select * from cuenta";
MySqlCommand sentencia = new MySqlCommand(select, conexion);
DataTable table = new DataTable();
MySqlDataAdapter adapter = new MySqlDataAdapter();
adapter.SelectCommand = sentencia;
adapter.Fill(table);
List <TOCuenta> lista = new List <TOCuenta>();
for (int x = 0; x < table.Rows.Count; x++)
{
TOCuenta cuenta = new TOCuenta();
cuenta.id = Convert.ToString(table.Rows[x]["idcuenta"]);
cuenta.contrasenna = Convert.ToString(table.Rows[x]["contrasenna"]);
cuenta.rol = Convert.ToString(table.Rows[x]["nombreEmpleado"]);
cuenta.nombreEmpleado = Convert.ToString(table.Rows[x]["rol"]);
cuenta.estado = Convert.ToBoolean(table.Rows[x]["estado"]);
lista.Add(cuenta);
}
return(lista);
// }
// catch (SqlException)
// {
// throw;
// }
// catch (Exception)
// {
// throw;
// }
// finally
// {
// conexion.Close();
// }
}
public void insertarActualizarCuenta(TOCuenta empleado)
{
//try
//{
string update = "begin tran if exists(select * from cuenta with (updlock, serializable) where idcuenta = @idCuenta) begin update cuenta set contrasenna = @contra, rol = @rol, nombreEmpleado = @nombre, estado = @estado where idcuenta = @idCuenta; end else begin insert into cuenta(idcuenta, contrasenna, nombreEmpleado, rol, estado) values(@idCuenta, @contra, @rol, @nombre, @estado); end commit tran";
MySqlCommand sentencia = new MySqlCommand(update, conexion);
sentencia.Parameters.AddWithValue("@idCuenta", empleado.id);
sentencia.Parameters.AddWithValue("@contra", empleado.contrasenna);
sentencia.Parameters.AddWithValue("@rol", empleado.rol);
sentencia.Parameters.AddWithValue("@nombre", empleado.nombreEmpleado);
sentencia.Parameters.AddWithValue("@estado", empleado.estado);
if (conexion.State != ConnectionState.Open)
{
conexion.Open();
}
sentencia.ExecuteNonQuery();
if (conexion.State != ConnectionState.Closed)
{
conexion.Close();
}
//}
//catch (SqlException)
//{
// throw;
//}
//catch (Exception)
//{
// throw;
//}
//finally
//{
// conexion.Close();
//}
}
/// <summary>
/// Modifica los datos de una cuenta del sistema
/// </summary>
/// <param name="cuenta">Cuenta a modificar y datos de la nueva cuenta</param>
/// <returns>True en caso de que la cuenta se haya modificado correctamente, false de lo contrario</returns>
public bool actualizarCuenta(TOCuenta cuenta)
{
if (conex.State != ConnectionState.Open)
{
conex.Open();
}
String qry = "update cuenta set nombreEmpleado = @nombre, contrasenna = @contra, privilegio = @priv, estado = @est, estado = @est where idUsuario = @idCuenta";
MySqlCommand cmd = new MySqlCommand(qry, conex);
cmd.Parameters.AddWithValue("@idCuenta", cuenta.idUsuario);
cmd.Parameters.AddWithValue("@nombre", cuenta.nombreEmpleado);
cmd.Parameters.AddWithValue("@priv", cuenta.privilegio);
cmd.Parameters.AddWithValue("@est", cuenta.estado);
cmd.Parameters.AddWithValue("@contra", cuenta.contrasenna);
int result = cmd.ExecuteNonQuery();
if (conex.State != ConnectionState.Closed)
{
conex.Close();
}
return(result > 0 ? true : false);
}
public string IniciarSesion(BLCuenta cuenta, BLUsuario usuario)
{
string confirmacion = "Error: Indefinido.";
TOCuenta toCuenta = new TOCuenta(cuenta.IdCuenta, "", cuenta.Contrasenna, "", "");
TOUsuario toUsuario = new TOUsuario();
DAOCuenta dao = new DAOCuenta();
confirmacion = dao.IniciarSesion(toCuenta, toUsuario);
if (!confirmacion.Contains("Error:"))
{
cuenta.Rol = toCuenta.Rol;
usuario.Nombre = toUsuario.Nombre;
usuario.PrimerApellido = toUsuario.PrimerApellido;
usuario.SegundoApellido = toUsuario.SegundoApellido;
usuario.CodigoAsistente = toUsuario.CodigoAsistente;
}
return(confirmacion);
}
//MySqlConnection conexion = new MySqlConnection(Properties.Settings.Default.connectionStringJ);
public TOCuenta buscarCuenta(string idEmpleado, string contra)
{
//try
//{
TOCuenta empleado = new TOCuenta();
MySqlCommand buscar = new MySqlCommand("SELECT * FROM cuenta WHERE idcuenta = @id and contrasenna = @contra", conexion);
buscar.Parameters.AddWithValue("@id", idEmpleado);
buscar.Parameters.AddWithValue("@contra", contra);
if (conexion.State != ConnectionState.Open)
{
conexion.Open();
}
MySqlDataReader reader = buscar.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
empleado.id = reader.GetString(0);
empleado.contrasenna = reader.GetString(1);
empleado.nombreEmpleado = reader.GetString(2);
empleado.rol = reader.GetString(3);
empleado.estado = reader.GetBoolean(4);
}
}
if (conexion.State != ConnectionState.Closed)
{
conexion.Close();
}
return(empleado);
}
/// <summary>
/// Convierte una cuenta de la capa de Objetos de Transferencia (TO) a la capa Lógica de Negocios. Método usado
/// localmente
/// </summary>
/// <param name="cuenta">Cuenta de Objetos de Transferencia a convertir</param>
/// <returns>Cuenta de Lógica de Negocios convertida</returns>
private BLCuenta convert(TOCuenta cuenta)
{
return new BLCuenta(cuenta.idUsuario, cuenta.nombreEmpleado, cuenta.contrasenna, cuenta.privilegio, cuenta.estado);
}
public string IniciarSesion(TOCuenta cuenta, TOUsuario usuario)
{
string confirmacion = "La sesión se ha iniciado correctamente.";
// Se abre la conexión
if (conexion != null)
{
try
{
if (conexion.State != ConnectionState.Open)
{
conexion.Open();
}
}
catch (Exception)
{
confirmacion = "Error: No se pudo iniciar la sesión de usuario";
return(confirmacion);
}
}
else
{
confirmacion = "Error: No se pudo iniciar la sesión de usuario";
return(confirmacion);
}
// Se inicia una nueva transacción
SqlTransaction transaccion = null;
try
{
transaccion = conexion.BeginTransaction("Iniciar sesión de usuario");
// Se crea un nuevo comando con la secuencia SQL y el objeto de conexión
SqlCommand comando = new SqlCommand();
comando.Connection = conexion;
comando.CommandText = "SELECT ROL FROM CUENTA_USUARIO WHERE ID_CUENTA = @idCuenta AND CONTRASENNA = @contrasenna AND ESTADO = 'activa'";
comando.Transaction = transaccion;
// Se ejecuta el comando y se realiza un commit de la transacción
comando.Parameters.AddWithValue("@idCuenta", cuenta.IdCuenta);
comando.Parameters.AddWithValue("@contrasenna", cuenta.Contrasenna);
SqlDataReader lector = comando.ExecuteReader();
if (lector.HasRows)
{
while (lector.Read())
{
cuenta.Rol = lector["ROL"].ToString();
}
}
else
{
cuenta.IdCuenta = "";
confirmacion = "Error: El usuario no existe o la cuenta se encuentra inactiva";
}
lector.Close();
comando.Parameters.Clear();
if (!cuenta.IdCuenta.Equals(""))
{
comando.CommandText = "SELECT NOMBRE, PRIMER_APELLIDO, SEGUNDO_APELLIDO, CODIGO_ASISTENTE FROM USUARIO WHERE CEDULA = @cedula";
comando.Parameters.AddWithValue("@cedula", cuenta.IdCuenta);
lector = comando.ExecuteReader();
if (lector.HasRows)
{
while (lector.Read())
{
usuario.Nombre = lector["NOMBRE"].ToString();
usuario.PrimerApellido = lector["PRIMER_APELLIDO"].ToString();
usuario.SegundoApellido = lector["SEGUNDO_APELLIDO"].ToString();
if (cuenta.Rol.Equals("asistente"))
{
usuario.CodigoAsistente = lector["CODIGO_ASISTENTE"].ToString();
}
}
}
lector.Close();
comando.Parameters.Clear();
if (cuenta.Rol.Equals("medico"))
{
comando.CommandText = "SELECT CODIGO_MEDICO FROM MEDICO WHERE ID_MEDICO = @idMedico";
comando.Parameters.AddWithValue("@idMedico", cuenta.IdCuenta);
lector = comando.ExecuteReader();
if (lector.HasRows)
{
while (lector.Read())
{
usuario.CodigoAsistente = lector["CODIGO_MEDICO"].ToString();
}
}
lector.Close();
}
}
transaccion.Commit();
}
catch (Exception)
{
try
{
// En caso de un error se realiza un rollback a la transacción
transaccion.Rollback();
}
catch (Exception)
{
}
finally
{
confirmacion = "Error: No se pudo iniciar la sesión de usuario";
}
}
finally
{
if (conexion.State != ConnectionState.Closed)
{
conexion.Close();
}
}
return(confirmacion);
}
public string ActualizarCuenta(TOCuenta toCuenta, TOUsuario toUsuario, TOMedico toMedico)
{
string confirmacion = "La cuenta se actualizó exitosamente";
// Se abre la conexión
if (conexion != null)
{
try
{
if (conexion.State != ConnectionState.Open)
{
conexion.Open();
}
}
catch (Exception)
{
confirmacion = "Error: No se pudo actualizar la cuenta en el sistema";
return(confirmacion);
}
}
else
{
confirmacion = "Error: No se pudo actualizar la cuenta en el sistema";
return(confirmacion);
}
// Se inicia una nueva transacción
SqlTransaction transaccion = null;
try
{
transaccion = conexion.BeginTransaction("Actualizar una cuenta");
// Se crea un nuevo comando con la secuencia SQL y el objeto de conexión
SqlCommand comando = new SqlCommand();
comando.Connection = conexion;
comando.CommandText = "UPDATE CUENTA_USUARIO SET " +
"CORREO = @correo, " +
"CONTRASENNA = @contrasenna, " +
"ROL = @rol, " +
"ESTADO = @estado " +
"WHERE ID_CUENTA = @id";
comando.Transaction = transaccion;
// Se asigna un valor a los parámetros del comando a ejecutar
comando.Parameters.AddWithValue("@id", toCuenta.IdCuenta);
comando.Parameters.AddWithValue("@correo", toCuenta.Correo);
comando.Parameters.AddWithValue("@contrasenna", toCuenta.Contrasenna);
comando.Parameters.AddWithValue("@rol", toCuenta.Rol);
comando.Parameters.AddWithValue("@estado", toCuenta.Estado);
// Se ejecuta el comando y se realiza un commit de la transacción
comando.ExecuteNonQuery();
comando.Parameters.Clear();
comando.CommandText = "UPDATE USUARIO SET " +
"NOMBRE = @nombre, " +
"PRIMER_APELLIDO = @primer, " +
"SEGUNDO_APELLIDO = @segundo, " +
"TELEFONO = @telefono, " +
"CODIGO_ASISTENTE = @codigoAsistente " +
"WHERE CEDULA = @cedula;";
// Se asigna un valor a los parámetros del comando a ejecutar
comando.Parameters.AddWithValue("@cedula", toUsuario.Cedula);
comando.Parameters.AddWithValue("@nombre", toUsuario.Nombre);
comando.Parameters.AddWithValue("@primer", toUsuario.PrimerApellido);
comando.Parameters.AddWithValue("@segundo", toUsuario.SegundoApellido);
comando.Parameters.AddWithValue("@telefono", toUsuario.Telefono);
comando.Parameters.AddWithValue("@codigoAsistente", toUsuario.CodigoAsistente);
// Se ejecuta el comando y se realiza un commit de la transacción
comando.ExecuteNonQuery();
comando.Parameters.Clear();
if (toCuenta.Rol.Equals("medico") && toMedico != null)
{
comando.CommandText = "UPDATE MEDICO SET " +
"CODIGO_MEDICO = @codigo, " +
"ESPECIALIDAD = @especialidad, " +
"DURACION_CITA = @duracion " +
"WHERE ID_MEDICO = @id;";
// Se asigna un valor a los parámetros del comando a ejecutar
comando.Parameters.AddWithValue("@id", toMedico.IdMedico);
comando.Parameters.AddWithValue("@codigo", toMedico.CodigoMedico);
comando.Parameters.AddWithValue("@especialidad", toMedico.Especialidad);
comando.Parameters.AddWithValue("@duracion", toMedico.DuracionCita);
// Se ejecuta el comando y se realiza un commit de la transacción
comando.ExecuteNonQuery();
}
transaccion.Commit();
}
catch (Exception)
{
try
{
// En caso de un error se realiza un rollback a la transacción
transaccion.Rollback();
}
catch (Exception)
{
}
finally
{
confirmacion = "Error: No se pudo actualizar la cuenta en el sistema";
}
}
finally
{
if (conexion.State != ConnectionState.Closed)
{
conexion.Close();
}
}
return(confirmacion);
}
public string CargarUsuario(TOCuenta cuenta, TOUsuario usuario, TOMedico medico)
{
string confirmacion = "El usuario se cargó exitosamente";
// Se abre la conexión
if (conexion != null)
{
try
{
if (conexion.State != ConnectionState.Open)
{
conexion.Open();
}
}
catch (Exception)
{
confirmacion = "Error: No se puede cargar los datos de usuario";
return(confirmacion);
}
}
else
{
confirmacion = "Error: No se puede cargar los datos de usuario";
return(confirmacion);
}
// Se inicia una nueva transacción
SqlTransaction transaccion = null;
try
{
transaccion = conexion.BeginTransaction("Cargar datos de usuario");
// Se crea un nuevo comando con la secuencia SQL y el objeto de conexión
SqlCommand comando = new SqlCommand();
comando.Connection = conexion;
comando.CommandText = "SELECT CORREO, ROL, ESTADO, CONTRASENNA FROM CUENTA_USUARIO WHERE ID_CUENTA = @idCuenta";
comando.Transaction = transaccion;
// Se ejecuta el comando y se realiza un commit de la transacción
comando.Parameters.AddWithValue("@idCuenta", cuenta.IdCuenta);
SqlDataReader lector = comando.ExecuteReader();
if (lector.HasRows)
{
while (lector.Read())
{
cuenta.Correo = lector["CORREO"].ToString();
cuenta.Rol = lector["ROL"].ToString();
cuenta.Estado = lector["ESTADO"].ToString();
cuenta.Contrasenna = lector["CONTRASENNA"].ToString();
}
}
else
{
cuenta.IdCuenta = "";
}
lector.Close();
comando.Parameters.Clear();
if (!cuenta.IdCuenta.Equals(""))
{
comando.CommandText = "SELECT * FROM USUARIO WHERE CEDULA = @cedula";
comando.Parameters.AddWithValue("@cedula", cuenta.IdCuenta);
lector = comando.ExecuteReader();
if (lector.HasRows)
{
while (lector.Read())
{
usuario.Cedula = lector["CEDULA"].ToString();
usuario.Nombre = lector["NOMBRE"].ToString();
usuario.PrimerApellido = lector["PRIMER_APELLIDO"].ToString();
usuario.SegundoApellido = lector["SEGUNDO_APELLIDO"].ToString();
usuario.Telefono = lector["TELEFONO"].ToString();
usuario.CodigoAsistente = lector["CODIGO_ASISTENTE"].ToString();
}
}
lector.Close();
comando.Parameters.Clear();
if (cuenta != null)
{
if (cuenta.Rol.Equals("medico"))
{
comando.CommandText = "SELECT * FROM MEDICO WHERE ID_MEDICO = @idMedico";
comando.Parameters.AddWithValue("@idMedico", cuenta.IdCuenta);
lector = comando.ExecuteReader();
if (lector.HasRows)
{
while (lector.Read())
{
medico.IdMedico = lector["ID_MEDICO"].ToString();
medico.CodigoMedico = lector["CODIGO_MEDICO"].ToString();
medico.Especialidad = lector["ESPECIALIDAD"].ToString();
medico.DuracionCita = lector["DURACION_CITA"].ToString();
}
}
lector.Close();
}
}
}
else
{
confirmacion = "Error: El usuario no existe";
}
transaccion.Commit();
}
catch (Exception)
{
try
{
// En caso de un error se realiza un rollback a la transacción
transaccion.Rollback();
}
catch (Exception)
{
}
finally
{
confirmacion = "Error: No se puede cargar los datos de usuario";
}
}
finally
{
if (conexion.State != ConnectionState.Closed)
{
conexion.Close();
}
}
return(confirmacion);
}
public string CargarUsuarios(List <TOCuenta> cuentas, List <TOUsuario> usuarios)
{
string confirmacion = "Las cuentas de usuario se cargaron exitosamente";
// Se abre la conexión
if (conexion != null)
{
try
{
if (conexion.State != ConnectionState.Open)
{
conexion.Open();
}
}
catch (Exception)
{
confirmacion = "Error: No se pueden cargar las cuentas de usuario";
return(confirmacion);
}
}
else
{
confirmacion = "Error: No se pueden cargar las cuentas de usuario";
return(confirmacion);
}
// Se inicia una nueva transacción
SqlTransaction transaccion = null;
try
{
transaccion = conexion.BeginTransaction("Cargar cuentas de usuario");
// Se crea un nuevo comando con la secuencia SQL y el objeto de conexión
SqlCommand comando = new SqlCommand();
comando.Connection = conexion;
comando.CommandText = "SELECT ID_CUENTA, CORREO, ESTADO FROM CUENTA_USUARIO";
comando.Transaction = transaccion;
// Se ejecuta el comando y se realiza un commit de la transacción
SqlDataReader lector = comando.ExecuteReader();
if (lector.HasRows)
{
while (lector.Read())
{
TOCuenta temp = new TOCuenta();
temp.IdCuenta = lector["ID_CUENTA"].ToString();
temp.Correo = lector["CORREO"].ToString();
temp.Estado = lector["ESTADO"].ToString();
cuentas.Add(temp);
}
}
lector.Close();
comando.CommandText = "SELECT CEDULA, NOMBRE, PRIMER_APELLIDO, SEGUNDO_APELLIDO, TELEFONO FROM USUARIO";
lector = comando.ExecuteReader();
if (lector.HasRows)
{
while (lector.Read())
{
TOUsuario temp = new TOUsuario(lector["CEDULA"].ToString(), lector["NOMBRE"].ToString(),
lector["PRIMER_APELLIDO"].ToString(), lector["SEGUNDO_APELLIDO"].ToString(),
lector["TELEFONO"].ToString(), "");
usuarios.Add(temp);
}
}
lector.Close();
transaccion.Commit();
}
catch (Exception)
{
try
{
// En caso de un error se realiza un rollback a la transacción
transaccion.Rollback();
}
catch (Exception)
{
}
finally
{
confirmacion = "Error: No se pueden cargar las cuentas de usuario";
}
}
finally
{
if (conexion.State != ConnectionState.Closed)
{
conexion.Close();
}
}
return(confirmacion);
}
/// <summary>
/// Sustituye la contraseña por un valor aleatorio que es enviado por mensaje de correo
/// </summary>
/// <param name="myTOCuenta">Recibe un objeto con los atributos de la cuenta que se desea modificar</param>
public void recuperarContraseña(TOCuenta myTOCuenta)
{
// Se abre la conexión
if (conexion != null)
{
try
{
if (conexion.State != ConnectionState.Open)
{
conexion.Open();
}
}
catch (Exception)
{
//confirmacion = "Ocurrio un error y no se pudo cargar los expedientes";
//return confirmacion;
}
}
else
{
//confirmacion = "Ocurrio un error y no se pudo cargar los expedientes";
//return confirmacion;
}
// Se inicia una nueva transacción
SqlTransaction transaccion = null;
try
{
transaccion = conexion.BeginTransaction("Editar contraseña");
// Se crea un nuevo comando con la secuencia SQL y el objeto de conexión
SqlCommand comando = new SqlCommand("update CUENTA set CONTRASENA = @Contraseña where CORREO = @Correo", conexion);
comando.Transaction = transaccion;
// Se asigna un valor a los parámetros del comando a ejecutar
comando.Parameters.AddWithValue("@Correo", myTOCuenta.correo);
comando.Parameters.AddWithValue("@Contraseña", myTOCuenta.contrasena);
// Se ejecuta el comando y se realiza un commit de la transacción
comando.ExecuteNonQuery();
transaccion.Commit();
}
catch (Exception)
{
try
{
// En caso de un error se realiza un rollback a la transacción
transaccion.Rollback();
}
catch (Exception)
{
}
finally
{
}
}
finally
{
//Se finaliza la conezion
if (conexion.State != ConnectionState.Closed)
{
conexion.Close();
}
}
}
// Se crea una cuenta de usuario en base de datos
public string CrearCuenta(TOCuenta toCuenta, TOUsuario toUsuario, TOMedico toMedico)
{
string confirmacion = "La cuenta se creó exitosamente";
string mensajeError = "Error: No se pudo ingresar la cuenta en el sistema";
// Se abre la conexión
if (conexion != null)
{
try
{
if (conexion.State != ConnectionState.Open)
{
conexion.Open();
}
}
catch (Exception)
{
confirmacion = mensajeError;
return(confirmacion);
}
}
else
{
confirmacion = mensajeError;
return(confirmacion);
}
// Se inicia una nueva transacción
SqlTransaction transaccion = null;
try
{
transaccion = conexion.BeginTransaction("Ingresar nueva cuenta");
// Se crea un nuevo comando con la secuencia SQL y el objeto de conexión
SqlCommand comando = new SqlCommand();
comando.Connection = conexion;
comando.Transaction = transaccion;
comando.CommandText = "INSERT INTO CUENTA_USUARIO (ID_CUENTA, CORREO, CONTRASENNA, ROL, ESTADO)" +
"VALUES (@id, @correo, @contrasenna, @rol, @estado);";
// Se asigna un valor a los parámetros del comando a ejecutar
comando.Parameters.AddWithValue("@id", toCuenta.IdCuenta);
comando.Parameters.AddWithValue("@correo", toCuenta.Correo);
comando.Parameters.AddWithValue("@contrasenna", toCuenta.Contrasenna);
comando.Parameters.AddWithValue("@rol", toCuenta.Rol);
comando.Parameters.AddWithValue("@estado", toCuenta.Estado);
// Se ejecuta el comando y se limpian los parámetros
comando.ExecuteNonQuery();
comando.Parameters.Clear();
// Se modifica la consulta del comando de la transacción
comando.CommandText = "INSERT INTO USUARIO (CEDULA, NOMBRE, PRIMER_APELLIDO, SEGUNDO_APELLIDO," +
" TELEFONO, CODIGO_ASISTENTE) VALUES (@cedula, @nombre, @primer, @segundo, @telefono, @codigoAsistente);";
// Se asigna un valor a los parámetros del comando a ejecutar
comando.Parameters.AddWithValue("@cedula", toUsuario.Cedula);
comando.Parameters.AddWithValue("@nombre", toUsuario.Nombre);
comando.Parameters.AddWithValue("@primer", toUsuario.PrimerApellido);
comando.Parameters.AddWithValue("@segundo", toUsuario.SegundoApellido);
comando.Parameters.AddWithValue("@telefono", toUsuario.Telefono);
comando.Parameters.AddWithValue("@codigoAsistente", toUsuario.CodigoAsistente);
// Se ejecuta el comando
comando.ExecuteNonQuery();
comando.Parameters.Clear();
// En caso de que el rol de la cuennta se un médico, se procede a guardar en base de datos
if (toCuenta.Rol.Equals("medico") && toMedico != null)
{
comando.CommandText = "INSERT INTO MEDICO (ID_MEDICO, CODIGO_MEDICO, ESPECIALIDAD, DURACION_CITA) " +
"VALUES (@id, @codigo, @especialidad, @duracion);";
// Se asigna un valor a los parámetros del comando a ejecutar
comando.Parameters.AddWithValue("@id", toMedico.IdMedico);
comando.Parameters.AddWithValue("@codigo", toMedico.CodigoMedico);
comando.Parameters.AddWithValue("@especialidad", toMedico.Especialidad);
comando.Parameters.AddWithValue("@duracion", toMedico.DuracionCita);
// Se ejecuta el comando y se realiza un commit de la transacción
comando.ExecuteNonQuery();
}
// Una vez que se ejecutaron todos los comandos se realiza el commit de la transacción
transaccion.Commit();
}
catch (Exception)
{
try
{
// En caso de un error se realiza un rollback a la transacción
transaccion.Rollback();
}
catch (Exception)
{
}
finally
{
confirmacion = mensajeError;
}
}
finally
{
if (conexion.State != ConnectionState.Closed)
{
conexion.Close();
}
}
return(confirmacion);
}
/// <summary>
/// Inserta una cuenta a la base de datos
/// </summary>
/// <param name="miTOCuenta">Recibe un objeto que posee los atributos de la cuenta</param>
/// <returns>Retorna un mensaje para confirmar la insercion de la cuenta</returns>
public string InsertarCuenta(TOCuenta miTOCuenta)
{
// Se abre la conexión
if (conexion != null)
{
try
{
if (conexion.State != ConnectionState.Open)
{
conexion.Open();
}
}
catch (Exception)
{
//confirmacion = "Ocurrio un error y no se pudo cargar los expedientes";
//return confirmacion;
}
}
else
{
//confirmacion = "Ocurrio un error y no se pudo cargar los expedientes";
//return confirmacion;
}
// Se inicia una nueva transacción
SqlTransaction transaccion = null;
string confirmacion = "Correcto";
try
{
transaccion = conexion.BeginTransaction("Insertar nueva cuenta");
// Se crea un nuevo comando con la secuencia SQL y el objeto de conexión
SqlCommand comando = new SqlCommand("INSERT INTO CUENTA (Correo, Contrasena, Tipo, Estado) VALUES (@cor, @con, @tip, @est);", conexion);
comando.Transaction = transaccion;
// Se asigna un valor a los parámetros del comando a ejecutar
comando.Parameters.AddWithValue("@cor", miTOCuenta.correo);
comando.Parameters.AddWithValue("@con", miTOCuenta.contrasena);
comando.Parameters.AddWithValue("@tip", miTOCuenta.tipo);
comando.Parameters.AddWithValue("@est", miTOCuenta.estado);
// Se ejecuta el comando y se realiza un commit de la transacción
comando.ExecuteNonQuery();
transaccion.Commit();
}
catch (Exception)
{
try
{
// En caso de un error se realiza un rollback a la transacción
transaccion.Rollback();
}
catch (Exception)
{
}
finally
{
confirmacion = "Error";
}
}
finally
{
// Se finaliza la conexion
if (conexion.State != ConnectionState.Closed)
{
conexion.Close();
}
}
return(confirmacion);
}
/// <summary>
/// Busca que el correo y la contraseña de una cuenta coincida
/// </summary>
/// <param name="myTOCuenta">Se recibe un objeto que contiene los datos a buscar</param>
public String buscarCuentaConContraseña(TOCuenta myTOCuenta)
{
string confirmacion = "La cuenta se encontro correctamente";
// Se abre la conexión
if (conexion != null)
{
try
{
if (conexion.State != ConnectionState.Open)
{
conexion.Open();
}
}
catch (Exception)
{
confirmacion = "Ocurrio un error y no se encontro la cuenta";
return(confirmacion);
}
}
else
{
confirmacion = "Ocurrio un error y no se encontro la cuenta";
return(confirmacion);
}
SqlTransaction transaccion = null;
try
{
transaccion = conexion.BeginTransaction("Buscar Cuenta con Contraseña");
SqlCommand comando = new SqlCommand("select * from Cuenta where CORREO = @Correo and CONTRASENA = @Contraseña", conexion);
comando.Transaction = transaccion;
// Asignar un valor a los parametros del comando a ejecutar
comando.Parameters.AddWithValue("@Correo", myTOCuenta.correo);
comando.Parameters.AddWithValue("@Contraseña", myTOCuenta.contrasena);
// Ejecutar comando y realizar commit de la transaccion
comando.ExecuteNonQuery();
transaccion.Commit();
SqlDataReader reader = comando.ExecuteReader();
if (reader.Read())
{
myTOCuenta.estado = reader["ESTADO"].ToString();
myTOCuenta.tipo = reader["TIPO"].ToString();
}
}
catch (Exception)
{
try
{
// Realizar rollback a la transaccion
transaccion.Rollback();
}
catch (Exception)
{
}
finally
{
confirmacion = "Ocurrió un error y no se pudo encontrar la cuenta";
}
}
finally
{
// Finaliza la conexion
if (conexion.State != ConnectionState.Closed)
{
conexion.Close();
}
}
return(confirmacion);
}
/// <summary>
/// Revisa que la contraseña recibida concida con los datos de la cuenta
/// </summary>
/// <param name="miTOCuenta">Se recibe un objeto con los atributos de la cuenta que interesa validad</param>
/// <returns>Retorna un valor booleano segun sea que la contraseña coincida o no</returns>
public Boolean revisarContrasena(TOCuenta miTOCuenta)
{
// Se abre la conexión
if (conexion != null)
{
try
{
if (conexion.State != ConnectionState.Open)
{
conexion.Open();
}
}
catch (Exception)
{
//confirmacion = "Ocurrio un error y no se pudo cargar los expedientes";
//return confirmacion;
}
}
else
{
//confirmacion = "Ocurrio un error y no se pudo cargar los expedientes";
//return confirmacion;
}
// Se inicia una nueva transacción
SqlTransaction transaccion = null;
Boolean valor = false;
try
{
transaccion = conexion.BeginTransaction("Revisar Contraseña");
// Se crea un nuevo comando con la secuencia SQL y el objeto de conexión
SqlCommand comando = new SqlCommand("SELECT CONTRASENA FROM CUENTA WHERE CORREO = @cor;", conexion);
comando.Transaction = transaccion;
// Se asigna un valor a los parámetros del comando a ejecutar
comando.Parameters.AddWithValue("@cor", miTOCuenta.correo);
// Se ejecuta el comando y se realiza un commit de la transacción
comando.ExecuteNonQuery();
transaccion.Commit();
SqlDataReader reader = comando.ExecuteReader();
if (reader.Read())
{
if (reader["CONTRASENA"].ToString() == miTOCuenta.contrasena)
{
valor = true;
}
}
}
catch (Exception)
{
try
{
// En caso de un error se realiza un rollback a la transacción
transaccion.Rollback();
}
catch (Exception)
{
}
}
finally
{
// Se finaliza la conezion
if (conexion.State != ConnectionState.Closed)
{
conexion.Close();
}
}
return(valor);
}
private BLCuenta convert(TOCuenta cuenta)
{
return(new BLCuenta(cuenta.id, cuenta.contrasenna, cuenta.rol, cuenta.nombreEmpleado, cuenta.estado));
}
/// <summary>
/// Busca los datos de una cuenta segun el correo ingresado
/// </summary>
/// <param name="miTOCuenta">Se recibe un ojbeto con el atributo de correo</param>
public void buscarCuentaPorCorreo(TOCuenta miTOCuenta)
{
// Se abre la conexión
if (conexion != null)
{
try
{
if (conexion.State != ConnectionState.Open)
{
conexion.Open();
}
}
catch (Exception)
{
//confirmacion = "Ocurrio un error y no se pudo cargar los expedientes";
//return confirmacion;
}
}
else
{
//confirmacion = "Ocurrio un error y no se pudo cargar los expedientes";
//return confirmacion;
}
// Se inicia una nueva transacción
SqlTransaction transaccion = null;
Boolean valor = false;
try
{
transaccion = conexion.BeginTransaction("Revisar Contraseña");
// Se crea un nuevo comando con la secuencia SQL y el objeto de conexión
SqlCommand comando = new SqlCommand("SELECT * FROM CUENTA WHERE CORREO = @cor;", conexion);
comando.Parameters.AddWithValue("@cor", miTOCuenta.correo);
comando.Transaction = transaccion;
// Se ejecuta el comando y se realiza un commit de la transacción
SqlDataReader lector = comando.ExecuteReader();
if (lector.HasRows)
{
// Se asignado los valores a un objeto segun los atributos seleccionados
while (lector.Read())
{
miTOCuenta.tipo = lector["TIPO"].ToString();
miTOCuenta.estado = lector["ESTADO"].ToString();
}
}
}
catch (Exception)
{
try
{
// En caso de un error se realiza un rollback a la transacción
transaccion.Rollback();
}
catch (Exception)
{
}
}
finally
{
// Se finaliza la conezion
if (conexion.State != ConnectionState.Closed)
{
conexion.Close();
}
}
}
/// <summary>
/// Edita la contraseña de una cuenta segun la nueva contraseña ingresada
/// </summary>
/// <param name="miTOCuenta">Recibe un objeto con los atributos de la cuenta que se desea modificar</param>
public void editarEstado(TOCuenta miTOCuenta, String Accion)
{
// Se abre la conexión
if (conexion != null)
{
try
{
if (conexion.State != ConnectionState.Open)
{
conexion.Open();
}
}
catch (Exception)
{
//confirmacion = "Ocurrio un error y no se pudo cargar los expedientes";
//return confirmacion;
}
}
else
{
//confirmacion = "Ocurrio un error y no se pudo cargar los expedientes";
//return confirmacion;
}
// Se inicia una nueva transacción
SqlTransaction transaccion = null;
try
{
transaccion = conexion.BeginTransaction("Editar estado");
SqlCommand comando;
// Se crea un nuevo comando con la secuencia SQL y el objeto de conexión
if (Accion == "HABILITAR")
{
comando = new SqlCommand("UPDATE CUENTA SET ESTADO = 'Habilitada' WHERE CORREO = @cor;", conexion);
}
else
{
comando = new SqlCommand("UPDATE CUENTA SET ESTADO = 'Deshabilitada' WHERE CORREO = @cor;", conexion);
}
comando.Transaction = transaccion;
// Se asigna un valor a los parámetros del comando a ejecutar
comando.Parameters.AddWithValue("@cor", miTOCuenta.correo);
// Se ejecuta el comando y se realiza un commit de la transacción
comando.ExecuteNonQuery();
transaccion.Commit();
}
catch (Exception)
{
try
{
// En caso de un error se realiza un rollback a la transacción
transaccion.Rollback();
}
catch (Exception)
{
}
finally
{
}
}
finally
{
//Se finaliza la conezion
if (conexion.State != ConnectionState.Closed)
{
conexion.Close();
}
}
}
public List <TOCuenta> buscarListaPacientes()
{
// Se abre la conexión
if (conexion != null)
{
try
{
if (conexion.State != ConnectionState.Open)
{
conexion.Open();
}
}
catch (Exception)
{
//confirmacion = "Ocurrio un error y no se pudo cargar los expedientes";
//return confirmacion;
}
}
else
{
//confirmacion = "Ocurrio un error y no se pudo cargar los expedientes";
//return confirmacion;
}
// Se inicia una nueva transacción
SqlTransaction transaccion = null;
//string confirmacion = "La cita se ingresó exitosamente en el sistema";
try
{
transaccion = conexion.BeginTransaction("Buscar Lista");
// Se crea un nuevo comando con la secuencia SQL y el objeto de conexión
SqlCommand comando = new SqlCommand("SELECT * FROM CUENTA WHERE TIPO = 'Paciente'", conexion);
comando.Transaction = transaccion;
// Se ejecuta el comando y se realiza un commit de la transacción
comando.ExecuteNonQuery();
transaccion.Commit();
using (SqlDataReader reader = comando.ExecuteReader())
{
// Añade una cuenta a la lista por cada una de las encontrada en la base de datos
while (reader != null && reader.Read())
{
TOCuenta miTOCuenta = new TOCuenta();
miTOCuenta.correo = reader["CORREO"].ToString();
lista.Add(miTOCuenta);
}
}
}
catch (Exception)
{
try
{
// En caso de un error se realiza un rollback a la transacción
transaccion.Rollback();
}
catch (Exception)
{
}
finally
{
//confirmacion = "Ocurrió un error y no se pudo ingresar el personal";
}
}
finally
{
// Finaliza la conexion
if (conexion.State != ConnectionState.Closed)
{
conexion.Close();
}
}
return(lista);
}
