private Result RemoveGroupRole(string userId, string roleId)
{
BaseSpecification <GroupUserEntity> baseSpecification = new BaseSpecification <GroupUserEntity>();
baseSpecification.AddFilter(x => x.UserId == userId);
baseSpecification.AddFilter(x => x.RoleId == roleId);
GroupUserEntity groupUser = _groupUserRepository.SingleOrDefault(baseSpecification);
if (groupUser == null)
{
_logger.LogError($"No GroupUser. UserId {userId}, roleId {roleId}");
return(Result.Fail("no_group_user", "No GroupUser"));
}
groupUser.UpdateRole(null);
bool updateResult = _groupUserRepository.Update(groupUser);
if (!updateResult)
{
_logger.LogError($"Failed to update GroupUser. UserId {userId}, roleId {roleId}");
return(Result.Fail("failed_to_update_group_user", "Failed to update GroupUser"));
}
return(Result.Ok());
}
public Core.Models.Result.Result Logout(string sessionCode, string userId, SessionEndTypes endType)
{
BaseSpecification <SessionEntity> specification = new BaseSpecification <SessionEntity>();
specification.AddFilter(x => x.Code == sessionCode);
specification.AddFilter(x => x.UserId == userId);
SessionEntity session = _sessionRepository.SingleOrDefault(specification);
if (session == null)
{
_logger.LogError($"Sesion does not exist. SessionCode {sessionCode}, userId {userId}");
return(Core.Models.Result.Result.Fail("no_session", "No Session"));
}
session.EndType = endType;
bool removeSessionResult = _sessionRepository.Remove(session);
if (!removeSessionResult)
{
_logger.LogError($"Faild to remove session. SessionCode {sessionCode}, userId {userId}");
return(Core.Models.Result.Result.Fail("error", "Error"));
}
_logger.LogInformation($"User session logout. UserId {userId}");
return(Core.Models.Result.Result.Ok());
}
private async Task <Result> AddToGlobalRole(AppUserEntity appUser, string roleId)
{
_logger.LogInformation($"Adding user to global role. UserId {appUser.Id}, RoleId {roleId}");
BaseSpecification <RoleEntity> baseSpecification = new BaseSpecification <RoleEntity>();
baseSpecification.AddFilter(x => x.Id == roleId);
baseSpecification.AddFilter(x => x.Type == Data.Enums.Entity.RoleTypes.Global);
RoleEntity role = _roleRepository.SingleOrDefault(baseSpecification);
if (role == null)
{
_logger.LogError($"No GlobalRole. RoleId {roleId}");
return(Result.Fail("no_role", "No Role"));
}
IdentityResult addResult = await _userManager.AddToRoleAsync(appUser, role.Name);
if (!addResult.Succeeded)
{
_logger.LogError($"Failed to add role. UserId {appUser.Id}, RoleId {roleId}");
return(Result.Fail("failed_to_add_role", "Failed to add role"));
}
return(Result.Ok());
}
public async Task <Result> Update(string userId, long attributeId, UpdateUserAttributeModel updateUserAttribute)
{
ValidationResult validationResult = _updateUserAttribute.Validate(updateUserAttribute);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid {typeof(UpdateUserAttributeModel).CustomAttributes} model");
return(Result.Fail(validationResult.Errors));
}
BaseSpecification <UserAttributeEntity> baseSpecification = new BaseSpecification <UserAttributeEntity>();
baseSpecification.AddFilter(x => x.Id == attributeId);
baseSpecification.AddFilter(x => x.UserId == userId);
UserAttributeEntity userAttribute = await _userAttributeRepository.SingleOrDefault(baseSpecification);
if (userAttribute == null)
{
_logger.LogError($"No UserAttribute. UserId {userId}, AttributeId {attributeId}");
return(Result.Fail("no_user_attribute", "No UserAttribute"));
}
userAttribute.Value = updateUserAttribute.Value;
bool updateResult = await _userAttributeRepository.Update(userAttribute);
if (!updateResult)
{
_logger.LogError($"Failed to update UserAttribute. UserId {userId}, AttributeId {attributeId}");
return(Result.Fail("failed_to_update_user_attribute", "Failed to update user attribute"));
}
return(Result.Ok());
}
public async Task <Result> Remove(string userId, long attributeId)
{
BaseSpecification <UserAttributeEntity> baseSpecification = new BaseSpecification <UserAttributeEntity>();
baseSpecification.AddFilter(x => x.Id == attributeId);
baseSpecification.AddFilter(x => x.UserId == userId);
UserAttributeEntity userAttribute = await _userAttributeRepository.SingleOrDefault(baseSpecification);
if (userAttribute == null)
{
_logger.LogError($"No UserAttribute. UserId {userId}, AttributeId {attributeId}");
return(Result.Fail("no_user_attribute", "No UserAttribute"));
}
bool removeResult = await _userAttributeRepository.Remove(userAttribute);
if (!removeResult)
{
_logger.LogError($"Failed to remove user attribute. UserId {userId}, AttributeId {attributeId}");
return(Result.Fail("failed_to_remove_user_attribute", "Failed to remove user attribute"));
}
return(Result.Ok());
}
private Result RoleIsValid(string roleId)
{
if (roleId == null)
{
_logger.LogInformation($"Adding GroupUser without role");
return(Result.Ok());
}
BaseSpecification <RoleEntity> baseSpecification = new BaseSpecification <RoleEntity>();
baseSpecification.AddFilter(x => x.Id == roleId);
baseSpecification.AddFilter(x => x.Type == Data.Enums.Entity.RoleTypes.Group);
RoleEntity role = _roleRepository.SingleOrDefault(baseSpecification);
if (role == null)
{
_logger.LogError($"No GroupRole. RoleId {roleId}");
return(Result.Fail("no_group_role", "No GroupRole"));
}
List <RoleListData> canAssigneRoles = _groupUserStore.CanAssigneGroupRoles();
if (!canAssigneRoles.Any(x => x.Id == roleId))
{
_logger.LogError($"User can not assign that GroupRole. GroupRoleId {roleId}");
return(Result.Fail("no_permission", "No permission"));
}
return(Result.Ok());
}
public Result Add(string roleId, AddRoleAssignmentRequest addRoleAssignment)
{
ValidationResult validationResult = _addRoleAssignmentValidator.Validate(addRoleAssignment);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid AddRoleAssignmentRequest model");
return(Result.Fail(validationResult.Errors));
}
if (roleId == addRoleAssignment.RoleId)
{
_logger.LogError($"Can not assign Role to itself. RoleId {roleId}");
return(Result.Fail("can_not_assigne_to_itself", "Can not assign Role to itself"));
}
Result roleExist = ValidateRole(roleId);
if (roleExist.Failure)
{
return(Result.Fail(roleExist.Errors));
}
Result canAssigneRoleExist = ValidateRole(addRoleAssignment.RoleId);
if (canAssigneRoleExist.Failure)
{
return(Result.Fail(canAssigneRoleExist.Errors));
}
BaseSpecification <RoleAssignmentEntity> roleAlreadyAssignedSpecification = new BaseSpecification <RoleAssignmentEntity>();
roleAlreadyAssignedSpecification.AddFilter(x => x.RoleId == roleId);
roleAlreadyAssignedSpecification.AddFilter(x => x.CanAssigneRoleId == addRoleAssignment.RoleId);
bool roleAlreadyAssigned = _groupRoleAssignmentRepository.Exist(roleAlreadyAssignedSpecification);
if (roleAlreadyAssigned)
{
_logger.LogError($"Role is already assigned. RoleId {roleId}, CanAssigneRoleId {addRoleAssignment.RoleId}");
return(Result.Fail("role_is_already_assigned", "Role is already assigned"));
}
//TODO: check for recursion loop if we are going to use role assignment recursion
RoleAssignmentEntity roleAssignment = new RoleAssignmentEntity(
roleId: roleId,
canAssigneRoleId: addRoleAssignment.RoleId);
bool addResult = _groupRoleAssignmentRepository.Add(roleAssignment);
if (!addResult)
{
_logger.LogError($"Failed to add GroupRoleAssignment, RoleId {roleId}, CanAssignedRoleId {addRoleAssignment.RoleId}");
return(Result.Fail("failed_to_add_role_assignment", "Failed to add RoleAssignment"));
}
return(Result.Ok());
}
public Core.Models.Result.Result <GroupUserEntity> Get(string userId, string groupId)
{
BaseSpecification <GroupUserEntity> getGroupUserSpecification = new BaseSpecification <GroupUserEntity>();
getGroupUserSpecification.AddFilter(x => x.UserId == userId);
getGroupUserSpecification.AddFilter(x => x.GroupId == groupId);
return(Get(getGroupUserSpecification));
}
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 Result Remove(string roleId, string permissionId)
{
_logger.LogInformation($"Removing PermissionRole. RoleId {roleId}, PermissionId {permissionId}");
BaseSpecification <PermissionRoleEntity> baseSpecification = new BaseSpecification <PermissionRoleEntity>();
baseSpecification.AddFilter(x => x.RoleId == roleId);
baseSpecification.AddFilter(x => x.PermissionId == permissionId);
return(Remove(baseSpecification));
}
public Result Remove(string roleId, string assigneRoleId)
{
_logger.LogInformation($"Removing RoleAssignment. RoleId {roleId}, AssignedRoleId {assigneRoleId}");
BaseSpecification <RoleAssignmentEntity> baseSpecification = new BaseSpecification <RoleAssignmentEntity>();
baseSpecification.AddFilter(x => x.RoleId == roleId);
baseSpecification.AddFilter(x => x.CanAssigneRoleId == assigneRoleId);
return(Remove(baseSpecification));
}
public Result Add(string groupId, AddGroupAttributeRequest addGroupAttribute)
{
ValidationResult validationResult = _addGroupAttributeValidator.Validate(addGroupAttribute);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid {nameof(addGroupAttribute)} modal");
return(Result.Fail(validationResult.Errors));
}
BaseSpecification <GroupEntity> groupExistSpecification = new BaseSpecification <GroupEntity>();
groupExistSpecification.AddFilter(x => x.Id == groupId);
bool groupExist = _groupRepository.Exist(groupExistSpecification);
if (!groupExist)
{
_logger.LogError($"No Group. GroupId {groupId}");
return(Result.Fail("no_group", "No Group"));
}
BaseSpecification <GroupAttributeEntity> keyExistSpecification = new BaseSpecification <GroupAttributeEntity>();
keyExistSpecification.AddFilter(x => x.GroupId == groupId);
keyExistSpecification.AddFilter(x => x.Key.ToUpper() == addGroupAttribute.Key.ToUpper());
bool keyExist = _groupAttributeRepository.Exist(keyExistSpecification);
if (keyExist)
{
_logger.LogError($"GroupAttribute key already exist. GroupId {groupId}, key {addGroupAttribute.Key}");
return(Result.Fail("group_attribute_key_already_exist", "GroupAttribute key already exist"));
}
GroupAttributeEntity groupAttributeEntity = new GroupAttributeEntity(
key: addGroupAttribute.Key,
value: addGroupAttribute.Value,
groupId: groupId);
bool addResult = _groupAttributeRepository.Add(groupAttributeEntity);
if (!addResult)
{
_logger.LogError($"Failed to add GroupAttribute. GroupId {groupId}, Key {addGroupAttribute.Key}");
return(Result.Fail("failed_to_add_group_attribute", "Failed to add group attribute"));
}
return(Result.Ok());
}
public async Task <Result> Add(string userId, AddUserAttributeModel addUserAttribute)
{
ValidationResult validationResult = _addUserAttributeValidator.Validate(addUserAttribute);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid {typeof(AddUserAttributeModel).Name} model");
return(Result.Fail(validationResult.Errors));
}
BaseSpecification <AppUserEntity> userSpecification = new BaseSpecification <AppUserEntity>();
userSpecification.AddFilter(x => x.Id == userId);
bool userExist = await _userRepository.Exist(userSpecification);
if (!userExist)
{
_logger.LogError($"No User. UserId {userId}");
return(Result.Fail("no_user", "No User"));
}
BaseSpecification <UserAttributeEntity> keyAlreadyExistsSpecification = new BaseSpecification <UserAttributeEntity>();
keyAlreadyExistsSpecification.AddFilter(x => x.UserId == userId);
keyAlreadyExistsSpecification.AddFilter(x => x.Key == addUserAttribute.Key);
bool keyAlreadyExists = await _userAttributeRepository.Exist(keyAlreadyExistsSpecification);
if (keyAlreadyExists)
{
_logger.LogError($"Key already exists. UserId {userId}, Key {addUserAttribute.Key}");
return(Result.Fail("key_already_exists", "Key already exists"));
}
UserAttributeEntity userAttribute = new UserAttributeEntity(
key: addUserAttribute.Key,
value: addUserAttribute.Value,
userId: userId);
bool addAttributeResult = await _userAttributeRepository.Add(userAttribute);
if (!addAttributeResult)
{
_logger.LogError($"Failed to add user attribute. UserId {userId}");
return(Result.Fail("failed_to_add_user_attribute", "Failed to add user attribute"));
}
return(Result.Ok(userAttribute));
}
public Result Add(AddGroupRequest addGroup)
{
ValidationResult validationResult = _addGroupValidator.Validate(addGroup);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid AddGroupRequest model");
return(Result.Fail(validationResult.Errors));
}
BaseSpecification <GroupEntity> groupExistSpecification = new BaseSpecification <GroupEntity>();
groupExistSpecification.AddFilter(x => x.Name.ToUpper() == addGroup.Name.ToUpper());
bool groupExist = _groupRepository.Exist(groupExistSpecification);
if (groupExist)
{
_logger.LogError($"Group with the same name already exist");
return(Result.Fail("group_with_name_already_exist", "Group with name already exist"));
}
GroupEntity group = new GroupEntity(
name: addGroup.Name);
bool addResult = _groupRepository.Add(group);
if (!addResult)
{
_logger.LogError($"Failed to add group");
return(Result.Fail("failed_to_add_group", "Failed to add group"));
}
return(Result.Ok());
}
public Result Edit(string id, EditPermissionRequest editPermission)
{
BaseSpecification <PermissionEntity> baseSpecification = new BaseSpecification <PermissionEntity>();
baseSpecification.AddFilter(x => x.Id == id);
PermissionEntity permission = _permissionRepository.SingleOrDefault(baseSpecification);
if (permission == null)
{
_logger.LogError($"No permission. PermissionId {id}");
return(Result.Fail("no_permission", "No Permission"));
}
permission.Update(editPermission.Description);
bool updateResult = _permissionRepository.Update(permission);
if (!updateResult)
{
_logger.LogError($"Failed to update permission. PermissionId {id}");
return(Result.Fail("failed_to_update_permission", "Failed to update permission"));
}
return(Result.Ok());
}
public Result <RoleViewModel> GetRoles(string id)
{
BaseSpecification <AppUserEntity> userSpecification = new BaseSpecification <AppUserEntity>();
userSpecification.AddFilter(x => x.Id == id);
bool existResult = _userRepository.Exist(userSpecification);
if (!existResult)
{
_logger.LogWarning($"No user. UserId {id}");
return(Result.Fail <RoleViewModel>("no_user", "No user"));
}
List <RoleEntity> assignedRoles = _roleRepository.GetAssigned(id);
List <RoleEntity> avaibleRoles = _roleRepository.GetAvailable(id);
RoleViewModel roleViewModel = new RoleViewModel(
assignedRoles: assignedRoles
.Select(x => new RoleViewModel.RoleModel(x.Id, x.Name))
.OrderBy(x => x.Name)
.ToList(),
availableRoles: avaibleRoles
.Select(x => new RoleViewModel.RoleModel(x.Id, x.Name))
.OrderBy(x => x.Name)
.ToList());
return(Result.Ok(roleViewModel));
}
public Result Remove(string id)
{
BaseSpecification <PermissionEntity> baseSpecification = new BaseSpecification <PermissionEntity>();
baseSpecification.AddFilter(x => x.Id == id);
PermissionEntity permission = _permissionRepository.SingleOrDefault(baseSpecification);
if (permission == null)
{
_logger.LogError($"No permission. PermissionId {id}");
return(Result.Fail("no_permission", "No Permission"));
}
_logger.LogInformation($"Removing permission. PermissionId {id}, Name {permission.Name}");
bool updateResult = _permissionRepository.Remove(permission);
if (!updateResult)
{
_logger.LogError($"Failed to remove permission. PermissionId {id}");
return(Result.Fail("failed_to_remove_permission", "Failed to remove permission"));
}
return(Result.Ok());
}
public Result Remove(string id)
{
_logger.LogInformation($"Removing Invite. InviteId {id}");
BaseSpecification <InviteEntity> baseSpecification = new BaseSpecification <InviteEntity>();
baseSpecification.AddFilter(x => x.Id == id);
InviteEntity invite = _inviteRepository.SingleOrDefault(baseSpecification);
if (invite == null)
{
_logger.LogError($"No Invite. InviteId {id}");
return(Result.Fail("no_invite", "No Invite"));
}
bool removeResult = _inviteRepository.Remove(invite);
if (!removeResult)
{
_logger.LogError($"Failed to remove invite. InviteId {id}");
return(Result.Fail("failed_to_remove_invite", "Failed to remove invite"));
}
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> RemoveRole(string userId, string roleId)
{
BaseSpecification <RoleEntity> getRoleSpecification = new BaseSpecification <RoleEntity>();
getRoleSpecification.AddFilter(x => x.Id == roleId);
RoleEntity role = _roleRepository.SingleOrDefault(getRoleSpecification);
if (role == null)
{
_logger.LogError($"No role. RoleId {roleId}");
return(Result.Fail("no_role", "No Role"));
}
switch (role.Type)
{
case Data.Enums.Entity.RoleTypes.Global:
{
return(await RemoveGlobalRole(userId, role.Name));
}
case Data.Enums.Entity.RoleTypes.Group:
{
return(RemoveGroupRole(userId, roleId));
}
default:
{
_logger.LogError($"Invalid Role type. RoleId {roleId}");
return(Result.Fail("invalid_role_type", "Invalid role type"));
}
}
}
public Result Remove(string id)
{
BaseSpecification <RoleEntity> roleSpecification = new BaseSpecification <RoleEntity>();
roleSpecification.AddFilter(x => x.Id == id);
RoleEntity role = _roleRepository.SingleOrDefault(roleSpecification);
if (role == null)
{
_logger.LogError($"No role");
return(Result.Fail("no_role", "No Role"));
}
_logger.LogInformation($"Removing Role. RoleId {id}, Name {role.Name}");
bool removeResult = _roleRepository.Remove(role);
if (!removeResult)
{
_logger.LogError($"Failed to remove Role. RoleId {id}, Name {role.Name}");
return(Result.Fail("failed_to_remove_role", "Failed to remove role"));
}
return(Result.Ok());
}
public async Task <Result> SendEmilVerificationMail(SendEmailVerificationMailRequest request, string adminId)
{
ValidationResult validationResult = _sendEmailVerificationMailValidator.Validate(request);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invlid SendEmailVerificationMailRequest. AdminId {adminId}");
return(Result.Fail(validationResult.Errors));
}
BaseSpecification <AppUserEntity> userSpecification = new BaseSpecification <AppUserEntity>();
userSpecification.AddFilter(x => x.Id == request.UserId);
AppUserEntity appUser = _userRepository.SingleOrDefault(userSpecification);
if (appUser == null)
{
_logger.LogWarning($"No User. UserId {request.UserId}, AdminId {adminId}");
return(Result.Fail("no_user", "No user"));
}
string code = await _userManager.GenerateEmailConfirmationTokenAsync(appUser);
await _emailConfirmationService.SendVerificationMail(appUser, code);
return(Result.Ok());
}
public Result UnlockUser(UnlockUserRequest request, string adminId)
{
ValidationResult validationResult = _unlockUserValidator.Validate(request);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invlid UnlockUserRequest. AdminId {adminId}");
return(Result.Fail(validationResult.Errors));
}
BaseSpecification <AppUserEntity> userSpecification = new BaseSpecification <AppUserEntity>();
userSpecification.AddFilter(x => x.Id == request.UserId);
AppUserEntity appUser = _userRepository.SingleOrDefault(userSpecification);
if (appUser == null)
{
_logger.LogWarning($"No User. UserId {request.UserId}, AdminId {adminId}");
return(Result.Fail("no_user", "No user"));
}
appUser.AccessFailedCount = 0;
appUser.LockoutEnd = null;
bool result = _userRepository.Update(appUser);
if (!result)
{
_logger.LogError($"Faild to unlock user. AdminId {adminId}");
return(Result.Fail("error", "Error"));
}
return(Result.Ok());
}
public async Task <Result <string> > GetProfileImageURL(string userId)
{
string cacheKey = string.Format(URL_CACHE_KEY, userId);
if (_memoryCache.TryGetValue(cacheKey, out string imageUrl))
{
return(Result.Ok(imageUrl));
}
BaseSpecification <UserImageEntity> userImageSpecification = new BaseSpecification <UserImageEntity>();
userImageSpecification.AddFilter(x => x.UserId == userId);
UserImageEntity userImage = await _userImageRepository.SingleOrDefault(userImageSpecification);
if (userImage == null)
{
_logger.LogError($"No profile image. UserId {userId}");
return(Result.Fail <string>("no_profile_image", "No Profile image"));
}
_memoryCache.Set(cacheKey, userImage.URL, IMAGE_IN_CACHE_TIME_SPAN);
return(Result.Ok(userImage.URL));
}
public void OnAuthorization(AuthorizationFilterContext context)
{
IIdentityUIUserInfoService identityUIUserInfoService = context.HttpContext.RequestServices.GetRequiredService <IIdentityUIUserInfoService>();
bool isIdentityAdmin = identityUIUserInfoService.HasPermission(_requirePermission);
if (isIdentityAdmin)
{
return;
}
bool isInRequiredRole = identityUIUserInfoService.HasGroupPermission(_requirePermission);
if (!isInRequiredRole)
{
context.Result = new ForbidResult();
return;
}
bool groupIdExist = context.RouteData.Values.TryGetValue(GROUP_ROUTE_KEY, out object groupIdObj);
if (!groupIdExist)
{
context.Result = new NotFoundResult();
}
string groupId = (string)groupIdObj;
string logedInUserId = context.HttpContext.User.GetUserId();
BaseSpecification <GroupUserEntity> baseSpecification = new BaseSpecification <GroupUserEntity>();
baseSpecification.AddFilter(x => x.UserId == logedInUserId);
baseSpecification.AddFilter(x => x.GroupId == groupId);
baseSpecification.AddFilter(x => x.Role.Permissions.Any(c => c.Permission.Name.ToUpper() == _requirePermission.ToUpper()));
IBaseRepository <GroupUserEntity> groupUserRepository = context.HttpContext.RequestServices.GetService <IBaseRepository <GroupUserEntity> >();
bool groupUserExist = groupUserRepository.Exist(baseSpecification);
if (!groupUserExist)
{
//_logger.LogError($"User does not have permission for group. UserId {logedInUserId}, {groupId}");
context.Result = new ForbidResult();
return;
}
}
public Result Exists(string groupId)
{
BaseSpecification <GroupEntity> baseSpecification = new BaseSpecification <GroupEntity>();
baseSpecification.AddFilter(x => x.Id == groupId);
return(Exists(baseSpecification));
}
private Result <GroupAttributeEntity> Get(string groupId, long id)
{
BaseSpecification <GroupAttributeEntity> baseSpecification = new BaseSpecification <GroupAttributeEntity>();
baseSpecification.AddFilter(x => x.GroupId == groupId);
baseSpecification.AddFilter(x => x.Id == id);
GroupAttributeEntity groupAttribute = _groupAttributeRepository.SingleOrDefault(baseSpecification);
if (groupAttribute == null)
{
_logger.LogError($"No GroupAttribute. GroupId {groupId}, Id {id}");
return(Result.Fail <GroupAttributeEntity>("no_group_attribute", "No GroupAttribute"));
}
return(Result.Ok(groupAttribute));
}
private Result GlobalRoleExists(string globalRoleId)
{
BaseSpecification <RoleEntity> baseSpecification = new BaseSpecification <RoleEntity>();
baseSpecification.AddFilter(x => x.Id == globalRoleId);
baseSpecification.AddFilter(x => x.Type == Data.Enums.Entity.RoleTypes.Global);
bool globalRoleExists = _roleRepository.Exist(baseSpecification);
if (!globalRoleExists)
{
_logger.LogError($"No GlobalRole. RoleId {globalRoleId}");
return(Result.Fail("no_global_role", "No GlobalRole"));
}
return(Result.Ok());
}
public Core.Models.Result.Result <GroupUserEntity> Get(long id)
{
BaseSpecification <GroupUserEntity> getGroupUserSpecification = new BaseSpecification <GroupUserEntity>();
getGroupUserSpecification.AddFilter(x => x.Id == id);
return(Get(getGroupUserSpecification));
}
public Core.Models.Result.Result Exists(long id)
{
BaseSpecification <GroupUserEntity> baseSpecification = new BaseSpecification <GroupUserEntity>();
baseSpecification.AddFilter(x => x.Id == id);
return(Exists(baseSpecification));
}
