Пример #1
0
        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));
        }
Пример #2
0
        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));
            }
        }
Пример #3
0
        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));
            }
        }
Пример #4
0
        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));
        }
Пример #5
0
        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));
        }
Пример #6
0
        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());
        }
Пример #7
0
        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"));
            }
        }
Пример #8
0
        // 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);
        }
Пример #10
0
        // 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));
        }
Пример #11
0
        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));
        }
Пример #12
0
 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());
     }
 }
Пример #13
0
        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));
            }
        }
Пример #15
0
        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));
        }
Пример #17
0
        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"));
        }
Пример #18
0
        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);

        //     }
    }
Пример #19
0
        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());
            }
        }
Пример #20
0
        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));
        }
Пример #21
0
        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());
            }
        }
Пример #22
0
        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));
            }
        }
Пример #23
0
        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"));
        }
Пример #24
0
        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));
        }
Пример #25
0
 public async Task <IActionResult> Put([FromBody] EditarUsuarioViewModel viewModel)
 => await Execute <EditarUsuarioCommand, EditarUsuarioViewModel>(viewModel);