public virtual JsonResult Login()
{
//if (!VerifyToken())
//{
// return ResultUtils.Fail(app_senre, msg_box);
//}
string username = RequestHelper.GetFormString("username");
string password = RequestHelper.GetFormString("password");
if (Utils.StrIsNullOrEmpty(username) || Utils.StrIsNullOrEmpty(password))
{
return(ResultUtils.Error("账号或密码不能为空"));
}
if (Utils.IsValidMobile(username)) //判断是否是手机号码
{
userid = NH.Service.Api.AuthService.GetInstance().LoginUp(username, password, 1); //手机号码
}
else
{
userid = NH.Service.Api.AuthService.GetInstance().LoginUp(username, password, 0); //用户名
}
if (userid > 0)
{
Entity.Model.Token token = base.GetToken();
return(ResultUtils.Success(new
{
userId = token.UserID,
timeStamp = token.Timestamp,
platform = token.Platform,
token = token.TokenStr
}));
}
return(ResultUtils.Fail("登录失败"));
}
public async Task <Result> Register(RegisterRequest registerRequest)
{
ValidationResult validationResult = _registerValidator.Validate(registerRequest);
if (!validationResult.IsValid)
{
_logger.LogError($"Invalid RegisterRequest");
return(Result.Fail(ResultUtils.ToResultError(validationResult.Errors)));
}
AppUserEntity appUser = new AppUserEntity(
userName: registerRequest.Email,
email: registerRequest.Email,
firstName: registerRequest.FirstName,
lastName: registerRequest.LastName,
emailConfirmed: false,
enabled: true);
IdentityResult identityResult = await _userManager.CreateAsync(appUser, registerRequest.Password);
if (!identityResult.Succeeded)
{
_logger.LogError($"Failed to register user");
return(Result.Fail(ResultUtils.ToResultError(identityResult.Errors)));
}
string code = await _userManager.GenerateEmailConfirmationTokenAsync(appUser);
await _emailService.SendVerificationMail(appUser, code);
return(Result.Ok());
}
public Result EditRole(string id, EditRoleRequest editRoleRequest, string adminId)
{
ValidationResult validationResult = _editRoleValidator.Validate(editRoleRequest);
if (!validationResult.IsValid)
{
_logger.LogError($"Invalid EditRoleRequest. admin {adminId}");
return(Result.Fail(ResultUtils.ToResultError(validationResult.Errors)));
}
BaseSpecification <RoleEntity> roleSpecification = new BaseSpecification <RoleEntity>();
roleSpecification.AddFilter(x => x.Id == id);
RoleEntity role = _roleRepository.SingleOrDefault(roleSpecification);
if (role == null)
{
_logger.LogError($"No role. Admin id {adminId}");
return(Result.Fail("no_role", "No Role"));
}
role.Description = editRoleRequest.Description;
bool result = _roleRepository.Update(role);
if (!result)
{
_logger.LogError($"Failed to update role with id {id}. Admin {adminId}");
return(Result.Fail("error", "Error"));
}
return(Result.Ok());
}
public async Task <Result <string> > AddRole(NewRoleRequest newRoleRequest, string adminId)
{
ValidationResult validationResult = _newRoleValidator.Validate(newRoleRequest);
if (!validationResult.IsValid)
{
_logger.LogError($"Invalid NewRoleRequest. Admin {adminId}");
return(Result.Fail <string>(ResultUtils.ToResultError(validationResult.Errors)));
}
RoleEntity role = new RoleEntity(
name: newRoleRequest.Name,
description: newRoleRequest.Description,
type: newRoleRequest.Type.Value);
IdentityResult result = await _roleManager.CreateAsync(role);
if (!result.Succeeded)
{
_logger.LogError($"Failed to add new role. Admin with id {adminId}");
return(Result.Fail <string>(ResultUtils.ToResultError(result.Errors)));
}
role = await _roleManager.FindByNameAsync(newRoleRequest.Name);
if (role == null)
{
_logger.LogError($"Failed to find new role with name {newRoleRequest.Name}. Admin with id {adminId}");
return(Result.Fail <string>("no_role", "No role"));
}
return(Result.Ok(role.Id));
}
/// <summary>
/// 提交验证码
/// </summary>
/// <param name="mod"></param>
/// <returns></returns>
public virtual JsonResult SubmitCode(SubmitCodeReq mod)
{
if (string.IsNullOrEmpty(mod.phone))
{
return(ResultUtils.Fail("手机号码或用户名不能为空"));
}
if (string.IsNullOrEmpty(mod.code))
{
return(ResultUtils.Fail("验证码不能为空"));
}
int ret = NH.Service.VerifyService.Instance().SubmitCode(mod);
if (ret == 1)
{
return(ResultUtils.Success("验证成功"));
}
else if (ret == -1)
{
return(ResultUtils.Fail("用户不存在"));
}
else if (ret == -2)
{
return(ResultUtils.Fail("手机号码未注册"));
}
return(ResultUtils.Fail("验证码过期"));
}
/// <summary>
/// Used only when admin is adding new user
/// </summary>
/// <param name="newUserRequest"></param>
/// <param name="adminId"></param>
/// <returns></returns>
public async Task <Core.Models.Result.Result <string> > AddUser(NewUserRequest newUserRequest, string adminId)
{
ValidationResult validationResult = _newUserValidator.Validate(newUserRequest);
if (!validationResult.IsValid)
{
_logger.LogError($"Invalid NewUserRequest. Admin {adminId}");
return(Core.Models.Result.Result.Fail <string>(ResultUtils.ToResultError(validationResult.Errors)));
}
BaseRegisterRequest baseRegisterRequest = new BaseRegisterRequest
{
Username = newUserRequest.UserName,
Email = newUserRequest.Email,
FirstName = newUserRequest.FirstName,
LastName = newUserRequest.LastName,
};
Result <AppUserEntity> addUserResult = await AddUser(baseRegisterRequest, false, false, false);
if (addUserResult.Failure)
{
return(Core.Models.Result.Result.Fail <string>(addUserResult.ResultMessages.Select(x => new Core.Models.Result.Result.ResultError(x.Code, x.Code)).ToList()));
}
return(Core.Models.Result.Result.Ok(addUserResult.Value.Id));
}
void btnClick(Object sender, EventArgs e)
{
Button btn = (Button)sender;
switch (btn.Text)
{
case "1":
case "2":
case "3":
case "4":
case "5":
case "6":
case "7":
case "8":
case "9":
case "0":
case ".":
case "+":
case "-":
case "*":
case "/":
case "(":
case ")":
if (this.clear)
{
testResult.Text = btn.Text;
clear = false;
}
else
{
testResult.Text += btn.Text;
}
break;
case "CE":
{
this.clear = true;
testResult.Text = "0";
break;
}
case "=":
{
String temp = testResult.Text + "=";
ResultUtils ru = new ResultUtils(testResult.Text);
String tmp = ru.getResult();
if (tmp.Equals("error"))
{
testResult.Text = "表达式错误，请正确输入,按CE继续";
}
else
{
testResult.Text = temp + ru.getResult();
}
break;
}
}
}
public Result <DataTableResult <UserTableModel> > GetGroupUsers(string roleId, DataTableRequest request)
{
ValidationResult validationResult = _dataTableValidator.Validate(request);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid {nameof(DataTableRequest)} model");
return(Result.Fail <DataTableResult <UserTableModel> >(ResultUtils.ToResultError(validationResult.Errors.ToList())));
}
BaseSpecification <RoleEntity> roleSpecification = new BaseSpecification <RoleEntity>();
roleSpecification.AddFilter(x => x.Id == roleId);
roleSpecification.AddFilter(x => x.Type == RoleTypes.Group);
bool existResult = _roleRepository.Exist(roleSpecification);
if (!existResult)
{
_logger.LogWarning($"GroupRole with id {roleId} does not exist");
return(Result.Fail <DataTableResult <UserTableModel> >("no_role", "No Role"));
}
PaginationSpecification <GroupUserEntity, UserTableModel> baseSpecification = new PaginationSpecification <GroupUserEntity, UserTableModel>();
baseSpecification.AddFilter(x => x.RoleId == roleId);
baseSpecification.AddSelect(x => new UserTableModel(
x.User.Id,
x.User.UserName,
x.Group.Name));
if (!string.IsNullOrEmpty(request.Search))
{
string search = request.Search.ToUpper();
baseSpecification.AddFilter(x =>
x.User.Id.ToUpper().Contains(search) ||
x.User.Email.ToUpper().Contains(search) ||
x.User.UserName.ToUpper().Contains(search) ||
x.User.FirstName.ToUpper().Contains(search) ||
x.User.LastName.ToUpper().Contains(search));
}
baseSpecification.AppalyPaging(request.Start, request.Length);
baseSpecification.AddInclude(x => x.User);
PaginatedData <UserTableModel> paginationData = _groupUserRepository.GetPaginated(baseSpecification);
DataTableResult <UserTableModel> result = new DataTableResult <UserTableModel>(
draw: request.Draw,
recordsTotal: paginationData.Count,
recordsFilterd: paginationData.Count,
error: null,
data: paginationData.Data);
return(Result.Ok(result));
}
public Task <Result <IEnumerable <string> > > VerifyEmailTwoFactorCode(string userId, AddTwoFactorEmailAuthenticationRequest request)
{
ValidationResult validationResult = _addEmailTwoFactorValidator.Validate(request);
if (!validationResult.IsValid)
{
_logger.LogError($"Verification failed.");
return(Task.FromResult(Result.Fail <IEnumerable <string> >(ResultUtils.ToResultError(validationResult.Errors))));
}
return(AddTwoFactorAuthentication(userId, TwoFactorAuthenticationType.Email, request.Token));
}
/// <summary>
/// 获取一级类目
/// </summary>
/// <returns></returns>
public virtual JsonResult GetRecommendTag()
{
var list = NH.Service.CategoryService.Instance().GetParentCategoryList();
if (list != null)
{
return(ResultUtils.Success(new
{
list = list
}));
}
return(ResultUtils.Fail("获取类目列表失败"));
}
public Task <Result <IEnumerable <string> > > VerifyTwoFactorCode(string userId, AddTwoFactorAuthenticatorRequest request)
{
ValidationResult validationResult = _addTwoFactorValidator.Validate(request);
if (!validationResult.IsValid)
{
_logger.LogError($"Invalid TwoFactor Verification code. ");
return(Task.FromResult(Result.Fail <IEnumerable <string> >(ResultUtils.ToResultError(validationResult.Errors))));
}
string vereficationCode = request.VereficationCode.Replace(" ", string.Empty).Replace("-", string.Empty);
return(AddTwoFactorAuthentication(userId, TwoFactorAuthenticationType.Authenticator, vereficationCode));
}
/// <summary>
/// 重置密码
/// </summary>
/// <param name="req"></param>
/// <returns></returns>
public virtual JsonResult ResetPassword(ResetPasswordReq req)
{
if (string.IsNullOrEmpty(req.phone))
{
return(ResultUtils.Fail("手机号码或用户名不能为空"));
}
if (string.IsNullOrEmpty(req.code))
{
return(ResultUtils.Fail("验证码不能为空"));
}
if (string.IsNullOrEmpty(req.password))
{
return(ResultUtils.Fail("密码不能为空"));
}
SubmitCodeReq mod = new SubmitCodeReq()
{
phone = req.phone,
code = req.code
};
int ret = NH.Service.VerifyService.Instance().SubmitCode(mod);
if (ret == 0)
{
return(ResultUtils.Success("验证码过期"));
}
else if (ret == -1)
{
return(ResultUtils.Fail("用户不存在"));
}
else if (ret == -2)
{
return(ResultUtils.Fail("手机号码未注册"));
}
userid = NH.Service.Api.AuthService.GetInstance().ResetPassword(req);
if (userid > 0)
{
Entity.Model.Token token = base.GetToken();
return(ResultUtils.Success(new
{
userId = token.UserID,
timeStamp = token.Timestamp,
platform = token.Platform,
token = token.TokenStr
}));
}
return(ResultUtils.Fail("重置密码失败"));
}
public virtual ActionResult Register(RegisterReq mod)
{
lock (lockhelper)
{
if (string.IsNullOrEmpty(mod.phone))
{
return(ResultUtils.Error("手机号码不能为空"));
}
else if (!Utils.IsValidMobile(mod.phone))
{
return(ResultUtils.Error("手机号码格式有误"));
}
if (string.IsNullOrEmpty(mod.code))
{
return(ResultUtils.Error("验证码不能为空"));
}
else if (mod.code.Trim().Length != 6)
{
return(ResultUtils.Error("验证码有误"));
}
else
{
}
if (string.IsNullOrEmpty(mod.username))
{
mod.username = mod.phone;
}
if (string.IsNullOrEmpty(mod.password))
{
return(ResultUtils.Error("密码不能为空"));
}
userid = NH.Service.Api.AuthService.GetInstance().Regieste(mod);
if (userid > 0)
{
Entity.Model.Token token = base.GetToken();
return(ResultUtils.Success(new
{
userId = token.UserID,
timeStamp = token.Timestamp,
platform = token.Platform,
token = token.TokenStr
}));
}
return(ResultUtils.Fail("注册失败"));
}
}
/// <summary>
/// 请求发送验证码
/// </summary>
/// <param name="mod"></param>
/// <returns></returns>
public virtual JsonResult SendCode(SendCodeReq mod)
{
if (string.IsNullOrEmpty(mod.phone))
{
return(ResultUtils.Fail("手机号码不能为空"));
}
string randownum = DataCheck.RandomNumber(4); //获取4位随机码
bool b = VerifyService.Instance().CreateVerifyCode(mod.phone, randownum);
if (b)
{
return(ResultUtils.Success(new
{
verifycode = randownum
}));
}
return(ResultUtils.Fail("请重新获取"));
}
public async Task <Result> VerifyTwoFactorCode(string userId, string sessionCode, string ip, AddTwoFactorAuthenticatorRequest request)
{
ValidationResult validationResult = _addTwoFactorValidator.Validate(request);
if (!validationResult.IsValid)
{
_logger.LogError($"Invalid TwoFactor Verificatin code. ");
return(Result.Fail(ResultUtils.ToResultError(validationResult.Errors)));
}
AppUserEntity appUser = await _userManager.FindByIdAsync(userId);
if (appUser == null)
{
_logger.LogError($"No user. UserId {userId}");
return(Result.Fail("no_user", "No User"));
}
string vereficationCode = request.VereficationCode.Replace(" ", string.Empty).Replace("-", string.Empty);
bool isCodeValid = await _userManager.VerifyTwoFactorTokenAsync(appUser, _userManager.Options.Tokens.AuthenticatorTokenProvider, vereficationCode);
if (!isCodeValid)
{
_logger.LogError($"Invlid TwoFactor Verification code. User {userId}");
return(Result.Fail("invlid_code", "Invalid Code", "VereficationCode"));
}
await _userManager.SetTwoFactorEnabledAsync(appUser, true);
_logger.LogInformation($"2fa enabled. User {appUser.Id}");
//TO DO: generate recovery codes
Result loginResult = await _loginService.Login(userId, sessionCode, ip);
if (loginResult.Failure)
{
_logger.LogError($"Faild to login user after 2fa reset. UserId {userId}");
}
return(Result.Ok());
}
public Result <DataTableResult <UserListViewModel> > GetAll(DataTableRequest request)
{
ValidationResult validationResult = _dataTableValidator.Validate(request);
if (!validationResult.IsValid)
{
return(Result.Fail <DataTableResult <UserListViewModel> >(ResultUtils.ToResultError(validationResult.Errors.ToList())));
}
PaginationSpecification <AppUserEntity, UserListViewModel> baseSpecification = new PaginationSpecification <AppUserEntity, UserListViewModel>();
if (!string.IsNullOrEmpty(request.Search))
{
string search = request.Search.ToUpper();
baseSpecification.AddFilter(x =>
x.Id.ToUpper().Contains(search) ||
x.Email.ToUpper().Contains(search) ||
x.UserName.ToUpper().Contains(search) ||
x.FirstName.ToUpper().Contains(search) ||
x.LastName.ToUpper().Contains(search));
}
baseSpecification.AppalyPaging(request.Start, request.Length);
baseSpecification.AddSelect(x => new UserListViewModel(
x.Id,
x.UserName,
x.Email,
x.FirstName,
x.LastName));
PaginatedData <UserListViewModel> paginationData = _userRepository.GetPaginated(baseSpecification);
DataTableResult <UserListViewModel> result = new DataTableResult <UserListViewModel>(
draw: request.Draw,
recordsTotal: paginationData.Count,
recordsFilterd: paginationData.Count,
error: null,
data: paginationData.Data);
return(Result.Ok(result));
}
public virtual JsonResult IntersetingCategory(UserCategoryReq request)
{
if (!VerifyToken())
{
return(ResultUtils.Fail(app_senre, msg_box));
}
if (string.IsNullOrEmpty(request.categoryids))
{
return(ResultUtils.Fail("请选择感兴趣的类目"));
}
string[] arr = request.categoryids.Split(',');
var list = arr.Select(c => c.ToInt()).ToArray();
int ret = NH.Service.CategoryService.Instance().InterstingCategory(userid, list);
if (ret > 0)
{
return(ResultUtils.Success("提交成功"));
}
return(ResultUtils.Fail("提交失败"));
}
public async Task <Result> SetNewPassword(string userId, SetNewPasswordRequest setNewPasswordRequest, string adminId)
{
ValidationResult validationResult = _setNewPasswordValidator.Validate(setNewPasswordRequest);
if (!validationResult.IsValid)
{
_logger.LogError($"Invlid SetNewPasswordRequest. Admin {adminId}");
return(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(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(Result.Fail(changePasswordResult.Errors));
}
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(Result.Ok());
}
public async Task <Result> AddRoles(string userId, List <string> roles, string adminId)
{
AppUserEntity appUser = await _userManager.FindByIdAsync(userId);
if (appUser == null)
{
_logger.LogError($"No user {userId}");
return(Result.Fail("no_user", "No User"));
}
IdentityResult result = await _userManager.AddToRolesAsync(appUser, roles);
if (!result.Succeeded)
{
_logger.LogError($"Admin with id {adminId} faild to add roles to user with id {userId}");
return(Result.Fail(ResultUtils.ToResultError(result.Errors)));
}
_logger.LogInformation($"Admin with id {adminId} added roles to user with id {userId}. Role ids: {Newtonsoft.Json.JsonConvert.SerializeObject(roles)}");
return(Result.Ok());
}
public Result <DataTableResult <RoleListViewModel> > GetAll(DataTableRequest request)
{
ValidationResult validationResult = _dataTableValidator.Validate(request);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid DataTableRequest model");
return(Result.Fail <DataTableResult <RoleListViewModel> >(ResultUtils.ToResultError(validationResult.Errors.ToList())));
}
PaginationSpecification <RoleEntity, RoleListViewModel> baseSpecification = new PaginationSpecification <RoleEntity, RoleListViewModel>();
if (!string.IsNullOrEmpty(request.Search))
{
string search = request.Search.ToUpper();
baseSpecification.AddFilter(x =>
x.Id.ToUpper().Contains(search) ||
x.Name.ToUpper().Contains(search));
}
baseSpecification.AppalyPaging(request.Start, request.Length);
baseSpecification.AddSelect(x => new RoleListViewModel(
x.Id,
x.Name,
x.Type.ToString()));
PaginatedData <RoleListViewModel> pagedResult = _roleRepository.GetPaginated(baseSpecification);
DataTableResult <RoleListViewModel> result = new DataTableResult <RoleListViewModel>(
draw: request.Draw,
recordsTotal: pagedResult.Count,
recordsFilterd: pagedResult.Count,
error: null,
data: pagedResult.Data);
return(Result.Ok(result));
}
/// <summary>
/// Used only when admin is adding new user
/// </summary>
/// <param name="newUserRequest"></param>
/// <param name="adminId"></param>
/// <returns></returns>
public async Task <Result <string> > AddUser(NewUserRequest newUserRequest, string adminId)
{
ValidationResult validationResult = _newUserValidator.Validate(newUserRequest);
if (!validationResult.IsValid)
{
_logger.LogError($"Invalid NewUserRequest. Admin {adminId}");
return(Result.Fail <string>(ResultUtils.ToResultError(validationResult.Errors)));
}
AppUserEntity appUser = new AppUserEntity(
userName: newUserRequest.UserName,
email: newUserRequest.Email,
firstName: newUserRequest.FirstName,
lastName: newUserRequest.LastName,
emailConfirmed: false,
enabled: true);
IdentityResult result = await _userManager.CreateAsync(appUser);
if (!result.Succeeded)
{
_logger.LogError($"Admin with id {adminId} failed to add new user");
return(Result.Fail <string>(ResultUtils.ToResultError(result.Errors)));
}
appUser = await _userManager.FindByNameAsync(newUserRequest.UserName);
if (appUser == null)
{
_logger.LogError($"Failed to find new user with UserName {newUserRequest.UserName}. Admin {adminId}");
return(Result.Fail <string>("no_user", "No user"));
}
return(Result.Ok(appUser.Id));
}
public async Task <Result> EditUser(string id, EditUserRequest editUserRequest, string adminId)
{
ValidationResult validationResult = _editUserValidator.Validate(editUserRequest);
if (!validationResult.IsValid)
{
_logger.LogError($"Invalid EditUserRequest. Admin {adminId}");
return(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(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(Result.Fail("error", "error"));
}
if (updateSecurityStamp)
{
Result logoutUserResult = await _sessionService.LogoutUser(new Auth.Session.Models.LogoutUserSessionsRequest(appUser.Id), adminId);
if (logoutUserResult.Failure)
{
return(logoutUserResult);
}
}
return(Result.Ok());
}
public async Task <Result> AcceptInvite(AcceptInviteRequest acceptInvite)
{
ValidationResult validationResult = _acceptInviteValidator.Validate(acceptInvite);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid {nameof(AcceptInviteRequest)} model");
return(Result.Fail(validationResult.Errors));
}
BaseSpecification <InviteEntity> getInviteSpecification = new BaseSpecification <InviteEntity>();
getInviteSpecification.AddFilter(x => x.Token == acceptInvite.Code);
getInviteSpecification.AddFilter(x => x.Status == Data.Enums.Entity.InviteStatuses.Pending);
InviteEntity inviteEntity = _inviteRepository.SingleOrDefault(getInviteSpecification);
if (inviteEntity == null)
{
_logger.LogError($"No Invite. Token {acceptInvite.Code}");
return(Result.Fail("no_invite", "No Invite"));
}
if (inviteEntity.ExpiresAt < DateTimeOffset.UtcNow)
{
_logger.LogError($"Invite has expired");
return(Result.Fail("no_invite", "No Invite"));
}
AppUserEntity appUser = new AppUserEntity(
userName: inviteEntity.Email,
email: inviteEntity.Email,
firstName: acceptInvite.FirstName,
lastName: acceptInvite.LastName,
emailConfirmed: true,
enabled: true);
IdentityResult identityResult = await _userManager.CreateAsync(appUser, acceptInvite.Password);
if (!identityResult.Succeeded)
{
_logger.LogError($"Failed to create new user for invite. InviteId {inviteEntity.Id}");
return(Result.Fail(ResultUtils.ToResultError(identityResult.Errors)));
}
inviteEntity.Update(Data.Enums.Entity.InviteStatuses.Accepted);
bool updateInvite = _inviteRepository.Update(inviteEntity);
if (!updateInvite)
{
_logger.LogWarning($"Failed to update invite status. InnivteId {inviteEntity.Id}, UserId {appUser.Id}");
}
if (inviteEntity.GroupId != null)
{
AddToGroup(appUser.Id, inviteEntity.GroupId, inviteEntity.GroupRoleId);
}
if (inviteEntity.RoleId != null)
{
await AddToGlobalRole(appUser, inviteEntity.RoleId);
}
return(Result.Ok());
}
public async Task <Result> AcceptInvite(AcceptInviteRequest acceptInvite)
{
ValidationResult acceptInviteValidationResult = _acceptInviteValidator.Validate(acceptInvite);
ValidationResult userAttributeValidationResult = _userAttributeRequestValidator.Validate(acceptInvite);
if (!acceptInviteValidationResult.IsValid || !userAttributeValidationResult.IsValid)
{
_logger.LogWarning($"Invalid {nameof(AcceptInviteRequest)} model");
List <Result.ResultError> errors = ResultUtils.ToResultError(acceptInviteValidationResult.Errors);
errors.AddRange(ResultUtils.ToResultError(userAttributeValidationResult.Errors));
return(Result.Fail(errors));
}
BaseSpecification <InviteEntity> getInviteSpecification = new BaseSpecification <InviteEntity>();
getInviteSpecification.AddFilter(x => x.Token == acceptInvite.Code);
getInviteSpecification.AddFilter(x => x.Status == Data.Enums.Entity.InviteStatuses.Pending);
InviteEntity inviteEntity = _inviteRepository.SingleOrDefault(getInviteSpecification);
if (inviteEntity == null)
{
_logger.LogError($"No Invite. Token {acceptInvite.Code}");
return(Result.Fail("no_invite", "No Invite"));
}
if (inviteEntity.ExpiresAt < DateTimeOffset.UtcNow)
{
_logger.LogError($"Invite has expired");
return(Result.Fail("no_invite", "No Invite"));
}
List <UserAttributeEntity> userAttributes = null;
if (acceptInvite.Attributes != null)
{
userAttributes = acceptInvite.Attributes
.Select(x => new UserAttributeEntity(
key: x.Key,
value: x.Value))
.ToList();
}
string username;
if (_identityUIEndpoints.UseEmailAsUsername)
{
username = inviteEntity.Email;
}
else
{
if (string.IsNullOrEmpty(acceptInvite.Username))
{
_logger.LogError($"Username cannot be empty");
return(Result.Fail("username_cannot_be_empty", "username_cannot_be_empty"));
}
username = acceptInvite.Username;
}
AppUserEntity appUser = new AppUserEntity(
userName: username,
email: inviteEntity.Email,
firstName: acceptInvite.FirstName,
lastName: acceptInvite.LastName,
emailConfirmed: true,
enabled: true,
phoneNumber: acceptInvite.PhoneNumber,
attributes: userAttributes);
IdentityResult identityResult = await _userManager.CreateAsync(appUser, acceptInvite.Password);
if (!identityResult.Succeeded)
{
_logger.LogError($"Failed to create new user for invite. InviteId {inviteEntity.Id}");
return(Result.Fail(ResultUtils.ToResultError(identityResult.Errors)));
}
inviteEntity.Update(Data.Enums.Entity.InviteStatuses.Accepted);
bool updateInvite = _inviteRepository.Update(inviteEntity);
if (!updateInvite)
{
_logger.LogWarning($"Failed to update invite status. InnivteId {inviteEntity.Id}, UserId {appUser.Id}");
}
if (inviteEntity.GroupId != null)
{
AddToGroup(appUser.Id, inviteEntity.GroupId, inviteEntity.GroupRoleId);
}
if (inviteEntity.RoleId != null)
{
await AddToGlobalRole(appUser, inviteEntity.RoleId);
}
return(Result.Ok());
}
public async Task <Result> ExternalLoginRequest(ExternalLoginRegisterRequest externalLoginRegisterRequest)
{
if (!_identityUIEndpoints.RegisterEnabled)
{
_logger.LogError($"User tried to register, but registrations are disabled");
return(Result.Fail("registration_is_not_enabled", "Registration disabled"));
}
ValidationResult externalLoginValidationResult = _externalLoginRequsterRequestValidator.Validate(externalLoginRegisterRequest);
ValidationResult userAttributeValidationResult = _userAttributeRequestValidator.Validate(externalLoginRegisterRequest);
if (!externalLoginValidationResult.IsValid || !userAttributeValidationResult.IsValid)
{
_logger.LogWarning($"Invalid {nameof(ExternalLoginRegisterRequestValidator)} model");
List <Result.ResultError> errors = ResultUtils.ToResultError(externalLoginValidationResult.Errors);
errors.AddRange(ResultUtils.ToResultError(userAttributeValidationResult.Errors));
return(Result.Fail(errors));
}
ExternalLoginInfo externalLoginInfo = await _signInManager.GetExternalLoginInfoAsync();
if (externalLoginInfo == null)
{
_logger.LogError($"Failed to get external login info.");
return(Result.Fail("failed_to_get_external_login_info", "Failed to get external login info"));
}
List <UserAttributeEntity> userAttributes = null;
if (externalLoginRegisterRequest.Attributes != null)
{
userAttributes = externalLoginRegisterRequest.Attributes
.Select(x => new UserAttributeEntity(
key: x.Key,
value: x.Value))
.ToList();
}
string username;
if (_identityUIEndpoints.UseEmailAsUsername)
{
username = externalLoginRegisterRequest.Email;
}
else
{
if (string.IsNullOrEmpty(externalLoginRegisterRequest.Username))
{
_logger.LogError($"Username cannot be empty");
return(Result.Fail("username_cannot_be_empty", "username_cannot_be_empty"));
}
username = externalLoginRegisterRequest.Username;
}
AppUserEntity appUser = new AppUserEntity(
userName: username,
email: externalLoginRegisterRequest.Email,
firstName: externalLoginRegisterRequest.FirstName,
lastName: externalLoginRegisterRequest.LastName,
emailConfirmed: false,
enabled: true,
phoneNumber: externalLoginRegisterRequest.PhoneNumber,
attributes: userAttributes);
IdentityResult createUserResult = await _userManager.CreateAsync(appUser);
if (!createUserResult.Succeeded)
{
_logger.LogError($"Failed to create user");
return(Result.Fail(createUserResult.Errors));
}
IdentityResult addLoginResult = await _userManager.AddLoginAsync(appUser, externalLoginInfo);
if (!addLoginResult.Succeeded)
{
_logger.LogError($"Failed to add login to user. UserId {appUser.Id}");
}
string code = await _userManager.GenerateEmailConfirmationTokenAsync(appUser);
await _emailService.SendVerificationMail(appUser, code);
return(Result.Ok());
}
public async Task <Result> Register(RegisterRequest registerRequest)
{
if (!_identityUIEndpoints.RegisterEnabled)
{
_logger.LogError($"User tried to register, but registrations are disabled");
return(Result.Fail("registration_is_not_enabled", "Registration disabled"));
}
ValidationResult registerValidationResult = _registerValidator.Validate(registerRequest);
ValidationResult userAttributeValidationResult = _userAttributeRequestValidator.Validate(registerRequest);
if (!registerValidationResult.IsValid || !userAttributeValidationResult.IsValid)
{
_logger.LogError($"Invalid {typeof(RegisterRequest).Name} model");
List <Result.ResultError> errors = ResultUtils.ToResultError(registerValidationResult.Errors);
errors.AddRange(ResultUtils.ToResultError(userAttributeValidationResult.Errors));
return(Result.Fail(errors));
}
List <UserAttributeEntity> userAttributes = null;
if (registerRequest.Attributes != null)
{
userAttributes = registerRequest.Attributes
.Select(x => new UserAttributeEntity(
key: x.Key,
value: x.Value))
.ToList();
}
string username;
if (_identityUIEndpoints.UseEmailAsUsername)
{
username = registerRequest.Email;
}
else
{
if (string.IsNullOrEmpty(registerRequest.Username))
{
_logger.LogError($"Username cannot be empty");
return(Result.Fail("username_cannot_be_empty", "username_cannot_be_empty"));
}
username = registerRequest.Username;
}
AppUserEntity appUser = new AppUserEntity(
userName: username,
email: registerRequest.Email,
firstName: registerRequest.FirstName,
lastName: registerRequest.LastName,
emailConfirmed: false,
enabled: true,
phoneNumber: registerRequest.PhoneNumber,
attributes: userAttributes);
IdentityResult identityResult = await _userManager.CreateAsync(appUser, registerRequest.Password);
if (!identityResult.Succeeded)
{
_logger.LogError($"Failed to register user");
return(Result.Fail(ResultUtils.ToResultError(identityResult.Errors)));
}
string code = await _userManager.GenerateEmailConfirmationTokenAsync(appUser);
await _emailService.SendVerificationMail(appUser, code);
return(Result.Ok());
}
public static Result <T> Fail <T>(IEnumerable <IdentityError> errors)
{
return(new Result <T>(default(T), false, ResultUtils.ToResultError(errors)));
}
public static Result <T> Fail <T>(IList <ValidationFailure> errors)
{
return(new Result <T>(default(T), false, ResultUtils.ToResultError(errors)));
}
public static Result Fail(IEnumerable <IdentityError> errors)
{
return(new Result(false, ResultUtils.ToResultError(errors)));
}
public static Result Fail(IList <ValidationFailure> errors)
{
return(new Result(false, ResultUtils.ToResultError(errors)));
}
