public async Task <IActionResult> EditarUsuario(string id)
{
var user = await userManager.FindByIdAsync(id);
if (user == null)
{
ViewBag.ErrorMessage = $"Usuario con Id = {id} no existe";
return(View("NotFound404", "Error"));
}
// GetClaimsAsync retunrs the list of user Claims
var userClaims = await userManager.GetClaimsAsync(user);
// GetRolesAsync returns the list of user Roles
var userRoles = await userManager.GetRolesAsync(user);
var model = new EditarUsuarioViewModel
{
Id = user.Id,
Email = user.Email,
UserName = user.UserName,
NombreCompleto = user.NombreCompleto,
Claims = userClaims.Select(c => c.Value).ToList(),
Roles = userRoles
};
return(View(model));
}
public async Task <IActionResult> EditarUsuario(EditarUsuarioViewModel model)
{
var user = await userManager.FindByIdAsync(model.Id);
if (user == null)
{
ViewBag.ErrorMessage = $"Usuario con Id = {model.Id} no existe";
return(View("NotFound404", "Error"));
}
else
{
user.Email = model.Email;
user.UserName = model.UserName;
user.NombreCompleto = model.NombreCompleto;
user.LastUpdatedBy = HttpContext.User.Identity.Name;
user.LastUpdatedDate = DateTime.Now;
user.LastUpdatedIp = HttpContext.Connection.RemoteIpAddress.ToString();
var result = await userManager.UpdateAsync(user);
if (result.Succeeded)
{
return(RedirectToAction("Usuarios"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(model));
}
}
public async Task <IActionResult> EditarUsuario(EditarUsuarioViewModel model)
{
var usuario = await _gestionUsuarios.FindByIdAsync(model.Id);
if (usuario == null)
{
ViewBag.ErrorMessage = $"Usuario con ID = {model.Id} no fue encontrado";
return(View("Error"));
}
else
{
usuario.Email = model.Email;
usuario.UserName = model.NombreUsuario;
var resultado = await _gestionUsuarios.UpdateAsync(usuario);
if (resultado.Succeeded)
{
return(RedirectToAction("ListarUsuarios"));
}
foreach (var error in resultado.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(model));
}
}
public async Task <IActionResult> Editar(EditarUsuarioViewModel model)
{
if (string.IsNullOrEmpty(model.Cpf))
{
_toastNotification.AddErrorToastMessage("CPf Invalido!");
return(View(model));
}
var cpf = new CPF(model.Cpf);
cpf.SemFormatacao();
var usuario = await _userManager.FindByNameAsync(cpf.Codigo);
if (usuario != null)
{
usuario.UserName = cpf.Codigo;
usuario.NomeCompleto = model.NomeCompleto;
usuario.Email = model.Email;
usuario.PhoneNumber = model.Telefone;
await _userManager.UpdateAsync(usuario);
_toastNotification.AddSuccessToastMessage("Alteração Salva!");
return(RedirectToAction("ListaDeUsuarios", new { cpf = model.Cpf }));
}
_toastNotification.AddErrorToastMessage("Usuario não encotrado!");
return(View(model));
}
public async Task <IActionResult> EditarUsuario(string id)
{
var user = await userManager.FindByIdAsync(id);
if (user == null)
{
ViewBag.ErrorMessage = $"Usuario con id = {id} no se puede encontrar.";
return(View("ListaUsuarios"));
}
var userRoles = roleManager.Roles.OrderBy(x => x.Name).ToList();
var model = new EditarUsuarioViewModel
{
Id = user.Id,
Email = user.Email,
Roles = userRoles
};
for (int i = 0; i < userRoles.Count(); i++)
{
model.Pertenece.Add(await userManager.IsInRoleAsync(user, userRoles.ElementAt(i).Name));
}
return(View(model));
}
public async Task <ActionResult> Editar(
[Bind(Include = "Email,Id, Nombre, Apellido, Estado")] EditarUsuarioViewModel editUser,
params string[] selectedGroups)
{
if (ModelState.IsValid)
{
var user = await UserManager.FindByIdAsync(editUser.Id);
if (user == null)
{
return(HttpNotFound());
}
// Update the User:
user.UserName = editUser.Email;
user.Email = editUser.Email;
user.Nombre = editUser.Nombre;
user.Apellido = editUser.Apellido;
user.Estado = editUser.Estado;
await this.UserManager.UpdateAsync(user);
// Update the Groups:
selectedGroups = selectedGroups ?? new string[] { };
await this.GroupManager.SetUserGroupsAsync(user.Id, selectedGroups);
return(RedirectToAction("Index"));
}
ModelState.AddModelError("", "Something failed.");
return(View());
}
public async Task <IActionResult> EditarUsuario(EditarUsuarioViewModel model)
{
var user = await userManager.FindByIdAsync(model.Id);
var roles = roleManager.Roles.OrderBy(x => x.Name).ToList();
if (user == null)
{
ViewBag.ErrorMessage = $"Usuario con id = {model.Id} no se puede encontrar.";
return(View("EditarUsuario"));
}
else
{
for (int i = 0; i < roles.Count; i++)
{
if (model.Pertenece[i])
{
await userManager.AddToRoleAsync(user, roles[i].Name);
}
else
{
await userManager.RemoveFromRoleAsync(user, roles[i].Name);
}
}
return(RedirectToAction("ListaUsuarios"));
}
}
// GET: Usuarios/Edit/5
public ActionResult Edit(int id)
{
var model = _usuariosDAO.ListadoRolesXUsuarios(id);
var listaDeRolesParaMultiSelect = new EditarUsuarioViewModel();
var listadoDeRoles = new List <SelectListItem>();
//MI LISTA DE ROLES CORRESPONDIENTES AL USUARIO
IEnumerable <Rol> roles = _usuariosDAO.ListadoRolesXUsuarios(id).First().Rol;
//MI LISTA COMPLETA DE ROLES
IEnumerable <Rol> rolesUsuario = _usuariosDAO.listadoDeRoles();
foreach (var rol in rolesUsuario)
{
var selected = roles.Any(ru => ru.Id_Rol == rol.Id_Rol);
//var selected = _rolesID.Any(ru => ru.Id_Rol == rol.Id_Rol);
listadoDeRoles.Add(new SelectListItem
{
Selected = selected,
Text = rol.Descripcion,
Value = rol.ToString()
});
}
listaDeRolesParaMultiSelect.Roles = listadoDeRoles;
return(View(listaDeRolesParaMultiSelect));
}
// GET: Reembolso/Edit/5
public ActionResult Edit(string id)
{
EditarUsuarioViewModel model = new EditarUsuarioViewModel();
model.Nome = "Gustavo";
return(RedirectToAction("CriarUsuarioView", "Reembolso", model));
//return View("CriarUsuarioView","Reembolso", id);
}
// GET: Usuarios/Edit/5
public ActionResult Edit(string id)
{
var usuario = Servicios.AspNetUsersServicio.obtener(id);
EditarUsuarioViewModel usuarioModelo = new EditarUsuarioViewModel();
usuarioModelo.Id = usuario.Id;
usuarioModelo.NombreApellido = usuario.NombreApellido;
usuarioModelo.Email = usuario.Email;
usuarioModelo.UserName = usuario.UserName;
return(View(usuarioModelo));
}
public async Task <IActionResult> Editar(string email)
{
var usuario = await _userManager.FindByEmailAsync(email);
EditarUsuarioViewModel usuarioModel = new EditarUsuarioViewModel
{
NomeCompleto = usuario.NomeCompleto,
Cpf = usuario.UserName,
Email = usuario.Email,
Telefone = usuario.PhoneNumber,
};
return(View(usuarioModel));
}
public ActionResult Edit(EditarUsuarioViewModel usuario)
{
try
{
var Usuario = Servicios.AspNetUsersServicio.obtener(usuario.Id);
var EmailNuevo = usuario.Email;
bool mailRepetido = false;
if (EmailNuevo != Usuario.Email)
{
mailRepetido = Servicios.AspNetUsersServicio.existeEmail(EmailNuevo);
}
var UserNameNuevo = usuario.UserName;
bool userNameRepetido = false;
if (UserNameNuevo != Usuario.UserName)
{
userNameRepetido = Servicios.AspNetUsersServicio.existeUserName(UserNameNuevo);
}
if (!mailRepetido)
{
if (!userNameRepetido)
{
var Id = usuario.Id;
var NombreApellido = usuario.NombreApellido;
if (Servicios.AspNetUsersServicio.editar(Id, NombreApellido, EmailNuevo, UserNameNuevo))
{
return(RedirectToAction("Index"));
}
}
else
{
ModelState.AddModelError("UserName", "El UserName ingresado ya existe");
}
}
else
{
ModelState.AddModelError("Email", "El Email ingresado ya existe");
}
return(View(usuario));
}
catch
{
return(View());
}
}
public ActionResult EditarUsuario(int Id)
{
var usuarioLogeado = User.Identity.GetUserId <int>();
var usuarioEditar = context.Users.FirstOrDefault(u => u.Id == Id);
if (usuarioEditar == null)
{
return(View("Error404"));
}
EditarUsuarioViewModel model = new EditarUsuarioViewModel();
var roles = context.Roles;
foreach (CustomRole rol in roles)
{
model.Roles.Add(new UsuarioRolViewModel()
{
RolId = rol.Id, Name = rol.Name, Selected = false
});
}
var rolesUsuario = usuarioEditar.Roles;
foreach (CustomUserRole rol in rolesUsuario)
{
var rolenusuario = model.Roles.FirstOrDefault(r => r.RolId == rol.RoleId);
if (rolenusuario != null)
{
rolenusuario.Selected = true;
}
}
model.Id = usuarioEditar.Id;
model.LastName = usuarioEditar.LastName;
model.FirstName = usuarioEditar.FirstName;
model.CellPhone = usuarioEditar.CellPhone;
model.UserName = usuarioEditar.UserName;
return(View(model));
}
public async Task <IActionResult> EditUser(EditarUsuarioViewModel model)
{
var user = await UserManager.FindByIdAsync(model.Id);
if (user == null)
{
return(View("Usuário não encontrado"));
}
else
{
user.Email = model.Email;
var result = await UserManager.UpdateAsync(user);
if (result.Succeeded)
{
return(RedirectToAction("ListUsers"));
}
return(View(model));
}
}
public ActionResult EditaUsuario(EditarUsuarioViewModel model)
{
var user = PegaUsuario(model.ClienteID);
if (!ModelState.IsValid)
{
return(View(user));
}
var valido = ValidaCPF(model.CPF, model.ClienteID);
if (valido)
{
//var user = PegaUsuario(model.ClienteID);
var usero = PegaUsuario(model.ClienteID);
if (user == null)
{
return(RedirectToAction("UsuariosLista", "Admin"));
}
user.DataModificacao = DateTime.Now;
user.Nome = model.Nome;
user.Email = model.Email;
user.CPF = model.CPF;
user.DataNascimento = model.DataNascimento;
user.Ativo = model.Ativo;
user.Telefone = model.Telefone;
try
{
context.Entry(usero).CurrentValues.SetValues(user);
context.SaveChanges();
return(RedirectToAction("UsuariosLista", "Admin"));
}
catch (Exception e)
{
ModelState.AddModelError("Erro", e);
return(View(user));
}
}
ModelState.AddModelError("CPF", "CPF já existente");
return(View(user));
}
public async Task <IActionResult> EditUser(string id)
{
var user = await UserManager.FindByIdAsync(id);
if (user == null)
{
return(View("Usuário não encontrado"));
}
var userClaims = await UserManager.GetClaimsAsync(user);
var userRoles = await UserManager.GetRolesAsync(user);
var model = new EditarUsuarioViewModel {
Id = user.Id,
Email = user.Email,
Claims = userClaims.Select(c => c.Value).ToList(),
Roles = userRoles
};
return(View(model));
}
public ActionResult Edit(EditarUsuarioViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
var usuario = _repositorio.Get(model.Id);
usuario.AlterarInfo(model.Nome, model.Email, model.NomeUsuario, model.Senha, model.ConfirmaSenha);
_repositorio.SaveOrUpdate(usuario);
}
catch (Exception ex)
{
ModelState.AddModelError("ErroDefault", ex.Message);
return(View(model));
}
return(RedirectToAction("Index"));
}
public ResultViewModel Post([FromBody] EditarUsuarioViewModel model)
{
if (model.Invalid)
{
return new ResultViewModel
{
Success = false,
Message = "Não foi possível cadastrar o usuario",
Data = model.Notifications
}
}
;
var usuario = new Usuario();
usuario.Nome = model.Nome;
usuario.Cpf = model.Cpf;
usuario.Sexo = model.Sexo;
usuario.Endereco = model.Endereco;
usuario.Login = model.Login;
usuario.Senha = model.Senha;
db.Usuarios.Add(usuario);
db.SaveChanges();
return(new ResultViewModel
{
Success = true,
Message = "Usuario cadastrado com sucesso!",
Data = usuario
});
}
// [Route("v1/usuarios/{id}")]
// [HttpGet]
// public Usuario Get(int id)
// {
// return db.Usuarios.FirstOrDefault(x => x.Id == id);
// }
}
public ActionResult Edit(int id, EditarUsuarioViewModel model)
{
var rol = _usuariosDAO.recuperarRoles(model.RolSeleccionado);
try
{
_usuariosDAO.EditarUsuario(rol, new LoginUsuario()
{
Id_Usuario = id,
Username = model.Usuario,
Password = model.Password,
Rol = rol
});
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public async Task <ActionResult> Editar(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var user = await UserManager.FindByIdAsync(id);
if (user == null)
{
return(HttpNotFound());
}
// Display a list of available Groups:
var allGroups = this.GroupManager.Groups;
var userGroups = await this.GroupManager.GetUserGroupsAsync(id);
var model = new EditarUsuarioViewModel()
{
Id = user.Id,
Email = user.Email,
Nombre = user.Nombre,
Apellido = user.Apellido,
Estado = user.Estado
};
foreach (var group in allGroups)
{
var listItem = new SelectListItem()
{
Text = group.Name,
Value = group.Id,
Selected = userGroups.Any(g => g.Id == group.Id)
};
model.GroupsList.Add(listItem);
}
return(View(model));
}
public ActionResult EditarUsuario(EditarUsuarioViewModel model)
{
try
{
if (!ModelState.IsValid)
{
return(View());
}
var user = context.Users.First(u => u.Id == model.Id);
user.Roles.Clear();
foreach (UsuarioRolViewModel rol in model.Roles.Where(r => r.Selected))
{
user.Roles.Add(new CustomUserRole()
{
RoleId = rol.RolId, UserId = model.Id
});
}
user.CellPhone = model.CellPhone;
user.FirstName = model.FirstName;
user.LastName = model.LastName;
context.Users.Attach(user);
context.Entry(user).State = EntityState.Modified;
context.SaveChanges();
return(RedirectToAction("Usuarios"));
}
catch
{
return(View());
}
}
public async Task <IActionResult> UpdateUsuario([FromBody] EditarUsuarioViewModel userViewModel)
{
try
{
var userDTO = _mapper.Map <UsuarioDTO>(userViewModel);
var userUpdated = await _usuarioServico.Update(userDTO);
return(Ok(new ResultViewModel
{
Message = "Usuário atualizado com sucesso!",
Success = true,
Data = userUpdated
}));
}
catch (ExecoesDominio ex)
{
return(BadRequest(Responses.DomainErrorMessage(ex.Message, ex.Erros)));
}
catch (Exception ex)
{
return(StatusCode(500, ex));
}
}
public ActionResult Create(EditarUsuarioViewModel model)
{
if (!ModelState.IsValid)
{
// ModelState.AddModelError("ErroDefault", Teste(ViewData.ModelState).ToString());
ModelState.AddModelError("ErroDefault", "Testesssssssssssss");
return(View(model));
}
try
{
var usuario = new Usuario(model.Nome, model.Email, model.NomeUsuario, model.Senha);
usuario.Registrar(model.Nome, model.Email, model.NomeUsuario, model.Senha, model.ConfirmaSenha);
_repositorio.SaveOrUpdate(usuario);
}
catch (Exception ex)
{
ModelState.AddModelError("ErroDefault", ex.Message);
return(View(model));
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> EditarUsuario(string id)
{
var usuario = await _gestionUsuarios.FindByIdAsync(id);
if (usuario == null)
{
ViewBag.ErrorMessage = $"Usuario con ID = {id} no fue encontrado";
return(View("Error"));
}
var usuarioClaims = await _gestionUsuarios.GetClaimsAsync(usuario);
var usuarioRol = await _gestionUsuarios.GetRolesAsync(usuario);
var model = new EditarUsuarioViewModel
{
Id = usuario.Id,
Email = usuario.Email,
NombreUsuario = usuario.UserName,
Notificaciones = usuarioClaims.Select(c => c.Value).ToList(),
Roles = usuarioRol
};
return(View(model));
}
public async Task <IActionResult> Put([FromBody] EditarUsuarioViewModel viewModel) => await Execute <EditarUsuarioCommand, EditarUsuarioViewModel>(viewModel);