public async Task <IActionResult> RegisterGroup(RegisterGroupModel registerGroupModel)
{
if (!_identityUIEndpoints.GroupRegistrationEnabled)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
RegisterGroupViewModel registerViewModel = _accountDataService.GetRegisterGroupViewModel();
return(View(registerViewModel));
}
CommonUtils.Result.Result result = await _groupRegistrationService.Add(registerGroupModel);
if (result.Failure)
{
RegisterGroupViewModel registerViewModel = _accountDataService.GetRegisterGroupViewModel();
CommonUtils.Result.ResultExtensions.AddResultErrors(ModelState, result);
return(View(registerViewModel));
}
return(RedirectToAction(nameof(RegisterSuccess)));
}
public async Task <Core.Models.Result.Result> Register(RegisterRequest registerRequest)
{
if (!_identityUIEndpoints.RegisterEnabled)
{
_logger.LogError($"User tried to register, but registrations are disabled");
return(Core.Models.Result.Result.Fail(REGISTRATION_IS_NOT_ENABLED, REGISTRATION_IS_NOT_ENABLED));
}
ValidationResult validationResult = _registerValidator.Validate(registerRequest);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid {typeof(RegisterRequest).Name}");
return(Core.Models.Result.Result.Fail(validationResult.Errors));
}
CommonUtils.Result.Result <AppUserEntity> addResult = await AddUser(registerRequest);
if (addResult.Failure)
{
return(Core.Models.Result.Result.Fail(addResult.ResultMessages.Select(x => new Core.Models.Result.Result.ResultError(x.Code, x.Code, null)).ToList()));
}
return(Core.Models.Result.Result.Ok());
}
public async Task <Result <SignInResult> > Callback(string remoteError)
{
if (!string.IsNullOrEmpty(remoteError))
{
_logger.LogError($"External login provider returned error. Error {remoteError}");
return(Result.Fail <SignInResult>("external_login_provider_error", remoteError));
}
ExternalLoginInfo externalLoginInfo = await _signInManager.GetExternalLoginInfoAsync();
if (externalLoginInfo == null)
{
_logger.LogError($"Error getting external login info");
return(Result.Fail <SignInResult>("failed_to_get_external_longin_info", "Failed to get external login info"));
}
AppUserEntity appUser = await _userManager.FindByLoginAsync(externalLoginInfo.LoginProvider, externalLoginInfo.ProviderKey);
if (appUser == null)
{
_logger.LogInformation($"Users email does not exist");
return(Result.Ok(SignInResult.Failed));
}
string sessionCode = _identityUIUserInfoService.GetSessionCode();
if (sessionCode != null)
{
_sessionService.Logout(sessionCode, appUser.Id, SessionEndTypes.Expired);
}
CommonUtils.Result.Result beforeLoginFilterResult = await _canLoginService.BeforeAdd(appUser);
if (beforeLoginFilterResult.Failure)
{
_logger.LogInformation($"User is not allowed to login. User {appUser.Id}");
beforeLoginFilterResult.ToOldResult();
}
SignInResult signInResult = await _signInManager.ExternalLoginSignInAsync(
loginProvider : externalLoginInfo.LoginProvider,
providerKey : externalLoginInfo.ProviderKey,
isPersistent : false,
bypassTwoFactor : _identityUIEndpoints.BypassTwoFactorOnExternalLogin);
CommonUtils.Result.Result afterLoginFilterResult = await _canLoginService.AfterAdded(appUser);
if (afterLoginFilterResult.Failure)
{
await _signInManager.SignOutAsync();
_sessionService.Logout(appUser.SessionCode, appUser.Id, SessionEndTypes.AffterLoginFilterFailure);
_logger.LogInformation($"User is not allowed to login. User {appUser.Id}");
afterLoginFilterResult.ToOldResult();
}
return(Result.Ok(signInResult));
}
public async Task <IActionResult> Remove([FromRoute] string groupId, [FromRoute] string inviteId)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
CommonUtils.Result.Result result = await _inviteService.Remove(groupId, inviteId);
return(result.ToApiResult());
}
/// <summary>
/// Used to login user after password change, 2fa change
/// </summary>
/// <param name="userId"></param>
/// <param name="sessionCode"></param>
/// <param name="ip"></param>
/// <returns></returns>
public async Task <Result> Login(string userId, string sessionCode, string ip)
{
await _signInManager.SignOutAsync();
AppUserEntity appUser = await _userManager.FindByIdAsync(userId);
if (appUser == null)
{
_logger.LogInformation($"No user with username {userId}");
return(Result.Fail("error", "Error"));
}
if (sessionCode != null)
{
_sessionService.Logout(sessionCode, appUser.Id, SessionEndTypes.SecurityCodeChange);
}
CommonUtils.Result.Result canLoginResult = await _canLoginService.BeforeAdd(appUser);
if (canLoginResult.Failure)
{
_logger.LogInformation($"User is not allowd to login. User {appUser.Id}");
return(Result.Fail("error", "Error"));
}
appUser.SessionCode = Guid.NewGuid().ToString();
Result addSessionResult = _sessionService.Add(appUser.SessionCode, appUser.Id, ip);
if (addSessionResult.Failure)
{
return(Result.Fail("error", "error"));
}
await _signInManager.SignInAsync(appUser, false);
CommonUtils.Result.Result afterLoginFilterResult = await _canLoginService.AfterAdded(appUser);
if (afterLoginFilterResult.Failure)
{
await _signInManager.SignOutAsync();
_sessionService.Logout(appUser.SessionCode, appUser.Id, SessionEndTypes.AffterLoginFilterFailure);
return(Result.Fail("error", "error"));
}
_logger.LogInformation($"User loged in. UserId {appUser.Id}");
return(Result.Ok());
}
public async Task <Core.Models.Result.Result> ExternalLoginRequest(ExternalLoginRegisterRequest externalLoginRegisterRequest)
{
if (!_identityUIEndpoints.RegisterEnabled)
{
_logger.LogError($"User tried to register, but registrations are disabled");
return(Core.Models.Result.Result.Fail("registration_is_not_enabled", "Registration disabled"));
}
ValidationResult externalLoginValidationResult = _externalLoginRequsterRequestValidator.Validate(externalLoginRegisterRequest);
if (!externalLoginValidationResult.IsValid)
{
_logger.LogWarning($"Invalid {typeof(ExternalLoginRegisterRequest)} model");
return(Core.Models.Result.Result.Fail(externalLoginValidationResult.Errors));
}
ExternalLoginInfo externalLoginInfo = await _signInManager.GetExternalLoginInfoAsync();
if (externalLoginInfo == null)
{
_logger.LogError($"Failed to get external login info.");
return(Core.Models.Result.Result.Fail("failed_to_get_external_login_info", "Failed to get external login info"));
}
//TODO: do not confirm. don't require confirmed emails for external login users
CommonUtils.Result.Result <AppUserEntity> addUserResult = await AddUser(
externalLoginRegisterRequest,
setPassword : false,
sendConfirmationMail : false,
emailConfirmed : true);
if (addUserResult.Failure)
{
return(addUserResult.ToOldResult());
}
AppUserEntity appUser = addUserResult.Value;
IdentityResult addLoginResult = await _userManager.AddLoginAsync(appUser, externalLoginInfo);
if (!addLoginResult.Succeeded)
{
_logger.LogError($"Failed to add login to user. UserId {appUser.Id}");
}
return(Core.Models.Result.Result.Ok());
}
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 <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 async Task <IActionResult> Delete([FromRoute] string userId)
{
CommonUtils.Result.Result result = await _manageUserService.RemoveUser(userId);
return(CommonUtils.Result.ActionResultExtensions.ToApiResult(result));
}
public async Task <SignInResult> Login(string ip, string sessionCode, LoginRequest login)
{
ValidationResult validationResult = _loginValidator.Validate(login);
if (!validationResult.IsValid)
{
_logger.LogError($"Invalid LoginRequest. UserName {login?.UserName}");
return(SignInResult.Failed);
}
await _signInManager.SignOutAsync();
AppUserEntity appUser = await _userManager.FindByNameAsync(login.UserName);
if (appUser == null)
{
_logger.LogInformation($"No user with username {login.UserName}");
return(SignInResult.Failed);
}
if (sessionCode != null)
{
_sessionService.Logout(sessionCode, appUser.Id, SessionEndTypes.Expired);
}
CommonUtils.Result.Result beforeLoginfilterResult = await _canLoginService.BeforeAdd(appUser);
if (beforeLoginfilterResult.Failure)
{
_logger.LogInformation($"User is not allowed to login. User {appUser.Id}");
return(SignInResult.Failed);
}
appUser.SessionCode = Guid.NewGuid().ToString();
Result addSessionResult = _sessionService.Add(appUser.SessionCode, appUser.Id, ip);
if (addSessionResult.Failure)
{
return(SignInResult.Failed);
}
SignInResult result = await _signInManager.PasswordSignInAsync(appUser, login.Password, login.RememberMe, lockoutOnFailure : true);
if (!result.Succeeded)
{
if (result.RequiresTwoFactor)
{
_logger.LogInformation($"Login Requires TwoFactor. User {appUser.Id}");
_sessionService.Logout(appUser.SessionCode, appUser.Id, SessionEndTypes.TwoFactorLogin);
}
if (!result.IsLockedOut)
{
_logger.LogInformation($"Failed to log in user. User {appUser.Id}");
_sessionService.Logout(appUser.SessionCode, appUser.Id, SessionEndTypes.InvalidLogin);
}
return(result);
}
CommonUtils.Result.Result afterLoginFilterResult = await _canLoginService.AfterAdded(appUser);
if (afterLoginFilterResult.Failure)
{
await _signInManager.SignOutAsync();
_sessionService.Logout(appUser.SessionCode, appUser.Id, SessionEndTypes.AffterLoginFilterFailure);
return(SignInResult.Failed);
}
_logger.LogInformation($"User id logged in. UserId {appUser.Id}");
return(result);
}
public async Task <SignInResult> LoginWith2fa(string ip, LoginWith2faRequest loginWith2FaRequest)
{
ValidationResult validationResult = _lginwith2faValidator.Validate(loginWith2FaRequest);
if (!validationResult.IsValid)
{
_logger.LogError($"Invalid LoginWith2faRequest");
return(SignInResult.Failed);
}
string code = loginWith2FaRequest.Code.Replace(" ", string.Empty).Replace("-", string.Empty);
AppUserEntity appUser = await _signInManager.GetTwoFactorAuthenticationUserAsync();
if (appUser == null)
{
_logger.LogError($"No user for Twofactor login");
return(SignInResult.Failed);
}
CommonUtils.Result.Result canLoginResult = await _canLoginService.BeforeAdd(appUser);
if (canLoginResult.Failure)
{
_logger.LogInformation($"User is not allowd to login. User {appUser.Id}");
return(SignInResult.Failed);
}
if (!appUser.TwoFactorEnabled || appUser.TwoFactor == TwoFactorAuthenticationType.None)
{
_logger.LogError($"Use does not have 2fa enabled. User {appUser.Id}");
return(SignInResult.Failed);
}
appUser.SessionCode = Guid.NewGuid().ToString();
Result addSessionResult = _sessionService.Add(appUser.SessionCode, appUser.Id, ip);
if (addSessionResult.Failure)
{
return(SignInResult.Failed);
}
SignInResult signInResult = await _signInManager.TwoFactorSignInAsync(appUser.TwoFactor.ToProvider(), code,
loginWith2FaRequest.RememberMe, loginWith2FaRequest.RememberMachine);
if (!signInResult.Succeeded)
{
_logger.LogError($"Faild to log in user with TwoFactorAuthenticator");
_sessionService.Logout(appUser.SessionCode, appUser.Id, SessionEndTypes.InvlidTwoFactorLogin);
}
CommonUtils.Result.Result afterLoginFilterResult = await _canLoginService.AfterAdded(appUser);
if (afterLoginFilterResult.Failure)
{
await _signInManager.SignOutAsync();
_sessionService.Logout(appUser.SessionCode, appUser.Id, SessionEndTypes.AffterLoginFilterFailure);
return(SignInResult.Failed);
}
_logger.LogInformation($"User logged in with 2fa. UserId {appUser.Id}");
return(signInResult);
}
