public bool actualizarUsuarios(Usuario usuario)
{
int ok = -1;
string actualizaString;
actualizaString = "UPDATE Usuario SET Clave= '" + usuario.Clave + "', Legajo= '" + usuario.Legajo + "' where Usu='" + usuario.Usu+"'";
SqlCommand cmd = new SqlCommand(actualizaString, myCon);
try
{
myCon.Open();
ok = cmd.ExecuteNonQuery();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
finally
{
myCon.Close();
}
if (ok > 0)
{
return true;
}
return false;
}
public void actualizarUsuario(Entidades.Usuario usuario)
{
Conexion aux = new Conexion();
SqlCommand cmd = new SqlCommand();
cmd.Connection = aux.conectar();
cmd.Parameters.Add(new SqlParameter("@Id_Usuario", usuario.Id_Usuario));
cmd.Parameters.Add(new SqlParameter("@Dominio", usuario.Dominio));
cmd.Parameters.Add(new SqlParameter("@Nombre_Usuario", usuario.Nombre_Usuario));
cmd.Parameters.Add(new SqlParameter("@Nombre_Completo", usuario.Nombre_Completo));
cmd.Parameters.Add(new SqlParameter("@Primer_Apellido", usuario.Primer_Apellido));
cmd.Parameters.Add(new SqlParameter("@Segundo_Apellido", usuario.Segundo_Apellido));
cmd.Parameters.Add(new SqlParameter("@Correo_Electronico", usuario.Correo_Electronico));
cmd.Parameters.Add(new SqlParameter("@Estado", usuario.Estado));
cmd.Parameters.Add(new SqlParameter("@Fecha_Ultimo_Acceso", usuario.Fecha_Ultimo_Acceso));
cmd.Parameters.Add(new SqlParameter("@Estado_Accion", usuario.Estado_Accion));
cmd.Parameters.Add(new SqlParameter("@Usuario_Ingreso", usuario.Usuario_Ingreso));
cmd.Parameters.Add(new SqlParameter("@Fecha_Ingreso", usuario.Fecha_Ingreso));
cmd.Parameters.Add(new SqlParameter("@Usuario_Modificacion", usuario.Usuario_Modificacion));
cmd.Parameters.Add(new SqlParameter("@Fecha_Modificacion", usuario.Fecha_Modificacion));
cmd.CommandText = "ActualizarUsuario";
cmd.CommandType = CommandType.StoredProcedure;
cmd.ExecuteNonQuery();
aux.conectar();
}
//Recibe un entero que representa el ID del usuario y el Modo en que estará el Formulario
public UsuarioABM(int ID, ModoForm modo)
: this()
{
this.Modo = modo;
UsuarioActual = new ControladorUsuario().dameUno(ID);
MapearDeDatos();
switch (modo)
{ //Dependiendo el modo, la ventana de carga como se setea
case (ModoForm.Alta):
this.btnAceptar.Text = "Guardar";
break;
case (ModoForm.Modificacion):
this.btnAceptar.Text = "Guardar";
break;
case (ModoForm.Baja):
this.btnAceptar.Text = "Eliminar";
break;
case (ModoForm.Consulta):
this.btnAceptar.Text = "Aceptar";
break;
}
}
public Boolean AgregarUsuario(Usuario usuario)
{
sql = "SP_AgregarUsuario";
try
{
if (conn.abrirConexion() == true) {
SqlCommand comando = new SqlCommand(sql, conn.conn);
comando.CommandType = CommandType.StoredProcedure;
comando.Parameters.Add("@p_us_correo", SqlDbType.VarChar).Value = usuario.Correo;
comando.Parameters.Add("@p_us_nombre", SqlDbType.VarChar).Value = usuario.Nombre;
comando.Parameters.Add("@p_us_apellidoPaterno", SqlDbType.VarChar).Value = usuario.ApellidoPaterno;
comando.Parameters.Add("@p_us_apellidoMaterno", SqlDbType.VarChar).Value = usuario.ApellidoMaterno;
comando.Parameters.Add("@p_us_alias", SqlDbType.VarChar).Value = usuario.Alias;
comando.Parameters.Add("@p_us_contrasena", SqlDbType.VarChar).Value = usuario.Contrasena;
comando.Parameters.Add("@p_us_pais", SqlDbType.VarChar).Value = usuario.Pais;
comando.Parameters.Add("@p_us_estado", SqlDbType.Char).Value = usuario.Estado;
comando.Parameters.Add("@p_us_estampa", SqlDbType.DateTime).Value = DateTime.Parse(usuario.Estampa);
comando.ExecuteNonQuery();
resultado = true;
}
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
conn.cerrarConexion();
return resultado;
}
/// <summary>
/// Ingresa un nuevo usuario en el sistema
/// </summary>
/// <param name="u"></param>
public void NuevoUsuario(Usuario u)
{
SqlConnection conexion = new SqlConnection(Conexion.Cnn);
SqlCommand cmd = Conexion.GetCommand("spAltaAlumno", conexion, CommandType.StoredProcedure);
//SqlParameter _codigo = new SqlParameter("@cod", A.Codigo);
//SqlParameter _nombre = new SqlParameter("@nom", A.Nombre);
//SqlParameter _precio = new SqlParameter("@pre", A.Precio);
SqlParameter _Retorno = new SqlParameter("@Retorno", SqlDbType.Int);
_Retorno.Direction = ParameterDirection.ReturnValue;
//int oAfectados = -1;
//oComando.Parameters.Add(_codigo);
//oComando.Parameters.Add(_nombre);
//oComando.Parameters.Add(_precio);
//oComando.Parameters.Add(_Retorno);
try
{
conexion.Open();
cmd.ExecuteNonQuery();
//oAfectados = (int)oComando.Parameters["@Retorno"].Value;
//if (oAfectados == -1)
// throw new Exception("El codigo de articulo ya existe");
}
catch
{
throw new ErrorBaseDeDatos(); //Acá van las excepciones según @retorno
}
finally
{
conexion.Close();
}
}
public Entidades.Usuario ObtenerUsuario(List <Parametro> listParametro)
{
object Resultado = new object();
Entidades.Usuario Usuario = new Entidades.Usuario();
const string spName = "ObtenerUsuario";
BDUsuario bdUsuario = new BDUsuario();
DataTable dtResultado = new DataTable();
try
{
Resultado = bdUsuario.ObtenerUsuario(spName, listParametro);
dtResultado = (DataTable)Resultado;
if (dtResultado.Rows.Count > 0)
{
var jsonUsuario = JsonConvert.DeserializeObject <Entidades.Usuario>(dtResultado.Rows[0][0].ToString());
Usuario = jsonUsuario;
}
}
catch (Exception ex)
{
}
return(Usuario);
}
public JsonResult MostrarAgregarUsuario()
{
ResultadoUsuarioDefault resultadoUsuario = new Models.Usuario.ResultadoUsuarioDefault();
List <CatRol> listaCatRol = new List <CatRol>();
Entidades.Usuario usuario = new Entidades.Usuario();
string mensaje = string.Empty;
try
{
resultadoUsuario.Usuario = usuario;
listaCatRol = (List <CatRol>)Session["ListCatRol"];
if (listaCatRol.Count > 0)
{
resultadoUsuario.CatRol = listaCatRol.FirstOrDefault();
}
resultadoUsuario.Mensaje = "OK";
}
catch (Exception ex)
{
mensaje = "ERROR: Metodo: ObtenerEstadistico_Dinero, Source: " + ex.Source + ", Mensaje: " + ex.Message;
ArchivoLog.EscribirLog(null, mensaje);
resultadoUsuario.Mensaje = mensaje;
}
return(Json(resultadoUsuario, JsonRequestBehavior.AllowGet));
}
public Entidades.Usuario EliminarUsuario(List <Parametro> listParametro)
{
object Resultado = new object();
Entidades.Usuario usuario = new Entidades.Usuario();
const string spName = "UpdateUsuario";
BDUsuario bdUsuario = new BDUsuario();
DataTable dtResultado = new DataTable();
try
{
Resultado = bdUsuario.EliminarUsuario(spName, listParametro);
if (dtResultado.Rows.Count > 0)
{
var jsonListUsuario = JsonConvert.DeserializeObject <Entidades.Usuario>(dtResultado.Rows[0][0].ToString());
usuario = jsonListUsuario;
}
}
catch (Exception ex)
{
}
return(usuario);
}
protected void Page_Load(object sender, EventArgs e)
{
usuario = (Usuario) (Session["usuario_logueado"]);
((MPRedSocial)this.Master).LnkPerfil = usuario.Correo;
ObtenerSolicitudes();
ObtenerDatos();
}
public UsuarioDesktop(int id, ModoForm modo)
{
InitializeComponent();
this.Modo = modo;
UsuarioLogic ul = new UsuarioLogic();
this.UsuarioActual = ul.GetOne(id);
this.MapearDeDatos(); //Ver si está bien implementado. LAB 4-Parte 2-Inciso 12.
}
public void Deposito(Entidades.Usuario UNovo)
{
using (var ctx = new SistemaContext())
{
Usuario UAntigo = ctx.Usuarios.Find(UNovo.Id);
UAntigo.Nome = UNovo.Nome;
UAntigo.Saldo = UNovo.Saldo;
ctx.SaveChanges();
}
}
public void crearUsuario(EN.Usuario usuario)
{
DA.Usuario objUsuario = new DA.Usuario();
objUsuario.Correo = usuario.Correo;
objUsuario.img = usuario.img;
objUsuario.Nombre = usuario.Nombre;
objUsuario.IdTipoUsu = 5;
db.Usuario.Add(objUsuario);
db.SaveChanges();
}
//USO DE SOBRECARGA PARA LOS METODOS MOSTRAR USUARIO, UNO PARA UN SOLO USUARIO Y OTRO PARA LISTA DE USUARIOS
public void MostrarDatos(Entidades.Usuario usu)
{
Console.WriteLine("\t\tUsuario:" + usu.Id);
System.Console.WriteLine("\t\tNombre: " + usu.Nombre);
Console.WriteLine("\t\tApellido: " + usu.Apellido);
System.Console.WriteLine("\t\tNombre de Usuario: " + usu.NombreUsuario);
System.Console.WriteLine("\t\tClave: " + usu.Clave);
System.Console.WriteLine("\t\tEmail: " + usu.Email);
System.Console.WriteLine("\t\tHabilitado: " + usu.Habilitado);
}
public JsonResult AgregarUsuario(Entidades.Usuario usuario, Entidades.CatRol rol)
{
List <Entidades.Usuario> ListUsuario = new List <Entidades.Usuario>();
Negocio.Usuario.Usuario Usuario = new Negocio.Usuario.Usuario();
List <Parametro> ListParametro = new List <Parametro>();
Parametro parametro = new Parametro();
//Entidades.Usuario usuario = new Entidades.Usuario();
ResultadoUsuario resultadoUsuario = new Models.Usuario.ResultadoUsuario();
const string key = "idaeconomia";
try
{
usuario.Password = EncripDecrip.Encriptar(usuario.Password, key);
usuario.ConfirmarPassword = usuario.Password;
usuario.IdRol = rol.Id;
usuario.Rol = rol.Rol;
parametro = new Parametro();
parametro.Nombre = "Nombre";
parametro.Valor = usuario.Nombre;
ListParametro.Add(parametro);
parametro = new Parametro();
parametro.Nombre = "Usuario";
parametro.Valor = usuario.Login;
ListParametro.Add(parametro);
parametro = new Parametro();
parametro.Nombre = "Password";
parametro.Valor = usuario.Password;
ListParametro.Add(parametro);
parametro = new Parametro();
parametro.Nombre = "IdRol";
parametro.Valor = usuario.IdRol;
ListParametro.Add(parametro);
usuario = Usuario.AgregarUsuario(ListParametro);
ListUsuario = (List <Entidades.Usuario>)Session["ListUsuario"];
ListUsuario.Add(usuario);
Session["ListUsuario"] = ListUsuario;
resultadoUsuario.ListaUsuario = ListUsuario.OrderBy(n => n.Nombre).ToList();
resultadoUsuario.Mensaje = "OK";
}
catch (Exception ex)
{
}
return(Json(resultadoUsuario, JsonRequestBehavior.AllowGet));
}
public JsonResult crear()
{
string resultado = "";
if (Request.HttpMethod == "POST")
{
try
{
Request.InputStream.Seek(0, SeekOrigin.Begin);
string jsonData = new StreamReader(Request.InputStream).ReadToEnd();
dynamic objUsuario = JsonConvert.DeserializeObject(jsonData, typeof(object));
if (!string.IsNullOrEmpty(jsonData))
{
Entidades.Usuario nuevoUsuario = new Entidades.Usuario();
try
{
nuevoUsuario.nombre = objUsuario.nombre;
nuevoUsuario.apellido = objUsuario.apellido;
nuevoUsuario.email = objUsuario.email;
nuevoUsuario.login_name = objUsuario.login_name;
nuevoUsuario.password = objUsuario.password;
nuevoUsuario.fecha_alta = DateTime.Now;
nuevoUsuario.habilitado = false;
nuevoUsuario.telefono = objUsuario.telefono;
//TODO: Generar random de token para habilitar usuario
nuevoUsuario.token_clave = "asdqwe";
}
catch (Exception)
{
resultado = "Faltan datos";
}
if (string.IsNullOrEmpty(resultado))
{
try
{
nuevoUsuario.id_usuario = serviceUsuario.crear(nuevoUsuario, ref resultado);
return(Json(nuevoUsuario, JsonRequestBehavior.AllowGet));
}
catch (Exception)
{
resultado = "Ocurrió un error al crear el proyecto";// }, JsonRequestBehavior.AllowGet);
}
}
}
}
catch (Exception ex)
{
resultado = ex.Message;
}
}
return(Json(new { Error = true, Mensaje = resultado }, JsonRequestBehavior.AllowGet));
}
public EN.Usuario retornarUser(string correo)
{
DA.Usuario usu = new DA.Usuario();
EN.Usuario user = new EN.Usuario();
usu = db.Usuario.Where(x => x.Correo.Contains(correo)).FirstOrDefault();
user.Correo = usu.Correo;
user.Nombre = usu.Nombre;
user.IdTipoUsu = usu.IdTipoUsu;
user.img = usu.img;
user.Id_Usuario = usu.Id_Usuario;
return(user);
}
public formListaUsuarios()
{
InitializeComponent();
this.oUsuarios = new Negocio.Usuarios();
Usuario[] usuarios = new Usuario[2];
Usuario nuevoUsuario = new Entidades.Usuario("Rossotto96", "12345", "Marcos", "Rossotto", "*****@*****.**", true);
Usuario nuevoUsuario2 = new Entidades.Usuario("Pedro96", "12345", "Pedro", "Routaboul", "*****@*****.**", true);
usuarios[0] = nuevoUsuario;
usuarios[1] = nuevoUsuario2;
this.dgvUsuarios.DataSource = usuarios;
}
public DataTable ObtenerDatosUsuario(Usuario usuario)
{
try
{
dt = dao_usuario.ObtenerDatosUsuario(usuario);
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
return dt;
}
public Boolean ModificarUsuario(Usuario usuario)
{
try
{
resultado = dao_usuario.ModificarUsuario(usuario);
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
return resultado;
}
protected void Page_Load(object sender, EventArgs e)
{
if (Page.IsPostBack == false)
{
//Session["usuario_logueado"] = null;
usuario = (Usuario)(Session["usuario_logueado"]);
((MPRedSocial)this.Master).LnkPerfil = usuario.Correo;
CargarDatos();
}
}
public Boolean InActivarUsuario(Usuario usuario)
{
try
{
resultado = dao_usuario.CambioEstadoUsuario(usuario);
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
return resultado;
}
private bool esUsuarioAdministrador(Entidades.Usuario usuario, ref string resultado)
{
foreach (var rol in usuario.roles)
{
if (rol.id_rol == 1)
{
return(true);
}
}
resultado = "Usted no tiene permisos de administrador";
return(false);
}
public Boolean LoginUsuario(Usuario usuario)
{
try
{
resultado = dao_usuario.LoginUsuario(usuario);
}
catch (Exception ex)
{
throw new Exception("Datos inválidos", ex);
}
return resultado;
}
static public void eliminar(Entidades.Usuario u)
{
Conexion.OpenConnection();
string query = "DELETE from usuario WHERE idUsuario = @idUsuario";
MySqlCommand comando = new MySqlCommand(query, Conexion.Connection);
comando.Parameters.AddWithValue("@idUsuario", u.IdUsuario);
comando.Prepare();
comando.ExecuteNonQuery();
Conexion.CloseConnection();
}
public Entidades.Usuario AgregarPagoUsuario(List <Parametro> listParametro)
{
object Resultado = new object();
DataSet dsResultado = new DataSet();
Entidades.Usuario usuario = new Entidades.Usuario();
const string spName = "RegistrodePagoUsuario";
BDUsuario bdUsuario = new BDUsuario();
DataTable dtResultado = new DataTable();
StringBuilder sbResultado = new StringBuilder();
try
{
Resultado = bdUsuario.InsertUsuariodt(spName, listParametro);
dtResultado = (DataTable)Resultado;
if (dtResultado.Rows.Count > 0)
{
sbResultado.Append("[");
dtResultado.Rows.Cast <DataRow>().ToList().ForEach(n =>
{
sbResultado.Append(n[0].ToString());
});
sbResultado.Append("]");
}
var jsonListUsuario = JsonConvert.DeserializeObject <Entidades.Usuario>(dtResultado.Rows[0][0].ToString());
usuario = jsonListUsuario;
if (usuario.Estatus)
{
usuario.StrEstatus = "Activo";
}
else
{
usuario.StrEstatus = "Inactivo";
}
usuario.ConfirmarPassword = usuario.Password;
}
catch (Exception ex)
{
}
return(usuario);
}
public void Agregar()
{
Entidades.Usuario usuario = new Entidades.Usuario();
System.Console.WriteLine("Ingrese los datos del usuario a registrar");
System.Console.WriteLine("Nombre: ");
usuario.NombreUsuario = Console.ReadLine();
System.Console.WriteLine("Apellido: ");
usuario.Apellido = Console.ReadLine();
System.Console.WriteLine("Clave: ");
usuario.Clave = Console.ReadLine();
System.Console.WriteLine("email: ");
usuario.Email = Console.ReadLine();
usuario.Habilitado = true;
cu.guardarUsuario(usuario);
}
static public void insertar(Entidades.Usuario u)
{
Conexion.OpenConnection();
string query = "insert into usuario (idUsuario, pass, tipo) values(@idUsuario, @pass, @tipo)";
MySqlCommand comando = new MySqlCommand(query, Conexion.Connection);
comando.Parameters.AddWithValue("@idUsuario", u.IdUsuario);
comando.Parameters.AddWithValue("@pass", u.Pass);
comando.Parameters.AddWithValue("@tipo", u.Tipo);
comando.Prepare();
comando.ExecuteNonQuery();
Conexion.CloseConnection();
}
static public void modificar(Entidades.Usuario u)
{
Conexion.OpenConnection();
string query = "UPDATE usuario set pass = @pass,tipo = @tipo WHERE idUsuario = @idUsuario";
MySqlCommand comando = new MySqlCommand(query, Conexion.Connection);
comando.Parameters.AddWithValue("@idUsuario", u.IdUsuario);
comando.Parameters.AddWithValue("@pass", u.Pass);
comando.Parameters.AddWithValue("@tipo", u.Tipo);
comando.Prepare();
comando.ExecuteNonQuery();
Conexion.CloseConnection();
}
public Entidade Logar(string login, string senha)
{
Entidade usuario = null;
MySqlCommand command = new MySqlCommand("SELECT id, nome, login, senha, data_cadastro FROM usuario where login = @login and senha = @senha", connection);
command.Parameters.Add("login", MySqlDbType.String);
command.Parameters["login"].Value = login;
command.Parameters.Add("senha", MySqlDbType.String);
command.Parameters["senha"].Value = senha;
try
{
connection.Open();
MySqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{
usuario = new Entidade
{
Id = Convert.ToInt32(reader["id"].ToString()),
Nome = reader["nome"].ToString(),
Login = reader["login"].ToString(),
Senha = reader["senha"].ToString(),
DataCadastro = DateTime.Parse(reader["data_cadastro"].ToString())
};
}
return(usuario);
}
catch (Exception exc)
{
command.Transaction.Rollback();
throw exc;
}
finally
{
if (connection.State == System.Data.ConnectionState.Open)
{
connection.Close();
}
}
throw new NotImplementedException();
}
public formPrincipal(Entidades.Usuario user)
{
InitializeComponent();
usuario = user;
userToolStripMenuItem.Text = (usuario.name + " " + usuario.surname).Trim();
this.mundial = new Mundial();
this.rolTipo = "";
this.FormClosing += FormPrincipal_FormClosing;
this.CompruebaRolUser();
yearPreferences = DateTime.Now.Year;
System.Timers.Timer aTimer = new System.Timers.Timer();
aTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent);
aTimer.Interval = 1000;
aTimer.Enabled = true;
}
private UsuarioWeb MapearUsuarioWeb(Entidades.Usuario user)
{
UsuarioWeb usuarioResult = new UsuarioWeb();
usuarioResult.id_usuario = user.id_usuario;
usuarioResult.login_name = user.login_name;
usuarioResult.email = user.email;
usuarioResult.habilitado = user.habilitado;
usuarioResult.token_clave = user.token_clave;
usuarioResult.fecha_alta = user.fecha_alta.ToShortDateString();
usuarioResult.fecha_baja = user.fecha_baja.ToShortDateString();
usuarioResult.fecha_ultima_modif = user.fecha_ultima_modif.ToShortDateString();
usuarioResult.roles = user.roles;
return(usuarioResult);
}
public override void MapearADatos()
{
//La propiedad State se setea dependiendo el Modo del Formulario
switch (this.Modo)
{
case (ModoForm.Alta):
{
UsuarioActual = new Entidades.Usuario();
Personas p = new Personas();
this.UsuarioActual.Habilitado = this.chkHabilitado.Checked;
this.UsuarioActual.Clave = this.txtClave.Text;
this.UsuarioActual.NombreUsuario = this.txtUsuario.Text;
this.UsuarioActual.Persona = p;
this.UsuarioActual.Persona.Id = Convert.ToInt32(this.cmbBoxPersonas.SelectedValue);
this.UsuarioActual.State = Entidades.EntidadBase.States.New;
break;
}
case (ModoForm.Modificacion):
{
this.UsuarioActual.Habilitado = this.chkHabilitado.Checked;
this.UsuarioActual.Clave = this.txtClave.Text;
this.UsuarioActual.NombreUsuario = this.txtUsuario.Text;
this.UsuarioActual.Persona.Id = Convert.ToInt32(this.cmbBoxPersonas.SelectedValue);
this.UsuarioActual.State = Entidades.EntidadBase.States.Modified;
break;
}
case (ModoForm.Baja):
{
this.UsuarioActual.State = Entidades.EntidadBase.States.Deleted;
break;
}
case (ModoForm.Consulta):
{
this.UsuarioActual.State = Entidades.EntidadBase.States.Unmodified;
break;
}
}
}
public JsonResult getUserById(int id_usuario)
{
string resultado = "";
if (Request.HttpMethod == "GET")
{
try
{
string token = Request.Headers["X-AUTH-TOKEN"];
if (!string.IsNullOrEmpty(token))
{
SesionService sesionService = new SesionService();
Sesion sesionActual = sesionService.getByToken(token, ref resultado);
List <Rol> roles = serviceRol.getByIdUser(sesionActual.usuario_logueado.id_usuario, ref resultado);
if (roles.Count > 0)
{
foreach (var rol in roles)
{
if (rol.id_rol == 1)
{
//Si tiene el rol 1 quiere decir que es administrador
Entidades.Usuario usuario = serviceUsuario.getById(id_usuario, ref resultado);
if (string.IsNullOrEmpty(resultado))
{
UsuarioWeb usuarioWeb = MapearUsuarioWeb(usuario);
return(Json(usuarioWeb, JsonRequestBehavior.AllowGet));
}
}
}
}
}
}
catch (Exception ex)
{
resultado = ex.Message;
}
}
return(Json(new { Error = true, Mensaje = resultado }, JsonRequestBehavior.AllowGet));
}
public static Usuario GetUsuario(string login , string pass)
{
Acceso ac = new Acceso();
Usuario p = new Usuario();
string sql = "SELECT * from usuarios where login = @login and password COLLATE Latin1_General_CS_AS = @pass ";
SqlCommand cmd = new SqlCommand();
cmd.Parameters.AddWithValue("@login", login);
cmd.Parameters.AddWithValue("@pass", pass);
SqlConnection conexion = new SqlConnection(ac.getCadenaConexion());
try
{
conexion.Open();
cmd.Connection = conexion;
cmd.CommandText = sql;
cmd.CommandType = CommandType.Text;
SqlDataReader dr = cmd.ExecuteReader();
dr.Read();
p.Login = dr["login"].ToString();
p.Nombre = dr["nombre"].ToString();
p.idUsuario = Convert.ToInt32(dr["idUsuario"]);
}
catch (InvalidOperationException ex)
{
throw new ApplicationException(ex.Message);
}
catch (SqlException ex)
{
throw new ApplicationException("Error en BD: " + ex.Message);
}
finally
{
conexion.Close();
}
return p;
}
static public bool Validar(Entidades.Usuario u)
{
Conexion.OpenConnection();
string query = "SELECT * FROM usuario WHERE idUsuario= @usuario AND pass = @pass";
MySqlCommand comando = new MySqlCommand(query, Conexion.Connection);
comando.Prepare();
comando.Parameters.AddWithValue("@usuario", u.IdUsuario);
comando.Parameters.AddWithValue("@pass", u.Pass);
MySqlDataReader reader = comando.ExecuteReader();
if (reader.HasRows)
{
Conexion.CloseConnection();
return(true);
}
Conexion.CloseConnection();
return(false);
}
protected void grdSolicitudes_RowUpdating(object sender, GridViewUpdateEventArgs e)
{
//aceptar solicitud
usuario = (Usuario) Session["usuario"];
solicitud = (Solicitud)Session["solicitud"];
Session["solicitud"] = solicitud;
solicitud.Estampa = DateTime.Now;
if (bl_solicitud.AceptarSolicitud(solicitud))
{
//La solicitud se aceptó
Response.Redirect(Request.RawUrl);
}
else
{
//Error
}
}
public Boolean CambioEstadoUsuario(Usuario usuario)
{
sql = "SP_CambioEstadoUsuario";
try
{
if (conn.abrirConexion() == true) {
SqlCommand comando = new SqlCommand(sql, conn.conn);
comando.CommandType = CommandType.StoredProcedure;
comando.Parameters.Add("@p_us_id", SqlDbType.Int).Value = usuario.Id;
comando.Parameters.Add("@p_us_estado", SqlDbType.Char).Value = usuario.Estado;
comando.ExecuteNonQuery();
resultado = true;
}
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
conn.cerrarConexion();
return resultado;
}
/// <summary>
/// Obtiene y devuelve el listado de usuarios de la app
/// haciendo de intermediario entre la capa Datos y Presentación
/// </summary>
/// <returns></returns>
public Entidades.Usuario getUsuarioById(int idUser)
{
Entidades.Usuario datosUser = new Entidades.Usuario();
try
{
datosUser = new Datos.Usuario().getUsuarioById(idUser);
}
catch (InvalidOperationException e)
{
MessageBox.Show(e.ToString());
}
catch (ApplicationException e)
{
MessageBox.Show(e.ToString());
}
catch (Oracle.ManagedDataAccess.Client.OracleException e)
{
MessageBox.Show(e.ToString());
}
return(datosUser);
}
public override void MapearADatos()
{
if (this.Modo == UsuarioDesktop.ModoForm.Alta || this.Modo == UsuarioDesktop.ModoForm.Modificacion) //Alta o Modif. se copian los datos de los controles al usuario actual.
{
if (this.Modo == UsuarioDesktop.ModoForm.Alta) //Si es un alta se crea un nuevo usuario.
{
this.UsuarioActual = new Entidades.Usuario();
}
this.UsuarioActual.Nombre = this.txtNombre.Text;
this.UsuarioActual.Apellido = this.txtApellido.Text;
this.UsuarioActual.Habilitado = this.chkHabilitado.Checked;
this.UsuarioActual.NombreUsuario = this.txtUsuario.Text;
this.UsuarioActual.Email = this.txtEmail.Text;
this.UsuarioActual.Clave = this.txtClave.Text;
if (this.Modo == ModoForm.Modificacion) //Si es modif. el ID se mantiene, no así para un alta que se autoincrementa (supongo)
{
this.UsuarioActual.ID = int.Parse(this.txtID.Text);
}
}
switch (this.Modo)
{
case ModoForm.Alta: this.UsuarioActual.State = Entidades.Entidades.States.New;
break;
case ModoForm.Baja: this.UsuarioActual.State = Entidades.Entidades.States.Deleted;
break;
case ModoForm.Consulta: this.UsuarioActual.State = Entidades.Entidades.States.Unmodified;
break;
case ModoForm.Modificacion: this.UsuarioActual.State = Entidades.Entidades.States.Modified;
break;
default: break;
}
}
public override void MapearADatos()
{
if (this.Modo == ModoForm.Alta)
{
UsuarioActual = new Usuario();
this.UsuarioActual.Habilitado = this.chkHabilitado.Checked;
this.UsuarioActual.NombreUsuario = this.txtUsuario.Text;
this.UsuarioActual.Clave = this.txtClave.Text;
this.UsuarioActual.Clave = this.txtConfirmarClave.Text;
this.UsuarioActual.IdPersona = Convert.ToInt32(this.cbPersonas.SelectedValue);
}
else if (Modo == ModoForm.Modificacion)
{
this.UsuarioActual.Id = Convert.ToInt32(this.txtID.Text);
this.UsuarioActual.Habilitado = this.chkHabilitado.Checked;
this.UsuarioActual.NombreUsuario = this.txtUsuario.Text;
this.UsuarioActual.Clave = this.txtClave.Text;
this.UsuarioActual.Clave = this.txtConfirmarClave.Text;
this.UsuarioActual.IdPersona = Convert.ToInt32(this.cbPersonas.SelectedValue);
}
switch (Modo)
{
case ModoForm.Alta:
UsuarioActual.Estado = Entidad.Estados.Nuevo;
break;
case ModoForm.Baja:
UsuarioActual.Estado = Entidad.Estados.Eliminado;
break;
case ModoForm.Consulta:
UsuarioActual.Estado = Entidad.Estados.NoModificado;
break;
case ModoForm.Modificacion:
UsuarioActual.Estado = Entidad.Estados.Modificado;
break;
}
}
public JsonResult MostrarEditarUsuario(Entidades.Usuario usuario)
{
ResultadoUsuario resultadoUsuario = new ResultadoUsuario();
Entidades.CatRol catRol = new Entidades.CatRol();
List <CatRol> listaCatRol = new List <CatRol>();
const string key = "idaeconomia";
string mensaje = string.Empty;
try
{
listaCatRol = (List <CatRol>)Session["ListCatRol"];
usuario.Password = EncripDecrip.Desencriptar(usuario.Password, key);
usuario.ConfirmarPassword = usuario.Password;
resultadoUsuario.Usuario = usuario;
catRol = listaCatRol.Where(n => n.Id == usuario.IdRol).FirstOrDefault();
if (catRol != null)
{
resultadoUsuario.CatRol = catRol;
}
resultadoUsuario.Mensaje = "OK";
}
catch (Exception ex)
{
mensaje = "ERROR: Metodo: ObtenerEstadistico_Dinero, Source: " + ex.Source + ", Mensaje: " + ex.Message;
ArchivoLog.EscribirLog(null, mensaje);
resultadoUsuario.Mensaje = mensaje;
}
return(Json(resultadoUsuario, JsonRequestBehavior.AllowGet));
}
public Entidades.Usuario EditarUsuario(List <Parametro> listParametro)
{
object Resultado = new object();
Entidades.Usuario usuario = new Entidades.Usuario();
const string spName = "UpdateUsuario";
BDUsuario bdUsuario = new BDUsuario();
DataTable dtResultado = new DataTable();
try
{
Resultado = bdUsuario.EditarUsuario(spName, listParametro);
dtResultado = (DataTable)Resultado;
if (dtResultado.Rows.Count > 0)
{
var jsonListUsuario = JsonConvert.DeserializeObject <Entidades.Usuario>(dtResultado.Rows[0][0].ToString());
usuario = jsonListUsuario;
if (usuario.Estatus)
{
usuario.StrEstatus = "Activo";
}
else
{
usuario.StrEstatus = "Inactivo";
}
usuario.ConfirmarPassword = usuario.Password;
}
}
catch (Exception ex)
{
}
return(usuario);
}
public void Cadastrar(Entidade usuario)
{
MySqlCommand command = new MySqlCommand(@"INSERT INTO usuario (nome, login, senha, data_cadastro)
VALUES (@nome, @login, @senha, current_timestamp()); ", connection);
command.Parameters.Add("nome", MySqlDbType.String);
command.Parameters["nome"].Value = usuario.Nome;
command.Parameters.Add("login", MySqlDbType.String);
command.Parameters["login"].Value = usuario.Login;
command.Parameters.Add("senha", MySqlDbType.String);
command.Parameters["senha"].Value = usuario.Senha;
try
{
connection.Open();
command.Transaction = connection.BeginTransaction();
command.ExecuteNonQuery();
command.Transaction.Commit();
}
catch (Exception exc)
{
command.Transaction.Rollback();
throw exc;
}
finally
{
if (connection.State == System.Data.ConnectionState.Open)
{
connection.Close();
}
}
}
public Boolean LoginUsuario(Usuario usuario)
{
sql = "SP_LoginUsuario";
try
{
if (conn.abrirConexion() == true)
{
SqlCommand comando = new SqlCommand(sql, conn.conn);
comando.CommandType = CommandType.StoredProcedure;
SqlParameter parametro = new SqlParameter("@p_us_correo", SqlDbType.VarChar);
parametro.Value = usuario.Correo;
comando.Parameters.Add(parametro);
parametro = new SqlParameter("@p_us_contrasena", SqlDbType.VarChar);
parametro.Value = usuario.Contrasena;
comando.Parameters.Add(parametro);
SqlDataReader rd = comando.ExecuteReader();
if (rd.HasRows)
{
rd.Read();
resultado = true;
}
else {
resultado = false;
}
}
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
conn.cerrarConexion();
return resultado;
}
public string Existe(Usuario u)
{
try
{
var sql = "";
var cx = new SqlConnection();
var documento = 0;
var pass = "";
var ds = new DataSet();
documento = u.Documento;
pass = u.Pass;
sql = "Select * from usuariosxperfiles where documento=" + documento;
cx.ConnectionString = conexion.ConexionString;
var da = new SqlDataAdapter(sql, cx);
da.Fill(ds, "usuariosxperfiles");
var test = ds.Tables[0].Rows[0][0].ToString();
return "Existe";
}
catch (Exception ex)
{
return "No existe";
}
}
public string ExistePerfilesXUsuario(Usuario u)
{
try
{
var sql = "";
var cx = new SqlConnection();
var id_perfil = "";
var documento = "";
var ds = new DataSet();
id_perfil = u.Id_perfil + "";
documento = u.Documento + "";
sql = "Select * from UsuariosXPerfiles where documento=" + documento + " and id_perfil=" + id_perfil;
cx.ConnectionString = conexion.ConexionString;
var da = new SqlDataAdapter(sql, cx);
da.Fill(ds, "PerfilesXUsuario");
//SqlParameter pr = new SqlParameter("@id", txtid.text);
//da.SelectCommand.CommandType = CommandType.StoredProcedure;
//da.SelectCommand.Parameters.Add("@id", txtid.text);
//da.SelectCommand.Parameters.Add("@id", txtid.text);
//da.SelectCommand.Parameters.Add("@id", txtid.text);
//da.SelectCommand.Parameters.Add("@id", txtid.text);
//da.SelectCommand.ExecuteNonQuery();
var test = ds.Tables[0].Rows[0][0].ToString();
return "Existe";
}
catch (Exception ex)
{
return "No existe";
}
}
public void Agregar()
{
Entidades.Usuario usuario = new Entidades.Usuario();
Console.Clear();
Console.WriteLine("Ingrese nombre");
usuario.Nombre = Console.ReadLine();
Console.WriteLine("Ingrese apellido");
usuario.Apellido = Console.ReadLine();
Console.WriteLine("Ingrese nombre de usuario");
usuario.NombreUsuario = Console.ReadLine();
Console.WriteLine("Ingrese password");
usuario.Password = Console.ReadLine();
Console.WriteLine("Ingrese Email");
usuario.Email = Console.ReadLine();
Console.WriteLine("Ingrese habilitacion de usuario (1-Si/Otro=NO)");
usuario.Habilitado = (Console.ReadLine()=="1");
usuario.State = BusinessEntity.States.New;
_uNegocio.Save(usuario);
Console.WriteLine();
Console.WriteLine("ID: {0}", usuario.ID);
}
public string Modificar(Usuario u)
{
try
{
var sql = "";
var cx = new SqlConnection();
var documento = 0;
var pass = "";
var id_perfil = 0;
var estado = 1;
var ds = new DataSet();
documento = u.Documento;
pass = u.Pass;
id_perfil = u.Id_perfil;
estado = u.Estado;
sql = "Update usuariosxperfiles set pass='******', estado=" + estado + " where documento=" +
documento+" and id_perfil="+id_perfil;
cx.ConnectionString = conexion.ConexionString;
var da = new SqlDataAdapter(sql, cx);
da.Fill(ds, "usuariosxperfiles");
return "Guardado";
}
catch (Exception ex)
{
return "Error al Guardar";
}
}
public DataSet ObtenerUsuario(Usuario usuario)
{
sql = "SP_ObtenerUsuario";
try
{
if (conn.abrirConexion() == true)
{
SqlCommand comando = new SqlCommand(sql, conn.conn);
if (usuario.Correo == null)
{
comando.Parameters.AddWithValue("@p_us_correo", DBNull.Value);
comando.Parameters.Add("@p_us_nombre", SqlDbType.VarChar).Value = usuario.Nombre;
}
else {
comando.Parameters.Add("@p_us_correo", SqlDbType.VarChar).Value = usuario.Correo;
comando.Parameters.AddWithValue("@p_us_nombre", DBNull.Value);
}
comando.CommandType = CommandType.StoredProcedure;
SqlDataAdapter adaptador = new SqlDataAdapter(comando);
adaptador.Fill(ds, "Datos");
}
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
conn.cerrarConexion();
return ds;
}
public void ModificarUsuario(Usuario u)
{
}
public string RegistrarSinPermisos(Usuario u)
{
try
{
var sql = "";
var sql2 = "";
var cx = new SqlConnection();
var id_perfil = 0;
var documento = 0;
var pass = "";
var estado = 1;
var ds = new DataSet();
id_perfil = u.Id_perfil;
documento = u.Documento;
estado = u.Estado;
pass = u.Pass;
sql = "delete from UsuariosXPerfiles where documento ="+u.Documento;
cx.ConnectionString = conexion.ConexionString;
var da = new SqlDataAdapter(sql, cx);
da.Fill(ds, "UsuariosXPerfiles");
sql2 = "Insert into UsuariosXPerfiles (id_perfil, documento, pass, estado) Values ('" + id_perfil + "','" +
documento + "','" + pass + "','" + estado + "')";
cx.ConnectionString = conexion.ConexionString;
var da2 = new SqlDataAdapter(sql2, cx);
da2.Fill(ds, "UsuariosXPerfiles");
return "Guardado";
}
catch (Exception ex)
{
return "Error al Guardar";
}
}
private void FixupUsuario(Usuario previousValue)
{
if (previousValue != null && previousValue.SesionActual.Contains(this))
{
previousValue.SesionActual.Remove(this);
}
if (Usuario != null)
{
if (!Usuario.SesionActual.Contains(this))
{
Usuario.SesionActual.Add(this);
}
if (AS_US_DESCR != Usuario.US_NOMBRE)
{
AS_US_DESCR = Usuario.US_NOMBRE;
}
}
}
public DataSet ObtenerUsuario(Usuario usuario)
{
try
{
ds = dao_usuario.ObtenerUsuario(usuario);
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
return ds;
}
protected void Page_Load(object sender, EventArgs e)
{
usuario1 = (Usuario)(Session["usuario_logueado"]);
((MPRedSocial)this.Master).LnkPerfil = usuario1.Correo;
usuario2 = (Usuario)(Session["usuario_perfil"]);
lblNombre.Text = usuario2.Nombre + ' ' + usuario2.ApellidoPaterno + ' ' + usuario2.ApellidoMaterno;
ObtenerRelacion();
}
public bool ConsultarUsuarios(Usuario us)
{
var nombre = us.Nombre;
var pass = us.Pass;
var sql = "";
var cx = new SqlConnection();
var ds = new DataSet();
sql = @"select * from usuariosxperfiles where documento='" + nombre + "' and pass='******' and estado=1";
try
{
cx.ConnectionString = conexion.ConexionString;
var da = new SqlDataAdapter(sql, cx);
da.Fill(ds, "usuariosxperfiles");
return true;
}
catch (Exception ex)
{
return false;
}
}
protected void Page_Load(object sender, EventArgs e)
{
usuarioEmisor = (Usuario)Session["usuario_logueado"];
usuarioReceptor = (Usuario)Session["usuario_perfil"];
ObtenerMensajes();
}
public int ObtenerIDUsuarrio(Usuario usuario)
{
int idUsuario;
try
{
idUsuario = dao_usuario.ObtenerIDUsuarrio(usuario);
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
return idUsuario;
}
public string Registrar(Usuario u)
{
try
{
var sql = "";
var cx = new SqlConnection();
var documento = 0;
var pass = "";
var id_perfil = 0;
var estado = 1;
var ds = new DataSet();
documento = u.Documento;
pass = u.Pass;
id_perfil = u.Id_perfil;
estado = u.Estado;
sql = "Insert into UsuariosXPerfiles (documento, pass, id_perfil, estado) Values ('" + documento + "','" +
pass + "','" + id_perfil + "'," + estado + ")";
cx.ConnectionString = conexion.ConexionString;
var da = new SqlDataAdapter(sql, cx);
da.Fill(ds, "usuariosxperfiles");
return "Guardado";
}
catch (Exception ex)
{
return "Error al Guardar";
}
}
public void EliminarUsuario(Usuario u)
{
}
public Usuario[] getUsuarios()
{
Usuario[] usuarios=null;
dTable = new DataTable("usuarios");
try
{
myCon.Open();
adapter = new SqlDataAdapter("select * from Usuario", myCon);
adapter.Fill(dTable);
usuarios = new Usuario[dTable.Rows.Count];
for (int i = 0; i < usuarios.Length; i++)
{
usuarios[i] = new Usuario();
usuarios[i].Usu = dTable.Rows[i]["Usu"].ToString();
usuarios[i].Clave = dTable.Rows[i]["Clave"].ToString();
usuarios[i].Legajo = (int)dTable.Rows[i]["Legajo"];
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
finally
{
myCon.Close();
}
return usuarios;
}