public IActionResult UpdateUserRole([FromBody] UserRoleUpdateDto userRoleUpdate)
        {
            var user = _unitOfWork.User.GetById(userRoleUpdate.UserId);

            if (user == null)
            {
                return(NotFound("User not found"));
            }

            var role = _transActionRepo.GetRole(userRoleUpdate.RoleId);

            if (role == null)
            {
                return(NotFound("Role not found"));
            }

            user.RoleId = role.RoleId;

            if (!_unitOfWork.Save())
            {
                return(StatusCode(500, "Error occurred while updating user role"));
            }

            return(CreatedAtRoute("GetUser", new { controller = "user", id = user.UserId }, _mapper.Map <UserDto>(user)));
        }
Beispiel #2
0
        public JsonResult UpdateRole(UserRoleUpdateDto dto)
        {
            try
            {
                if (dto.type == "Add")
                {
                    foreach (var u in dto.users)
                    {
                        int cnt = db.UserRoles.Where(ur => ur.username == u).Count();
                        if (cnt > 0)
                        {
                            db.UserRoles.Add(new UserRole {
                                roletype = dto.role, username = u, COMP_CODE = dto.company
                            });
                            UserRole role = db.UserRoles.Where(ur => ur.username == u).FirstOrDefault();
                            if (role != null)
                            {
                                //RoleLogs code added by Nagaraju Madishetti as part of IND29615692i-5/Nov/2018

                                string myIP        = Server.HtmlEncode(Request.UserHostAddress);
                                string currentuser = !string.IsNullOrEmpty(User?.Identity?.Name) ? User.Identity.Name.ToUpper() : "Anonymous";
                                currentuser = currentuser.Substring(currentuser.IndexOf('\\') + 1).Replace("\\", "").ToUpper();
                                string Activity = role.roletype.GetDisplayName() + " To " + dto.role.GetDisplayName() + " role";
                                db.Rolelogs.Add(new Rolelog {
                                    UserID = currentuser, IP = myIP, Target_User_ID = u, Activity = Activity, COMP_CODE = dto.company
                                });

                                role.roletype = dto.role;
                            }
                        }
                    }
                    db.SaveChanges();
                }
                else
                {
                    foreach (var u in dto.users)
                    {
                        IEnumerable <UserRole> list = db.UserRoles.Where(ur => ur.username == u && ur.roletype == dto.role).ToList();
                        db.UserRoles.RemoveRange(list);
                    }
                    db.SaveChanges();
                }
            }
            catch (Exception e)
            {
                log.Error(e);
                return(Json(new { result = false }));
            }
            return(Json(new { result = true }));
        }
        public IActionResult UpdateUserRole(int userId, [FromBody] UserRoleUpdateDto userRoleUpdate)
        {
            var user = _unitOfWork.User.GetById(userId);

            user.TraImage = null;
            user.Role     = null;
            if (user == null)
            {
                return(StatusCode(404, new TransActionResponse("User not found.")));
            }

            var role = _unitOfWork.Role.GetRoleById(userRoleUpdate.RoleId);

            if (role == null)
            {
                return(StatusCode(404, new TransActionResponse("Role not found")));
            }

            user.RoleId = role.RoleId;

            // Make sure the user can't revoke his own admin role if he is the only admin
            var adminRole  = _unitOfWork.Role.GetAllRoles().Where(x => x.Name.ToLower() == "admin").FirstOrDefault();
            var adminUsers = _unitOfWork.User.GetAdmins(adminRole.RoleId);

            if (role != adminRole && adminUsers.Count() == 1 && user == adminUsers.FirstOrDefault())
            {
                return(StatusCode(400, new TransActionResponse("Cannot change the only admin's role")));
            }

            _unitOfWork.User.Update(user);
            if (!_unitOfWork.Save())
            {
                return(StatusCode(500, new TransActionResponse("Error occurred while updating user role")));
            }

            return(CreatedAtRoute("GetUser", new { controller = "user", id = user.UserId }, _mapper.Map <UserDto>(user)));
        }
        public async Task <ActionResult> UpdateUserRole(Guid id, [FromBody] UserRoleUpdateDto roleDto)
        {
            // Check if the user exists
            var user = await UserApplication.GetUser(u => u.Id == id, false);

            if (user == null)
            {
                ErrorMessage error = new ErrorMessage((int)HttpStatusCode.NotFound, $"O usuário, {id}, não foi encontrado.");
                return(NotFound(error));
            }

            IEnumerable <RoleDto> lstRoles = null;

            if (roleDto.Roles.Count > 0)
            {
                var distinctRoles = roleDto.Roles.Distinct();

                if (distinctRoles.Count() != roleDto.Roles.Count())
                {
                    ErrorMessage error = new ErrorMessage((int)HttpStatusCode.BadRequest, $"Não é possível cadastrar regras duplicadas.");
                    return(BadRequest(error));
                }

                lstRoles = await RoleApplication.GetRoleIn(roleDto.Roles);

                if (lstRoles.Count() != roleDto.Roles.Count())
                {
                    ErrorMessage error = new ErrorMessage((int)HttpStatusCode.BadRequest, $"Existem regras inválidas.");
                    return(BadRequest(error));
                }
            }

            await UserApplication.UpdateAllUserRoles(user, lstRoles);

            return(Ok());
        }