public Result <EmailViewModel> GetViewModel(long id, string userId)
{
SelectSpecification <EmailEntity, EmailViewModel> selectSpecification = new SelectSpecification <EmailEntity, EmailViewModel>();
selectSpecification.AddFilter(x => x.Id == id);
selectSpecification.AddSelect(x => new EmailViewModel(
x.Id,
x.Type.GetDescription(),
x.Subject,
x.Body));
EmailViewModel emailView = _emailRepository.SingleOrDefault(selectSpecification);
if (emailView == null)
{
_logger.LogError($"No Email. EmailId id");
return(Result.Fail <EmailViewModel>("no_email", "No Email"));
}
SelectSpecification <AppUserEntity, string> emailSpecification = new SelectSpecification <AppUserEntity, string>();
emailSpecification.AddFilter(x => x.Id == userId);
emailSpecification.AddSelect(X => X.Email);
string email = _userRepository.SingleOrDefault(emailSpecification);
emailView.Email = email;
emailView.UseEmailSender = _identityUIEndpoint.UseEmailSender ?? false;
return(Result.Ok(emailView));
}
public Result <GroupUserViewModel> GetGroupUserViewModel(string groupId)
{
_logger.LogInformation($"Getting Group. GroupId {groupId}");
SelectSpecification <GroupEntity, GroupUserViewModel> selectSpecification = new SelectSpecification <GroupEntity, GroupUserViewModel>();
selectSpecification.AddFilter(x => x.Id == groupId);
selectSpecification.AddSelect(x => new GroupUserViewModel(
x.Id,
x.Name));
GroupUserViewModel groupUserViewModel = _groupStore.Get(selectSpecification);
if (groupUserViewModel == null)
{
_logger.LogError($"No Group. GroupId {groupId}");
return(Result.Fail <GroupUserViewModel>("no_group", "No Group"));
}
groupUserViewModel.CanAssigneGroupRoles = _groupUserStore.CanAssigneGroupRoles();
groupUserViewModel.CanMangeGroupRoles = _groupUserStore.CanManageGroupRoles();
groupUserViewModel.CanChangeOwnRole = _groupUserStore.CanChangeOwnRole();
return(Result.Ok(groupUserViewModel));
}
public Result <Select2Result <Select2ItemBase> > GetAvailable(Select2Request select2Request)
{
ValidationResult validationResult = _select2Validator.Validate(select2Request);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid {nameof(Select2Request)} model");
return(Result.Fail <Select2Result <Select2ItemBase> >(validationResult.Errors));
}
SelectSpecification <AppUserEntity, Select2ItemBase> selectSpecification = new SelectSpecification <AppUserEntity, Select2ItemBase>();
selectSpecification.AddFilter(x => x.Groups.Count == 0); // TODO: change this maybe
if (!string.IsNullOrEmpty(select2Request.Term))
{
selectSpecification.AddFilter(x => x.NormalizedUserName.Contains(select2Request.Term));
}
selectSpecification.AddSelect(x => new Select2ItemBase(
x.Id,
x.UserName));
List <Select2ItemBase> users = _userRepository.GetList(selectSpecification);
Select2Result <Select2ItemBase> select2Result = new Select2Result <Select2ItemBase>(
results: users);
return(Result.Ok(select2Result));
}
public Result <Select2Result <Select2ItemBase> > GetGlobalRoles(Select2Request select2Request)
{
ValidationResult validationResult = _select2RequestValidator.Validate(select2Request);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid {nameof(Select2Request)} model");
return(Result.Fail <Select2Result <Select2ItemBase> >(validationResult.Errors));
}
SelectSpecification <RoleEntity, Select2ItemBase> selectSpecification =
new SelectSpecification <RoleEntity, Select2ItemBase>();
selectSpecification.AddFilter(x => x.Type == Core.Data.Enums.Entity.RoleTypes.Global);
if (!string.IsNullOrEmpty(select2Request.Term))
{
selectSpecification.AddFilter(x => x.NormalizedName.Contains(select2Request.Term.ToUpper()));
}
selectSpecification.AddSelect(x => new Select2ItemBase(
x.Id,
x.Name));
List <Select2ItemBase> roles = _roleRepository.GetList(selectSpecification);
Select2Result <Select2ItemBase> select2Result = new Select2Result <Select2ItemBase>(
results: roles);
return(Result.Ok(select2Result));
}
public Result <Select2Result <Select2ItemBase> > GetAvailable(string roleId, Select2Request select2Request)
{
ValidationResult validationResult = _select2Validator.Validate(select2Request);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid {nameof(Select2Request)} model");
return(Result.Fail <Select2Result <Select2ItemBase> >(validationResult.Errors));
}
SelectSpecification <PermissionEntity, Select2ItemBase> selectSpecification = new SelectSpecification <PermissionEntity, Select2ItemBase>();
selectSpecification.AddFilter(x => !x.Roles.Select(c => c.RoleId).Contains(roleId));
if (!string.IsNullOrEmpty(select2Request.Term))
{
selectSpecification.AddFilter(x => x.Name.ToUpper().Contains(select2Request.Term.ToUpper()));
}
selectSpecification.AddSelect(x => new Select2ItemBase(
x.Id,
x.Name));
List <Select2ItemBase> availableRoles = _permissionRepository.GetList(selectSpecification);
Select2Result <Select2ItemBase> select2Result = new Select2Result <Select2ItemBase>(
results: availableRoles);
return(Result.Ok(select2Result));
}
public virtual async Task <UserData> GetUserData(string userId)
{
SelectSpecification <AppUserEntity, UserData> userDataSpecification = new SelectSpecification <AppUserEntity, UserData>();
userDataSpecification.AddFilter(x => x.Id == userId);
userDataSpecification.AddSelect(x => new UserData(
x.Id,
x.UserName,
x.SecurityStamp,
x.Groups
.Select(c => new GroupData(
c.Group.Id,
c.Group.Name,
c.Role.Name,
c.Role.Permissions.Select(v => v.Permission.Name))),
x.UserRoles.Select(c => new RoleData(
c.Role.Name,
c.Role.Type,
c.Role.Permissions.Select(v => v.Permission.Name)))
));
UserData userData = await _userRepository.SingleOrDefault(userDataSpecification);
if (userData == null)
{
_logger.LogError($"User does not exists. UserId {userId}");
throw new Exception("no user");
}
return(userData);
}
public Result <UserDetailsViewModel> GetDetailsViewModel(string id)
{
SelectSpecification <AppUserEntity, UserDetailsViewModel> userSpecification = new SelectSpecification <AppUserEntity, UserDetailsViewModel>();
userSpecification.AddFilter(x => x.Id == id);
userSpecification.AddSelect(x => new UserDetailsViewModel(
/*id:*/ x.Id,
/*userName:*/ x.UserName,
/*email:*/ x.Email,
/*firstName:*/ x.FirstName,
/*lastName:*/ x.LastName,
/*emailConfirmed:*/ x.EmailConfirmed,
/*phoneNumber:*/ x.PhoneNumber,
/*phoneNumberConfirmed:*/ x.PhoneNumberConfirmed,
/*twoFactorEnabled:*/ x.TwoFactorEnabled,
/*enabled:*/ x.Enabled,
/*LockoutEnd:*/ x.LockoutEnd.HasValue ? x.LockoutEnd.Value.ToString("d.M.yyyy HH:mm:ss") : null));
UserDetailsViewModel userDetails = _userRepository.SingleOrDefault(userSpecification);
if (userDetails == null)
{
return(Result.Fail <UserDetailsViewModel>("no_user", "No user"));
}
userDetails.UseEmailSender = _identityUIEndpoints.UseEmailSender ?? false;
return(Result.Ok(userDetails));
}
public Result <Select2Result <Select2ItemBase> > GetUnassigned(string roleId, Select2Request select2Request)
{
ValidationResult validationResult = _select2Validator.Validate(select2Request);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid Select2Request model");
return(Result.Fail <Select2Result <Select2ItemBase> >(validationResult.Errors));
}
SelectSpecification <RoleEntity, Select2ItemBase> selectSpecification =
new SelectSpecification <RoleEntity, Select2ItemBase>();
selectSpecification.AddFilter(x => x.Id != roleId);
selectSpecification.AddFilter(x => x.Type == Core.Data.Enums.Entity.RoleTypes.Group);
selectSpecification.AddFilter(x => !x.CanBeAssignedBy.Select(c => c.RoleId).Contains(roleId)); //TODO: check this
selectSpecification.AddSelect(x => new Select2ItemBase(
x.Id,
x.Name));
List <Select2ItemBase> unassignedRoles = _roleRepository.GetList(selectSpecification);
Select2Result <Select2ItemBase> select2Result = new Select2Result <Select2ItemBase>(
unassignedRoles, false);
return(Result.Ok(select2Result));
}
public Result <Select2Result <Select2ItemBase> > GetGroups(Select2Request select2Request)
{
ValidationResult validationResult = _select2RequestValidator.Validate(select2Request);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid {nameof(Select2Request)} model");
return(Result.Fail <Select2Result <Select2ItemBase> >(validationResult.Errors));
}
SelectSpecification <GroupEntity, Select2ItemBase> selectSpecification =
new SelectSpecification <GroupEntity, Select2ItemBase>();
if (!string.IsNullOrEmpty(select2Request.Term))
{
selectSpecification.AddFilter(x => x.Name.ToUpper().Contains(select2Request.Term.ToUpper()));
}
selectSpecification.AddSelect(x => new Select2ItemBase(
x.Id,
x.Name));
List <Select2ItemBase> groups = _groupRepository.GetList(selectSpecification);
Select2Result <Select2ItemBase> select2Result = new Select2Result <Select2ItemBase>(
results: groups);
return(Result.Ok(select2Result));
}
private List <RoleListData> GetAllGroupRoles()
{
SelectSpecification <RoleEntity, RoleListData> selectSpecification = new SelectSpecification <RoleEntity, RoleListData>();
selectSpecification.AddFilter(x => x.Type == Data.Enums.Entity.RoleTypes.Group);
selectSpecification.AddSelect(x => new RoleListData(
x.Id,
x.Name));
List <RoleListData> roleListData = _roleRepository.GetList(selectSpecification);
return(roleListData);
}
public async Task <Core.Models.Result.Result> LogoutUser(LogoutUserSessionsRequest request, string adminId)
{
ValidationResult validationResult = _logoutUserSessionsValidator.Validate(request);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invlid LogoutSessionRequest. Admin {adminId}");
return(Core.Models.Result.Result.Fail(validationResult.Errors));
}
AppUserEntity appUser = await _userManager.FindByIdAsync(request.UserId);
if (appUser == null)
{
_logger.LogWarning($"No user. UserId {request.UserId}, Admin {adminId}");
return(Core.Models.Result.Result.Fail("no_user", "No user"));
}
SelectSpecification <SessionEntity, SessionEntity> specification = new SelectSpecification <SessionEntity, SessionEntity>();
specification.AddFilter(x => x.UserId == request.UserId);
specification.AddSelect(x => x);
List <SessionEntity> sessions = _sessionRepository.GetList(specification);
if (sessions.Count == 0)
{
return(Core.Models.Result.Result.Ok());
}
foreach (SessionEntity session in sessions)
{
session.EndType = SessionEndTypes.AdminLogout;
}
bool removeResult = await _sessionRepository.Remove(sessions);
if (!removeResult)
{
_logger.LogWarning($"Faild to remove sessions. UserId {request.UserId}, Admin {adminId}");
return(Core.Models.Result.Result.Fail("error", "Error"));
}
_logger.LogInformation($"User session logout. Admin {adminId}");
return(Core.Models.Result.Result.Ok());
}
public async Task <Result> RemoveRoles(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"));
}
roles = roles.Select(x => x.ToUpper()).ToList();
SelectSpecification <RoleEntity, string> roleSpecification = new SelectSpecification <RoleEntity, string>();
roleSpecification.AddFilter(x => roles.Contains(x.NormalizedName));
roleSpecification.AddFilter(x => x.Type == Data.Enums.Entity.RoleTypes.Global);
roleSpecification.AddSelect(x => x.NormalizedName);
List <string> existingRoles = _roleRepository.GetList(roleSpecification);
if (roles.Count != existingRoles.Count)
{
_logger.LogError($"Some roles does not exists. Missing roles {Newtonsoft.Json.JsonConvert.SerializeObject(roles.Except(existingRoles))}");
}
SelectSpecification <UserRoleEntity, UserRoleEntity> getUserRolesSpecification = new SelectSpecification <UserRoleEntity, UserRoleEntity>();
getUserRolesSpecification.AddFilter(x => x.UserId == userId);
getUserRolesSpecification.AddFilter(x => x.Role.Type == Data.Enums.Entity.RoleTypes.Global);
getUserRolesSpecification.AddFilter(x => existingRoles.Contains(x.Role.NormalizedName));
getUserRolesSpecification.AddSelect(x => x);
List <UserRoleEntity> userRoles = _userRoleRepository.GetList(getUserRolesSpecification);
bool removeResult = _userRoleRepository.RemoveRange(userRoles);
if (!removeResult)
{
_logger.LogError($"Failed to remove user roles. UserId {userId}. RoleNames {Newtonsoft.Json.JsonConvert.SerializeObject(roles)}");
return(Result.Fail("failed_to_remove_user_roles", "Failed to remove user roles"));
}
_logger.LogInformation($"Removed roles form user {userId}. Role names: {Newtonsoft.Json.JsonConvert.SerializeObject(existingRoles)}");
return(Result.Ok());
}
public Result <UserCredentialsViewModel> GetCredetialsViewModel(string id)
{
SelectSpecification <AppUserEntity, UserCredentialsViewModel> userSpecification = new SelectSpecification <AppUserEntity, UserCredentialsViewModel>();
userSpecification.AddFilter(x => x.Id == id);
userSpecification.AddSelect(x => new UserCredentialsViewModel(
x.Id,
x.UserName));
UserCredentialsViewModel userCredentials = _userRepository.SingleOrDefault(userSpecification);
if (userCredentials == null)
{
return(Result.Fail <UserCredentialsViewModel>("no_user", "No user"));
}
return(Result.Ok(userCredentials));
}
public Result <TwoFactorAuthenticatorViewModel> GetTwoFactorAuthenticatorViewModel(string userId)
{
SelectSpecification <AppUserEntity, TwoFactorAuthenticatorViewModel> selectSpecification = new SelectSpecification <AppUserEntity, TwoFactorAuthenticatorViewModel>();
selectSpecification.AddFilter(x => x.Id == userId);
selectSpecification.AddSelect(x => new TwoFactorAuthenticatorViewModel(
x.TwoFactorEnabled));
TwoFactorAuthenticatorViewModel twoFactorAuthenticatorViewModel = _userRepository.Get(selectSpecification);
if (twoFactorAuthenticatorViewModel == null)
{
_logger.LogWarning($"No user. UserId {userId}");
return(Result.Fail <TwoFactorAuthenticatorViewModel>("no_user", "No User"));
}
return(Result.Ok(twoFactorAuthenticatorViewModel));
}
private Result InviteExits(string email)
{
SelectSpecification <InviteEntity, InviteEntity> validInvteExistsSpecification = new SelectSpecification <InviteEntity, InviteEntity>();
validInvteExistsSpecification.AddFilter(x => x.Email == email);
validInvteExistsSpecification.AddFilter(x => x.Status == Data.Enums.Entity.InviteStatuses.Pending);
validInvteExistsSpecification.AddSelect(x => x);
List <InviteEntity> invites = _inviteRepository.GetList(validInvteExistsSpecification);
if (invites.Any(x => x.ExpiresAt > DateTimeOffset.UtcNow))
{
_logger.LogError($"Valid invite already exists");
return(Result.Fail("invite_exists", "Invite exits"));
}
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"));
}
roles = roles.Select(x => x.ToUpper()).ToList();
SelectSpecification <RoleEntity, RoleEntity> getRoleSpecification = new SelectSpecification <RoleEntity, RoleEntity>();
getRoleSpecification.AddFilter(x => roles.Contains(x.NormalizedName));
getRoleSpecification.AddSelect(x => x);
List <RoleEntity> roleEntites = _roleRepository.GetList(getRoleSpecification);
List <UserRoleEntity> userRoles = new List <UserRoleEntity>();
foreach (RoleEntity role in roleEntites)
{
if (role.Type != Data.Enums.Entity.RoleTypes.Global)
{
_logger.LogError($"Invalid role type. RoleId {role.Id}");
continue;
}
userRoles.Add(new UserRoleEntity(
userId: appUser.Id,
roleId: role.Id));
}
bool addRoles = _userRoleRepository.AddRange(userRoles);
if (!addRoles)
{
_logger.LogError($"Failed to add user roles");
return(Result.Fail("failed_to_add_user_roles", "Failed to add UserRoles"));
}
_logger.LogInformation($"Added roles to user. UserId {userId}, Role ids: {Newtonsoft.Json.JsonConvert.SerializeObject(userRoles.Select(x => x.RoleId))}");
return(Result.Ok());
}
public Result <UserSessionViewModel> GetUserSessionViewModel(string userId)
{
SelectSpecification <AppUserEntity, UserSessionViewModel> userSpecification = new SelectSpecification <AppUserEntity, UserSessionViewModel>();
userSpecification.AddFilter(x => x.Id == userId);
userSpecification.AddSelect(x => new UserSessionViewModel(
x.Id,
x.UserName));
UserSessionViewModel userRoles = _userRepository.SingleOrDefault(userSpecification);
if (userRoles == null)
{
_logger.LogWarning($"No user. UserId {userId}");
return(Result.Fail <UserSessionViewModel>("no_user", "No user"));
}
return(Result.Ok(userRoles));
}
public Result <RoleUserViewModel> GetUsersViewModel(string id)
{
SelectSpecification <RoleEntity, RoleUserViewModel> roleSpecification = new SelectSpecification <RoleEntity, RoleUserViewModel>();
roleSpecification.AddFilter(x => x.Id == id);
roleSpecification.AddSelect(x => new RoleUserViewModel(
x.Id,
x.Name));
RoleUserViewModel roleUser = _roleRepository.Get(roleSpecification);
if (roleUser == null)
{
_logger.LogWarning($"No Role. RoleId {id}");
return(Result.Fail <RoleUserViewModel>("no_role", "No Role"));
}
return(Result.Ok(roleUser));
}
public Result <PermissionMenuViewModel> GetMenuViewModel(string id)
{
SelectSpecification <PermissionEntity, PermissionMenuViewModel> selectSpecification = new SelectSpecification <PermissionEntity, PermissionMenuViewModel>();
selectSpecification.AddFilter(X => X.Id == id);
selectSpecification.AddSelect(x => new PermissionMenuViewModel(
x.Id,
x.Name));
PermissionMenuViewModel permission = _permissionRepository.SingleOrDefault(selectSpecification);
if (permission == null)
{
_logger.LogError($"No Permission");
return(Result.Fail <PermissionMenuViewModel>("no_permission", "No Permission"));
}
return(Result.Ok(permission));
}
public Result <UserMenuViewModel> GetUserMenuViewModel(string id)
{
SelectSpecification <AppUserEntity, UserMenuViewModel> userSpecification = new SelectSpecification <AppUserEntity, UserMenuViewModel>();
userSpecification.AddFilter(x => x.Id == id);
userSpecification.AddSelect(x => new UserMenuViewModel(
x.Id,
x.UserName));
UserMenuViewModel userMenuView = _userRepository.SingleOrDefault(userSpecification);
if (userMenuView == null)
{
_logger.LogError($"No User. UserId {id}");
return(Result.Fail <UserMenuViewModel>("no_user", "No user"));
}
return(Result.Ok(userMenuView));
}
public Result <RoleDetailViewModel> GetDetails(string id)
{
SelectSpecification <RoleEntity, RoleDetailViewModel> roleSpecification = new SelectSpecification <RoleEntity, RoleDetailViewModel>();
roleSpecification.AddFilter(x => x.Id == id);
roleSpecification.AddSelect(x => new RoleDetailViewModel(
x.Id,
x.Name,
x.Description));
RoleDetailViewModel roleDetail = _roleRepository.Get(roleSpecification);
if (roleDetail == null)
{
_logger.LogWarning($"Role with id {id} does not exist");
return(Result.Fail <RoleDetailViewModel>("no_role", "No Role"));
}
return(Result.Ok(roleDetail));
}
public Result <GroupMenuViewModel> GetMenuViewModel(string id)
{
_logger.LogInformation($"Getting Group. GroupId {id}");
SelectSpecification <GroupEntity, GroupMenuViewModel> selectSpecification = new SelectSpecification <GroupEntity, GroupMenuViewModel>();
selectSpecification.AddFilter(x => x.Id == id);
selectSpecification.AddSelect(x => new GroupMenuViewModel(
x.Id,
x.Name));
GroupMenuViewModel groupMenuView = _groupStore.Get(selectSpecification);
if (groupMenuView == null)
{
_logger.LogError($"No Group. GroupId {id}");
return(Result.Fail <GroupMenuViewModel>("no_group", "No Group"));
}
return(Result.Ok(groupMenuView));
}
public Result <ProfileViewModel> GetProfile(string userId)
{
SelectSpecification <AppUserEntity, ProfileViewModel> selectSpecification = new SelectSpecification <AppUserEntity, ProfileViewModel>();
selectSpecification.AddFilter(x => x.Id == userId);
selectSpecification.AddSelect(x => new ProfileViewModel(
x.UserName,
x.FirstName,
x.LastName,
x.PhoneNumber));
ProfileViewModel profile = _userRepository.Get(selectSpecification);
if (profile == null)
{
_logger.LogWarning($"No user. UserId {userId}");
return(Result.Fail <ProfileViewModel>("no_user", "No User"));
}
return(Result.Ok(profile));
}
public override async Task <ClaimsPrincipal> CreateAsync(AppUserEntity user)
{
SelectSpecification <AppUserEntity, UserData> userDataSpecification = new SelectSpecification <AppUserEntity, UserData>();
userDataSpecification.AddFilter(x => x.Id == user.Id);
userDataSpecification.AddSelect(x => new UserData(
x.Id,
x.UserName,
x.SecurityStamp,
x.Groups
.Select(c => new GroupData(
c.Group.Id,
c.Group.Name,
c.Role.Name,
c.Role.Permissions.Select(v => v.Permission.Name))),
x.UserRoles.Select(c => new RoleData(
c.Role.Name,
c.Role.Type,
c.Role.Permissions.Select(v => v.Permission.Name)))
));
UserData userData = await _userRepository.SingleOrDefault(userDataSpecification);
if (userData == null)
{
throw new Exception("no user");
}
ClaimsIdentity claimsIdentity = userData.ToClaimIdentity(Options.ClaimsIdentity.SecurityStampClaimType);
ClaimsPrincipal claimsPrincipal = new ClaimsPrincipal(claimsIdentity);
if (!string.IsNullOrEmpty(user.SessionCode))
{
((ClaimsIdentity)claimsPrincipal.Identity).AddClaim(new Claim(IdentityUIClaims.SESSION_CODE, user.SessionCode));
}
return(claimsPrincipal);
}
public Result <TwoFactorAuthenticatorViewModel> GetTwoFactorAuthenticatorViewModel()
{
string userId = _httpContextAccessor.HttpContext.User.GetUserId();
SelectSpecification <AppUserEntity, TwoFactorAuthenticatorViewModel> selectSpecification = new SelectSpecification <AppUserEntity, TwoFactorAuthenticatorViewModel>();
selectSpecification.AddFilter(x => x.Id == userId);
selectSpecification.AddSelect(x => new TwoFactorAuthenticatorViewModel(
x.TwoFactorEnabled,
x.TwoFactor.ToProvider(),
_options.UseSmsGateway && !string.IsNullOrEmpty(x.PhoneNumber),
_options.UseEmailSender.GetValueOrDefault(false) && !string.IsNullOrEmpty(x.Email)));
TwoFactorAuthenticatorViewModel twoFactorAuthenticatorViewModel = _userRepository.SingleOrDefault(selectSpecification);
if (twoFactorAuthenticatorViewModel == null)
{
_logger.LogWarning($"No user. UserId {userId}");
return(Result.Fail <TwoFactorAuthenticatorViewModel>("no_user", "No User"));
}
return(Result.Ok(twoFactorAuthenticatorViewModel));
}
private List <RoleListData> GetRoleAssignmes(string userId, string groupId)
{
SelectSpecification <GroupUserEntity, RoleListData> getGroupRoleSpecification = new SelectSpecification <GroupUserEntity, RoleListData>();
getGroupRoleSpecification.AddFilter(x => x.UserId == userId);
getGroupRoleSpecification.AddFilter(x => x.GroupId == groupId);
getGroupRoleSpecification.AddSelect(x => new RoleListData(
x.Role.Id,
x.Role.Name));
RoleListData groupRole = _groupUserRepository.SingleOrDefault(getGroupRoleSpecification);
if (groupRole == null)
{
_logger.LogInformation($"User has no groupRole. UserId {userId}, GroupId {groupId}");
return(new List <RoleListData>());
}
SelectSpecification <RoleAssignmentEntity, RoleListData> getRoleAssignmesSpecification = new SelectSpecification <RoleAssignmentEntity, RoleListData>();
getRoleAssignmesSpecification.AddFilter(x => x.RoleId == groupRole.Id);
getRoleAssignmesSpecification.AddSelect(x => new RoleListData(
x.CanAssigneRole.Id,
x.CanAssigneRole.Name));
List <RoleListData> canAssigneRoles = _roleAssignmentRepository.GetList(getRoleAssignmesSpecification);
if (!canAssigneRoles.Any(x => x.Id == groupRole.Id))
{
canAssigneRoles.Add(groupRole);
}
return(canAssigneRoles);
}
public T Get <T>(SelectSpecification <GroupUserEntity, T> selectSpecification)
{
selectSpecification = ApplayGroupUserFilter(selectSpecification);
return(_groupUserRepository.SingleOrDefault(selectSpecification));
}
