public static List <UsuarioRol> ObtenerUsuarioRol()
{
var dataTable = new DataTable();
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand sqlCommand = new SqlCommand(null, connection);
sqlCommand.CommandText = "select * from UsuarioRol";
connection.Open();
var DataAdapter = new SqlDataAdapter(sqlCommand);
DataAdapter.Fill(dataTable);
usuarioRol = new List <UsuarioRol>();
for (int i = 0; i < dataTable.Rows.Count; i++)
{
UsuarioRol usuariorol = new UsuarioRol();
usuariorol.idUsuarioRol = int.Parse(dataTable.Rows[i]["idUsuarioRol"].ToString());
usuariorol.idRol = int.Parse(dataTable.Rows[i]["idRol"].ToString());
usuariorol.idUsuario = int.Parse(dataTable.Rows[i]["idUsuario"].ToString());
usuarioRol.Add(usuariorol);
}
return(usuarioRol);
}
}
protected void GridView_Usuarios_RowCommand(object sender, GridViewCommandEventArgs e)
{
if (e.CommandName == "Edit")
{
int idUsuario = Convert.ToInt32(e.CommandArgument);
ViewState["idUsuario"] = idUsuario;
UsuarioRol c = (from x in ModelBD_Usuario.UsuarioRol
where x.IdUsuario == idUsuario
select x).First();
NombreUsuario.Text = c.Usuario.NombreCompleto;
NombreUsuario.Enabled = false;
ddlRol.DataSource = (from p in ModelBD_Usuario.TipoRol
orderby p.FechaRegistro descending
select new { p.IdTipoRol, p.NombreRol }).ToList();
ddlRol.DataTextField = "NombreRol";
ddlRol.DataValueField = "IdTipoRol";
ddlRol.DataBind();
ChK_Modulos.DataSource = (from p in ModelBD_Usuario.Modulo
where p.IdModulo == 1
select new { p.IdModulo, p.Nombre }).ToList();
ChK_Modulos.DataTextField = "Nombre";
ChK_Modulos.DataValueField = "IdModulo";
ChK_Modulos.DataBind();
ScriptManager.RegisterStartupScript(Page, Page.GetType(), "myModal", "$('#myModal').modal();", true);
upModal.Update();
}
}
public async Task <IActionResult> EditUsuarioRol(string rolId)
{
ViewBag.rolId = rolId;
var role = await gestionRoles.FindByIdAsync(rolId);
if (role == null)
{
ViewBag.ErrorMessage = $"Rol con el Id = {rolId} no fue encontrado";
return(View("Error"));
}
var model = new List <UsuarioRol>();
foreach (var user in gestionUsuarios.Users)
{
var usuarioRol = new UsuarioRol
{
UsuarioId = user.Id,
UsuarioNombre = user.UserName
};
if (await gestionUsuarios.IsInRoleAsync(user, role.Name))
{
usuarioRol.EstaSeleccionado = true;
}
else
{
usuarioRol.EstaSeleccionado = false;
}
model.Add(usuarioRol);
}
return(View(model));
}
public ActionResult UsuarioAgregar(string Nomina, string rol)
{
int idrol = int.Parse(rol);
var quer = from user in db.UsuarioRol
where user.Nomina == Nomina
select user;
int contador = quer.Count();
if (quer.Count() == 0)
{
//No existe vamos a agregar ese dato.
UsuarioRol usuriorol = new UsuarioRol
{
id_rol = idrol,
Nomina = Nomina
};
db.UsuarioRol.Add(usuriorol);
db.SaveChanges();
ViewBag.resultado = "Agregado";
}
else
{
ViewBag.resultado = "TieneAsignacion";
}
return(View());
}
public static int AgregarUsuarioRol(UsuarioRol ur)
{
int insert = 0;
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlCommand sqlCommand = new SqlCommand(null, connection);
sqlCommand.CommandText = "insert into UsuarioRol values(@idUsuarioRol, @idRol, @idUsuario)";
sqlCommand.Parameters.AddWithValue("@idUsuarioRol", ur.idUsuarioRol);
sqlCommand.Parameters.AddWithValue("@idRol", ur.idRol);
sqlCommand.Parameters.AddWithValue("@idUsuario", ur.idUsuario);
try
{
connection.Open();
insert = sqlCommand.ExecuteNonQuery();
connection.Close();
}
catch (Exception ex)
{
Console.WriteLine(">>>>>>>>" + ex.GetType());
Console.WriteLine(">>>>>>>>" + ex.Message);
}
}
return(insert);
}
// GET: UsuarioRol
public ActionResult Index()
{
try
{
var dato = ObjUsuarioRol.ConsultarUsuarioRol();
List <UsuarioRol> ListaUsuarioRoles = new List <UsuarioRol>();
foreach (var item in dato)
{
UsuarioRol usuariorol = new UsuarioRol();
usuariorol.IdUsuarioRol = item.IdUsuarioRol;
usuariorol.IdRol = item.IdRol;
usuariorol.IdUsuario = item.IdUsuario;
ListaUsuarioRoles.Add(usuariorol);
}
return(View(ListaUsuarioRoles));
}
catch (Exception ex)
{
return(new HttpNotFoundResult("Error al consultar el UsuarioRoles"));
}
}
public ActionResult AgregarRol(UsuarioViewModel usuarioVM)
{
if (ModelState.IsValid)
{
if (usuarioVM.RolIdFromVista == 0 || usuarioVM.SucursalIdFromVista == 0)
{
ViewBag.Error = "No pudo agregarse el Rol, vuelva a intentarlo.";
}
else if (usuarioVM.Roles.Exists(a => a.Rol.Id == usuarioVM.RolIdFromVista && a.Sucursal.Id == usuarioVM.SucursalIdFromVista))
{
ViewBag.Error = "El Rol seleccionado ya existe.";
}
else
{
//Creo un Usuario Rol y lo agrego a la lista usuarioVM.Roles
UsuarioRol UsuarioRol = new UsuarioRol();
UsuarioRol.RolID = usuarioVM.RolIdFromVista;
UsuarioRol.Rol = _rolesServicios.GetOne(usuarioVM.RolIdFromVista);
UsuarioRol.SucursalID = usuarioVM.SucursalIdFromVista;
UsuarioRol.Sucursal = _sucursalesServicios.GetOne(usuarioVM.SucursalIdFromVista);
usuarioVM.Roles.Add(UsuarioRol);
}
}
else
{
ViewBag.Error = "No pudo agregarse el Rol, vuelva a intentarlo.";
}
LLenarDropDownList();
return(View("Agregar", usuarioVM));
}
// GET: UsuarioRol
public ActionResult Index()
{
try
{
var datos = ObjUsuarioRol.ConsultarUsuarioRol();
List <UsuarioRol> ListaUsuarioRols = new List <UsuarioRol>();
foreach (var item in datos)
{
UsuarioRol usuarioRol = new UsuarioRol();
usuarioRol.IdUsuarioRol = item.IdUsuarioRol;
usuarioRol.Nombre = item.Nombre;
usuarioRol.Descripcion = item.Descripcion;
ListaUsuarioRols.Add(usuarioRol);
}
return(View(ListaUsuarioRols));
}
catch (Exception)
{
return(View());
throw;
}
}
private void GetDatabaseUserRolesPermisos()
{
using (RequerimientosConn _data = new RequerimientosConn())
{
Usuarios _user = _data.Usuarios.Where(u => u.Usuario == this.Usuario).FirstOrDefault();
if (_user != null)
{
this.User_Id = _user.User_Id;
foreach (ROLES _rol in _user.ROLES)
{
UsuarioRol _userRole = new UsuarioRol {
Rol_Id = _rol.Rol_Id, Nombre = _rol.Nombre
};
foreach (Permisos _permissions in _rol.Permisos)
{
_userRole.Permisos.Add(new RolPermiso {
Permiso_Id = _permissions.Permiso_Id, Descripcion = _permissions.Descripcion
});
}
this.Roles.Add(_userRole);
if (!this.EsAdmin)
{
this.EsAdmin = _rol.EsAdmin;
}
}
}
}
}
public async Task <IHttpActionResult> PutUsuarioRol(int id, UsuarioRol usuarioRol)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != usuarioRol.ID)
{
return(BadRequest());
}
db.Entry(usuarioRol).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UsuarioRolExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public string GetRol()
{
int rolAdministrador = 1, rolResponsable = 2, rolAdmStock = 4;
usr = (Usuario)System.Web.HttpContext.Current.Session["UsuarioActual"];
sucID = (int)System.Web.HttpContext.Current.Session["SucursalActual"];
UsuarioRol UsuarioRol = usr.Roles.Where(x => x.RolID == rolAdministrador && x.SucursalID == sucID).FirstOrDefault();
if (UsuarioRol != null)
{
return("administrador");
}
else
{
UsuarioRol = usr.Roles.Where(x => x.RolID == rolResponsable && x.SucursalID == sucID).FirstOrDefault();
if (UsuarioRol != null)
{
return("responsable");
}
else
{
UsuarioRol = usr.Roles.Where(x => x.RolID == rolAdmStock && x.SucursalID == sucID).FirstOrDefault();
if (UsuarioRol != null)
{
return("adm. de stock");
}
else
{
return("vendedor");
}
}
}
}
public int ActualizarUsuarioRol(UsuarioRol oUsuarioRol)
{
int Codigo = -1;
try
{
using (SqlConnection cn = new SqlConnection(Conexion.conexion))
{
using (SqlCommand cmd = new SqlCommand("Seguridad.UsuarioRol_Actualizar_SP", cn))
{
cn.Open();
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@IdUsuario", oUsuarioRol.IdUsuario);
cmd.Parameters.AddWithValue("@IdRol", oUsuarioRol.IdRol);
cmd.Parameters.AddWithValue("@UsuarioModificacion", oUsuarioRol.UsuarioModificacion);
Codigo = (Convert.ToInt16(cmd.ExecuteScalar()));
}
}
}
catch (Exception ex)
{
throw ex;
}
return(Codigo);
}
public ActionResult Index()
{
try
{
var datos = ObjUsuarioRol.ConsultarUsuarioRol();
List <UsuarioRol> ListaUsuarios = new List <UsuarioRol>();
foreach (var item in datos)
{
UsuarioRol usuarioRol = new UsuarioRol
{
IdUsuarioRol = item.IdUsuarioRol,
IdUsuario = item.IdUsuario,
Usuario = item.Usuario,
IdRol = item.IdRol,
Rol = item.Rol
};
ListaUsuarios.Add(usuarioRol);
}
return(View(ListaUsuarios));
}
catch (Exception)
{
throw;
}
}
public ActionResult Editar(int id)
{
try
{
var dato = ObjUsuarioRol.ConsultaUsuarioRol(id);
UsuarioRol usuario = new UsuarioRol
{
IdUsuarioRol = dato.IdUsuarioRol,
IdUsuario = dato.IdUsuario,
IdRol = dato.IdRol
};
ViewBag.Roles = ListaRoles().Where(x => x.Estado == true);
ViewBag.Usuarios = ListaUsuarios().Where(x => x.Estado == true);
return(View(usuario));
}
catch (Exception)
{
return(View());
throw;
}
}
public async Task <IActionResult> PutUsuariosRoles(int id, UsuarioRol usuarioRol)
{
if (id != usuarioRol.Id)
{
return(BadRequest());
}
_context.Entry(usuarioRol).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UsuariosRolesExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <UsuarioRol> > PostUsuariosRoles(UsuarioRol usuarioRol)
{
_context.UsuariosRoles.Add(usuarioRol);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetUsuariosRoles", new { id = usuarioRol.Id }, usuarioRol));
}
public ActionResult Editar(UsuarioRol usuarioRol)
{
try
{
if (ObjUsuarioRol.ActualizarUsuarioRol(usuarioRol.IdUsuarioRol, usuarioRol.IdUsuario, usuarioRol.IdRol))
{
return(RedirectToAction("Index"));
}
else
{
ViewBag.Usuario = ConsultarUsuario();
ViewBag.Rol = ConsultarRol();
return(View());
}
}
catch (Exception)
{
ViewBag.Usuario = ConsultarUsuario();
ViewBag.Rol = ConsultarRol();
return(View());
throw;
}
}
public RegistroExitosoDTO Registro(UsuarioRegistroDTO usuario)
{
if (usuario == null)
{
throw new Exception("Ha ocurrudo un error");
}
if (usuario.Nombre == "" || usuario.Apellido == "" || usuario.Email == "" || usuario.Contraseña == "")
{
throw new Exception("Por favor ingrese caracteres validos");
}
var usuarioDb = new Usuario()
{
Apellido = usuario.Apellido,
Nombre = usuario.Nombre,
Contraseña = GetHash(usuario.Contraseña),
Email = usuario.Email,
};
this.Repository.Add(usuarioDb);
var usuarioRol = new UsuarioRol()
{
UsuarioId = usuarioDb.UsuarioId,
RolId = usuario.RolId
};
((IUsuarioRepository)Repository).AddUsuarioRol(usuarioRol);
return(new RegistroExitosoDTO {
Estado = "Registro Exitoso"
});
}
/// <summary>
/// Descripción: Edita rol para un usuario.
/// Author: Terceros.
/// Fecha Creacion: 01/01/2017
/// Fecha Modificación: 02/02/2017.
/// Modificación: Se agregaron comentarios.
/// </summary>
/// <param name="usuarioRol"></param>
public void UpdateRolByUsuario(UsuarioRol usuarioRol)
{
using (var usuarioRolDal = new UsuarioRolDal())
{
usuarioRolDal.UpdateRolByUsuario(usuarioRol);
}
}
public ActionResult DeleteConfirmed(int id)
{
UsuarioRol usuarioRol = db.UsuarioRols.Find(id);
db.UsuarioRols.Remove(usuarioRol);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public UsuarioLogeado(int id, string nombre, string mail, UsuarioRol role, DateTime?momentoCreacion = null)
{
Id = id;
Nombre = nombre;
Mail = mail;
Role = role;
MomentoCreacion = momentoCreacion ?? DateTime.Now;
}
private static UsuarioRol ConvertToUsuarioRolViewModel(this UsuarioRolViewModel usuarioRolViewModel)
{
var usuarioRol = new UsuarioRol()
{
UsuarioId = usuarioRolViewModel.UsuarioId,
RolId = usuarioRolViewModel.RolId
};
return(usuarioRol);
}
public ActionResult Edit([Bind(Include = "ID,id_rol,id_usuario")] UsuarioRol usuarioRol)
{
if (ModelState.IsValid)
{
db.Entry(usuarioRol).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(usuarioRol));
}
public async Task <IHttpActionResult> GetUsuarioRol(int id)
{
UsuarioRol usuarioRol = await db.UsuarioRol.FindAsync(id);
if (usuarioRol == null)
{
return(NotFound());
}
return(Ok(usuarioRol));
}
public string EditUsuario(UsuarioViewModel model)
{
if (ValidarUsuario(model))
{
try
{
var usuario = _uow.UsuarioRepository.Find(x => x.UsuarioId == model.UsuarioId);
usuario.Apellido = model.Apellido;
usuario.Email = model.Email;
usuario.Nombre = model.Nombre;
var rolesList = _uow.UsuarioRolRepository
.FilterIncluding(x => x.UsuarioId == model.UsuarioId, y => y.Rol, z => z.Usuario).ToList();
foreach (var rol in rolesList)
{
_uow.UsuarioRolRepository.Delete(rol);
}
_uow.UsuarioRepository.Update(usuario);
var rolesListNew = model.ArrayRoles != null
? model.ArrayRoles.Split(',').ToList()
: new List <string>();
foreach (var rol in rolesListNew)
{
var usuarioRol = new UsuarioRol()
{
RolId = int.Parse(rol),
UsuarioId = model.UsuarioId
};
_uow.UsuarioRolRepository.Create(usuarioRol);
}
_uow.Save();
_logger.LogInformation("Se editó correctamente el Usuario <{0} con el ID <{1}>",
model.Nombre + " " + model.Apellido, model.UsuarioId);
return("Usuario editado correctamente");
}
catch (Exception ex)
{
_uow.Dispose();
_logger.LogErrorException(ex, "Ocurrió un problema al editar el Usuario <{0}> con el ID <{1}>",
model.Nombre + " " + model.Apellido, model.UsuarioId);
throw new UpdateRecordException("Ocurrió un error al editar el usuario", ex);
}
}
else
{
_logger.LogError(
"[ERROR VALIDACION EN SERVER] - Ocurrió un error al editar un usuario. Uno o mas datos son incorrectos.");
return("FailModel");
}
}
public ActionResult Create([Bind(Include = "ID,id_rol,id_usuario")] UsuarioRol usuarioRol)
{
if (ModelState.IsValid)
{
db.UsuarioRols.Add(usuarioRol);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(usuarioRol));
}
public ActionResult SignupMedico(Usuarios model, string nombreCompleto, string codigo, string cedula)
{
if (nombreCompleto == null)
{
nombreCompleto = "";
}
if (cedula == null)
{
cedula = "";
}
var empleadoExiste = (from a in context.Empleados.ToList()
join b in context.Usuarios.ToList() on a.ID equals b.EmpleadoID
where (a.Nombre + " " + a.Apellido).ToLower() == nombreCompleto.ToLower() &&
a.Cedula == StringExtenssion.SinGuion(cedula) && a.Tipo == "Medico"
select new { id = a.ID }).FirstOrDefault();
if (model.EmpleadoID == null && empleadoExiste == null)
{
nombreCompleto = StringExtenssion.SinTildes(nombreCompleto);
Empleados empleado = EmpleadoConsulta.FindEmpledoCredenciales(nombreCompleto, codigo, cedula, "Medico", context);
if (empleado != null)
{
ViewBag.EmpleadoID = empleado.ID;
}
else
{
ModelState.AddModelError("", "Las credenciales son incorrectas");
}
}
else if (empleadoExiste != null)
{
ModelState.AddModelError("", "Existe un usuario creado con estas credenciales");
}
else
{
model.Activo = true;
context.Usuarios.Add(model);
context.SaveChanges();
UsuarioRol usuarioRol = new UsuarioRol();
usuarioRol.Rol = "Medico";
usuarioRol.UsuarioID = context.Usuarios.ToList().Last().ID;
context.UsuarioRol.Add(usuarioRol);
context.SaveChanges();
FormsAuthentication.SetAuthCookie(model.Email, false);
return(RedirectToAction("HistorialMedico", "Medico"));
}
return(View());
}
public ActionResult Eliminar(UsuarioRol usuarioRol)
{
if (ObjUsuarioRol.EliminarUsuarioRol(usuarioRol.IdUsuarioRol))
{
return(RedirectToAction("Index"));
}
else
{
return(View());
}
}
public async Task <ActionResult <Usuarios> > PostUsuario(PersonaDto usuario)
{
var persona = new Personas {
Apellido = usuario.Apellido, Email = usuario.Email, Nombre = usuario.Nombre, Telefono = usuario.Telefono
};
var user = new Usuarios
{
UsuarioNombre = persona.Email,
IdPersona = usuario.IdPersona,
Password = BCrypt.Net.BCrypt.HashPassword(usuario.Password),
IdPersonaNavigation = persona,
FechaCreacion = DateTime.Now
};
var usuarioRol = new UsuarioRol {
IdRol = Convert.ToInt32(usuario.RolId), IdUsuarioNavigation = user,
};
if (usuario.RolId == "1")
{
var institucionEstudiante = new InstitucionEstudiante {
IdInstitucion = usuario.IdInstitucion, IdUsuarioNavigation = user
};
_context.InstitucionEstudiante.Add(institucionEstudiante);
}
if (usuario.RolId == "2")
{
var institucionDocente = new InstitucionDocente {
IdInstitucion = usuario.IdInstitucion, IdDocenteNavigation = user
};
_context.InstitucionDocente.Add(institucionDocente);
}
/*if (usuario.RolId == "3")
* {
* var institucionTutor = new InstitucionTutor { IdInstitucion = usuario.IdInstitucion, IdTutorNavigation = user };
* _context.InstitucionTutor.Add(institucionTutor);
* }*/
_context.Personas.Add(persona);
_context.Usuarios.Add(user);
_context.UsuarioRol.Add(usuarioRol);
if (!EmailExists(user.UsuarioNombre))
{
await _context.SaveChangesAsync();
return(CreatedAtAction("GetUsuario", new { id = user.IdUsuario }, usuario));
}
else
{
return(BadRequest(new { message = "Email ya existe en Base de Datos" }));
}
}
public async Task <IHttpActionResult> PostUsuarioRol(UsuarioRol usuarioRol)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.UsuarioRol.Add(usuarioRol);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = usuarioRol.ID }, usuarioRol));
}
