public IActionResult Profile(EditProfileRequest request)
{
if (!ModelState.IsValid)
{
return(RedirectToAction(nameof(Profile)));
}
Core.Models.Result.Result editResult = _manageUserService.EditUser(GetUserId(), request);
Core.Models.Result.Result <ProfileViewModel> getResult = _manageDataService.GetProfile(GetUserId());
if (getResult.Failure)
{
ModelState.AddErrors(getResult.Errors);
return(View());
}
if (editResult.Failure)
{
getResult.Value.StatusAlert = StatusAlertViewExtension.Get(editResult);
ModelState.AddErrors(editResult.Errors);
return(View());
}
getResult.Value.StatusAlert = StatusAlertViewExtension.Get("Profile updated");
return(View(getResult.Value));
}
public Task <Result> Add(string code, string userId)
{
string remoteIp = _httpContextAccessor.HttpContext.Connection.RemoteIpAddress.ToString();
Core.Models.Result.Result result = Add(code, userId, remoteIp);
return(Task.FromResult(result.ToNewResult()));
}
private async Task <Result> ChangeRoleAsync(long groupUserId, string roleId, string userId)
{
_logger.LogInformation($"Changing GroupUser role. GroupUserId {groupUserId}, roleId {roleId}");
Result roleValidResult = await RoleIsValid(roleId);
if (roleValidResult.Failure)
{
return(Result.Fail(roleValidResult));
}
List <RoleListData> canAssigneGroupRoles = _groupUserStore.CanAssigneGroupRoles();
if (!canAssigneGroupRoles.Any(x => x.Id == roleId))
{
_logger.LogError($"User does not have permission to assign role. RoleId {roleId}");
return(Result.Fail(NO_PERMISSION));
}
Core.Models.Result.Result <GroupUserEntity> getGroupUserResult = _groupUserStore.Get(groupUserId);
if (getGroupUserResult.Failure)
{
return(getGroupUserResult.ToNewResult());
}
GroupUserEntity groupUser = getGroupUserResult.Value;
List <RoleListData> canManageGroupRoles = _groupUserStore.CanManageGroupRoles();
if (!canManageGroupRoles.Any(x => x.Id != groupUser.RoleId))
{
_logger.LogError($"User does not have permission to manage role. GroupUserId {groupUserId} RoleId {roleId}");
return(Result.Fail(NO_PERMISSION));
}
if (!_groupUserStore.CanChangeOwnRole())
{
if (groupUser.UserId == userId)
{
_logger.LogError($"User can not change his own role");
return(Result.Fail(USER_CAN_NOT_CHANGE_HIS_OWN_ROLE));
}
}
groupUser.UpdateRole(roleId);
bool updateResult = await _groupUserDAO.Update(groupUser);
if (!updateResult)
{
_logger.LogError($"Failed to change group user role. GroupUserId {groupUserId}, roleId {roleId}");
return(Result.Fail(FAILED_TO_CAHNGE_GROUP_USER_ROLE));
}
return(Result.Ok());
}
public IActionResult Remove([FromRoute] long groupUserId)
{
Core.Models.Result.Result result = _groupUserService.Remove(groupUserId);
if (result.Failure)
{
ModelState.AddErrors(result);
return(BadRequest(ModelState));
}
return(Ok(new EmptyResult()));
}
public IActionResult AddExisting([FromRoute] string groupId, [FromBody] AddExistingUserRequest addExistingUserRequest)
{
Core.Models.Result.Result result = _groupUserService.AddExisting(groupId, addExistingUserRequest);
if (result.Failure)
{
ModelState.AddErrors(result);
return(BadRequest(ModelState));
}
return(Ok(new EmptyResult()));
}
public async Task <IActionResult> Invite([FromRoute] string groupId, [FromBody] InviteToGroupRequest inviteToGroupRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
Core.Models.Result.Result result = await _inviteService.InviteToGroup(groupId, inviteToGroupRequest);
return(result.ToNewResult().ToApiResult());
}
public IActionResult ChangeRole([FromRoute] string groupId, [FromRoute] long groupUserId, [FromQuery] string roleId)
{
Core.Models.Result.Result result = _groupUserService.ChangeRole(groupUserId, roleId, User.GetUserId(_identityUIClaimOptions));
if (result.Failure)
{
ModelState.AddErrors(result);
return(BadRequest(ModelState));
}
return(Ok(new EmptyResult()));
}
public IActionResult Profile()
{
Core.Models.Result.Result <ProfileViewModel> result = _manageDataService.GetProfile(GetUserId());
if (result.Failure)
{
ModelState.AddErrors(result.Errors);
return(View("Profile"));
}
return(View("Profile", result.Value));
}
public IActionResult Get([FromRoute] string groupId, [FromQuery] DataTableRequest dataTableRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Core.Models.Result.Result <DataTableResult <GroupInviteTableModel> > result = _groupInviteDataService.Get(groupId, dataTableRequest);
return(result.ToNewResult().ToApiResult());
}
public async Task <IActionResult> ProfileImage([FromForm] UploadProfileImageRequest uploadImageRequest)
{
Core.Models.Result.Result result = await _profileImageService.UpdateProfileImage(GetUserId(), uploadImageRequest);
if (result.Failure)
{
ModelState.AddErrors(result);
return(BadRequest(ModelState));
}
return(Ok(new EmptyResult()));
}
public IActionResult Leave([FromRoute] string groupId)
{
//TODO: change for impersonation
Core.Models.Result.Result result = _groupUserService.Leave(User.GetUserId(_identityUIClaimOptions), groupId);
if (result.Failure)
{
ModelState.AddErrors(result);
return(BadRequest(ModelState));
}
return(Ok(new EmptyResult()));
}
public async Task <IActionResult> GetProfileImage()
{
Core.Models.Result.Result <FileData> result = await _profileImageService.GetProfileImage(GetUserId());
if (result.Failure)
{
return(NotFound());
}
//TODO: make this nicer
string contentType = "application/octet-stream";
if (result.Value.FileName.EndsWith(".svg"))
{
contentType = "image/svg+xml";
}
return(File(result.Value.File, contentType, result.Value.FileName));
}
public async Task <CommonUtils.Result.Result> EditUser(long groupUserId, EditUserRequest editUserRequest)
{
IBaseSpecification <GroupUserEntity, GroupUserEntity> specification = SpecificationBuilder
.Create <GroupUserEntity>()
.Where(x => x.Id == groupUserId)
.Include(x => x.User)
.Build();
CommonUtils.Result.Result <GroupUserEntity> getGroupUserResult = await _groupUserStore.SingleOrDefault(specification);
if (getGroupUserResult.Failure)
{
return(CommonUtils.Result.Result.Fail(getGroupUserResult));
}
//TODO: change so that Edit takes AppUserEntity as parameter
Core.Models.Result.Result updateResult = await EditUser(getGroupUserResult.Value.UserId, editUserRequest, "");
return(updateResult.ToNewResult());
}
public async Task <Core.Models.Result.Result> SetNewPassword(string userId, SetNewPasswordRequest setNewPasswordRequest, string adminId)
{
ValidationResult validationResult = _setNewPasswordValidator.Validate(setNewPasswordRequest);
if (!validationResult.IsValid)
{
_logger.LogError($"Invlid SetNewPasswordRequest. Admin {adminId}");
return(Core.Models.Result.Result.Fail(ResultUtils.ToResultError(validationResult.Errors)));
}
AppUserEntity appUser = await _userManager.FindByIdAsync(userId);
if (appUser == null)
{
_logger.LogError($"No User with id {userId}. Admin {adminId}");
return(Core.Models.Result.Result.Fail("no_user", "No User"));
}
_logger.LogInformation($"Seting new password for with id {userId}. Admin id {adminId}");
string passwordResetToken = await _userManager.GeneratePasswordResetTokenAsync(appUser);
IdentityResult changePasswordResult = await _userManager.ResetPasswordAsync(appUser, passwordResetToken, setNewPasswordRequest.Password);
if (!changePasswordResult.Succeeded)
{
_logger.LogError($"Faild to reset password. UserId {appUser.Id}, admin {adminId}");
return(Core.Models.Result.Result.Fail(changePasswordResult.Errors));
}
Core.Models.Result.Result logoutUserResult = await _sessionService.LogoutUser(new Auth.Session.Models.LogoutUserSessionsRequest(appUser.Id), adminId);
if (logoutUserResult.Failure)
{
return(logoutUserResult);
}
_logger.LogInformation($"Added new password to user with id {userId}. Admin id {adminId}");
return(Core.Models.Result.Result.Ok());
}
public async Task <CommonUtils.Result.Result> SendEmilVerificationMail(long groupUserId)
{
IBaseSpecification <GroupUserEntity, GroupUserEntity> specification = SpecificationBuilder
.Create <GroupUserEntity>()
.Where(x => x.Id == groupUserId)
.Include(x => x.User)
.Build();
CommonUtils.Result.Result <GroupUserEntity> getGroupUserResult = await _groupUserStore.SingleOrDefault(specification);
if (getGroupUserResult.Failure)
{
return(CommonUtils.Result.Result.Fail(getGroupUserResult));
}
SendEmailVerificationMailRequest sendEmailVerificationMailRequest = new SendEmailVerificationMailRequest(
userId: getGroupUserResult.Value.UserId);
Core.Models.Result.Result result = await SendEmilVerificationMail(sendEmailVerificationMailRequest, "");
return(result.ToNewResult());
}
public Task <IActionResult> Update([FromRoute] string groupId, [FromRoute] long groupAttributeId, [FromBody] EditGroupAttributeRequest request)
{
Core.Models.Result.Result result = _groupAttributeService.Edit(groupId, groupAttributeId, request);
return(Task.FromResult(result.ToNewResult().ToApiResult()));
}
public async Task <IActionResult> Add([FromRoute] string groupId, [FromBody] InviteToGroupRequest request)
{
Core.Models.Result.Result result = await _inviteService.InviteToGroup(groupId, request);
return(result.ToNewResult().ToApiResult());
}
public Task <IActionResult> Add([FromRoute] string groupId, [FromBody] AddGroupAttributeRequest request)
{
Core.Models.Result.Result result = _groupAttributeService.Add(groupId, request);
return(Task.FromResult(result.ToNewResult().ToApiResult()));
}
public async Task <Core.Models.Result.Result> EditUser(string id, EditUserRequest editUserRequest, string adminId)
{
ValidationResult validationResult = _editUserValidator.Validate(editUserRequest);
if (!validationResult.IsValid)
{
_logger.LogError($"Invalid EditUserRequest. Admin {adminId}");
return(Core.Models.Result.Result.Fail(ResultUtils.ToResultError(validationResult.Errors)));
}
BaseSpecification <AppUserEntity> userSpecification = new BaseSpecification <AppUserEntity>();
userSpecification.AddFilter(x => x.Id == id);
AppUserEntity appUser = _userRepository.SingleOrDefault(userSpecification);
if (appUser == null)
{
_logger.LogWarning($"No User. UserId {id}. Admin {adminId}");
return(Core.Models.Result.Result.Fail("no_user", "No User"));
}
bool updateSecurityStamp = false;
appUser.FirstName = editUserRequest.FirstName;
appUser.LastName = editUserRequest.LastName;
#if NET_CORE2
string normalizeEmail = _userManager.NormalizeKey(editUserRequest.Email);
#endif
#if NET_CORE3
string normalizeEmail = _userManager.NormalizeEmail(editUserRequest.Email);
#endif
if (normalizeEmail != appUser.NormalizedEmail)
{
appUser.Email = editUserRequest.Email;
appUser.NormalizedEmail = normalizeEmail;
appUser.EmailConfirmed = false;
}
else
{
appUser.EmailConfirmed = editUserRequest.EmailConfirmed;
}
if (appUser.PhoneNumber != editUserRequest.PhoneNumber)
{
appUser.PhoneNumber = editUserRequest.PhoneNumber;
appUser.PhoneNumberConfirmed = false;
}
else
{
appUser.PhoneNumberConfirmed = editUserRequest.PhoneNumberConfirmed;
}
if (appUser.TwoFactorEnabled)
{
appUser.TwoFactorEnabled = editUserRequest.TwoFactorEnabled;
}
if (appUser.Enabled != editUserRequest.Enabled)
{
appUser.Enabled = editUserRequest.Enabled;
updateSecurityStamp = true;
}
bool result = _userRepository.Update(appUser);
if (!result)
{
_logger.LogError($"Failed to save edited user data. Admin {adminId}");
return(Core.Models.Result.Result.Fail("error", "error"));
}
if (updateSecurityStamp)
{
Core.Models.Result.Result logoutUserResult = await _sessionService.LogoutUser(new Auth.Session.Models.LogoutUserSessionsRequest(appUser.Id), adminId);
if (logoutUserResult.Failure)
{
return(logoutUserResult);
}
}
return(Core.Models.Result.Result.Ok());
}
public Task <IActionResult> Delete([FromRoute] string groupId, [FromRoute] long groupAttributeId)
{
Core.Models.Result.Result result = _groupAttributeService.Remove(groupId, groupAttributeId);
return(Task.FromResult(result.ToNewResult().ToApiResult()));
}
public async Task <Result> AddInvite(string email, string roleId = null, string groupId = null, string groupRoleId = null)
{
Result inviteAlreadyExistsResult = await InviteAlreadyExits(email);
if (inviteAlreadyExistsResult.Failure)
{
return(inviteAlreadyExistsResult);
}
//TODO: change method or response to make more sense
Result userAlreadyExistsResult = await UserAlreadyExist(email);
if (userAlreadyExistsResult.Failure)
{
return(userAlreadyExistsResult);
}
if (!string.IsNullOrEmpty(roleId))
{
Result roleValidResult = await GlobalRoleExists(roleId);
if (roleValidResult.Failure)
{
return(roleValidResult);
}
}
if (!string.IsNullOrEmpty(groupId))
{
Result isGroupValid = await IsGroupInviteValid(groupId, groupRoleId);
if (isGroupValid.Failure)
{
return(isGroupValid);
}
}
Result beforeAddResult = await _addInviteFilter.BeforeAdd(email, roleId, groupId, groupRoleId);
if (beforeAddResult.Failure)
{
return(beforeAddResult);
}
InviteEntity invite = new InviteEntity(
email: email,
token: StringUtils.GenerateToken(),
status: Data.Enums.Entity.InviteStatuses.Pending,
roleId: roleId,
groupId: groupId,
groupRoleId: groupRoleId,
expiresAt: DateTimeOffset.UtcNow.Add(_identityManagementEndpoints.InviteValidForTimeSpan));
bool addInvite = await _inviteDAO.Add(invite);
if (!addInvite)
{
_logger.LogError($"Failed to add invite");
return(Result.Fail(FAILED_TO_ADD_INVITE));
}
Result afterAddedResult = await _addInviteFilter.AfterAdded(invite);
if (afterAddedResult.Failure)
{
return(afterAddedResult);
}
_logger.LogInformation($"Invite was added, sending email");
string callbackUrl = QueryHelpers.AddQueryString($"{_identityManagementOptions.BasePath}{_identityManagementEndpoints.AcceptInvite}", "code", invite.Token);
callbackUrl = HtmlEncoder.Default.Encode(callbackUrl);
Core.Models.Result.Result sendMailResult = await _mailService.SendInvite(invite.Email, callbackUrl);
if (sendMailResult.Failure)
{
return(sendMailResult.ToNewResult());
}
return(Result.Ok());
}
