public override async Task <Empty> UpdateUserRole(UpdateUserRoleRequest request, ServerCallContext context)
{
var updateUserRoleCommand = _mapper.Map <UpdateUserRoleCommand>(request);
var response = await _mediator.Send(updateUserRoleCommand);
return(new Empty());
}
public IActionResult UpdateUserRoles([FromBody] UpdateUserRoleRequest updateUserRoleRequest)
{
if (updateUserRoleRequest == null ||
string.IsNullOrWhiteSpace(updateUserRoleRequest.Login) ||
updateUserRoleRequest.RoleIds == null)
{
return(HandleBadRequest("A valid login name and a (potentially empty) list of user roles need to be supplied."));
}
List <Role> roles = new List <Role>();
try
{
foreach (int roleId in updateUserRoleRequest.RoleIds)
{
roles.Add((Role)roleId);
}
}
catch
{
return(HandleBadRequest("One or more of the supplied IDs is not a valid Sartre role ID."));
}
UserService.UpdateUserRoles(updateUserRoleRequest.Login, roles);
return(Ok());
}
public async Task <IActionResult> UpdateUserRole([FromBody] UpdateUserRoleRequest model)
{
bool isExist = !string.IsNullOrEmpty(model.Email);
IdentityResult Result;
string roleName = string.Empty;
if (ModelState.IsValid)
{
ApplicationUser applicationUser = await _userManager.FindByEmailAsync(model.Email);
var UserRole = await _userManager.GetRolesAsync(applicationUser);
if (UserRole != null)
{
Result = await _roleservice.RemoveFromRoleAsync(applicationUser, model.Old_ApplicationRoleName);
string RoleName = applicationUser.Name;
Result = await _roleservice.AddToRoleAsync(applicationUser, model.New_ApplicationRoleName);
if (Result.Succeeded)
{
return(Ok(" SuccessFully Updated UserRole In AspNetUserRole table...." + model.Email));
}
}
Result = await _roleservice.AddToRoleAsync(applicationUser, model.Old_ApplicationRoleName);
}
return(Ok($"Faild to Update Role {roleName} for user " + model.Email));
}
public async Task <IActionResult> RemoveRoles(
int id,
[FromBody] UpdateUserRoleRequest request)
{
if (await appsService.IsRequestValidOnThisLicense(
request.AppId,
request.License,
request.RequestorId))
{
var result = await usersService.RemoveUserRoles(
id,
request.RoleIds.ToList(),
request.License);
if (result.Success)
{
result.Message = ControllerMessages.StatusCode200(result.Message);
return(Ok(result));
}
else
{
result.Message = ControllerMessages.StatusCode404(result.Message);
return(NotFound(result));
}
}
else
{
return(BadRequest(ControllerMessages.InvalidLicenseRequestMessage));
}
}
public async Task <IActionResult> UpdateUserRole(int roleId, [FromBody] UpdateUserRoleRequest request)
{
var updateUserRoleCommand = new UpdateUserRoleCommand(roleId, request);
var result = await mediator.Send(updateUserRoleCommand);
return(StatusCode((int)result.Code, result.Value));
}
public async Task <UpdateUserRoleResponse> UpdateUserRole(UpdateUserRoleRequest o)
{
var result = new UpdateUserRoleResponse(o.RequestId);
result.Application = o.Application;
result.Updated = await Server.UpdateUserRole(o.Id, o.Name, o.Description);
return(result);
}
public async Task UpdateUserRole(UpdateUserRoleRequest request)
{
User user = await _unitOfWork.Users.All()
.FirstOrDefaultAsync(w => w.Email == request.Email);
if (user == null)
{
throw new NotFoundException();
}
user.Role = request.Role;
_unitOfWork.Users.Update(user);
await _unitOfWork.SaveAsync();
}
public async Task Setup()
{
context = await TestDatabase.GetDatabaseContext();
mockUsersService = new MockUsersService(context);
mockAppsService = new MockAppsService(context);
mockWebHostEnvironment = new Mock <IWebHostEnvironment>();
baseRequest = new BaseRequest();
updateUserRequest = new UpdateUserRequest()
{
UserName = "******",
FirstName = "FirstName",
LastName = "LastName",
NickName = "MyNickname",
Email = "*****@*****.**",
License = TestObjects.GetLicense(),
RequestorId = 1,
Paginator = new Paginator()
};
updatePasswordRequest = new UpdatePasswordRequest()
{
UserId = 1,
NewPassword = "******"
};
updateUserRoleRequest = new UpdateUserRoleRequest()
{
RoleIds = new List <int>()
{
3
},
License = TestObjects.GetLicense(),
RequestorId = 1,
Paginator = new Paginator()
};
sutSuccess = new UsersController(
mockUsersService.UsersServiceSuccessfulRequest.Object,
mockAppsService.AppsServiceSuccessfulRequest.Object,
mockWebHostEnvironment.Object);
sutFailure = new UsersController(
mockUsersService.UsersServiceFailedRequest.Object,
mockAppsService.AppsServiceSuccessfulRequest.Object,
mockWebHostEnvironment.Object);
}
public async Task <UserWithRoleDto> UpdateUserRoleAsync(UpdateUserRoleRequest request)
{
this.userValidationService.ValidateUpdateUserRole();
var role = await Context.Roles.FirstAsync(x => x.Id == request.RoleId);
var user = await GetByIdAsync(request.UserId);
user.Role = role;
user.RoleId = role.Id;
await SaveChanges();
return(Mapper.Map <User, UserWithRoleDto>(user));
}
public async Task <IActionResult> Put([FromRoute] Request meta, [FromBody] UpdateUserRoleRequest request)
{
IActionResult result = null;
var updated = await Server.UpdateUserRole(request.Id, request.Name, request.Description);
if (updated)
{
result = Factory.CreateSuccessResponse(updated);
}
else
{
result = Factory.CreateNoContentResponse();
}
return(result);
}
public IHttpActionResult UpdateUserRole(UpdateUserRoleRequest request)
{
Responce <bool> responce = new Responce <bool>();
try
{
responce = _accountService.UpdateUserRole(request);
return(Ok(responce));
}
catch (Exception ex)
{
responce.Success = false;
responce.Message = $"ERROR UpdateUserRole : {ex.InnerException}";
responce.ResponeContent = false;
return(Content(HttpStatusCode.BadRequest, responce));
}
}
public async Task <IActionResult> UpdateRole([FromRoute] int userId, [FromBody] UpdateUserRoleRequest request)
{
var user = await _userService.GetUserByIdAsync(userId);
if (user == null)
{
return(NotFound());
}
User updatedUser = _mapper.Map(request, user);
bool successfullyUpdated = await _userService.UpdateUserAsync(updatedUser);
if (!successfullyUpdated)
{
return(BadRequest(new ErrorResponse("There was a problem during role update")));
}
return(Ok());
}
public async Task <bool> UpdateUserRole(string UserId, string RoleId)
{
try
{
UpdateUserRoleRequest updateUserRoleRequest = new UpdateUserRoleRequest();
updateUserRoleRequest.Email = "";
updateUserRoleRequest.UserId = UserId;
updateUserRoleRequest.RoleId = RoleId;
string Json = JsonConvert.SerializeObject(updateUserRoleRequest);
var result = await restapiHelper.PosyAsync <Responce <bool> >(EndPoint.Account.UpdateUserRole, Json);
return(result.ResponeContent);
}
catch (Exception ex)
{
return(false);
}
}
public Responce <bool> UpdateUserRole(UpdateUserRoleRequest request)
{
Responce <bool> responce = new Responce <bool>();
responce.Success = true;
try
{
responce.Success = true;
using (SSCEntities db = new SSCEntities())
{
db.UpdateUserRole(request.RoleId, request.UserId);
responce.ResponeContent = true;
}
}
catch (Exception ex)
{
responce.Success = false;
responce.Message = $"ERROR UpdateUserRole : {ex.InnerException}";
responce.ResponeContent = false;
}
return(responce);
}
public async Task RemoveRolesFromUsers()
{
// Arrange
var userId = 1;
var user = context.Users
.Include(u => u.Roles)
.FirstOrDefault(u => u.Id == userId);
var updateUserRoleRequest = new UpdateUserRoleRequest();
updateUserRoleRequest.RoleIds.Add(3);
var license = TestObjects.GetLicense();
// Act
var result = await sut.RemoveUserRoles(
userId,
updateUserRoleRequest.RoleIds,
license);
// Assert
Assert.That(result.Success, Is.True);
Assert.That(result.Message, Is.EqualTo("Roles Removed"));
}
public async Task <HttpResponseMessage> UpdateUserRole([FromBody] UpdateUserRoleRequest request)
{
await _userService.UpdateUserRole(request);
return(new HttpResponseMessage(HttpStatusCode.OK));
}
public async Task <UserWithRoleDto> UpdateUserRole([FromBody] UpdateUserRoleRequest updateUserRoleRequest)
{
return(await this.userService.UpdateUserRoleAsync(updateUserRoleRequest));
}
public async Task <IActionResult> UpdateUserRole([FromRoute] string id, [FromBody] UpdateUserRoleRequest request)
{
await _userService.UpdateUserRoleAsync(id, request.Role);
return(Ok()); //
}
