private async Task <CommonUtils.Result.Result> AddToGlobalRole(AppUserEntity appUser, string roleId)
{
_logger.LogInformation($"Adding user to global role. UserId {appUser.Id}, RoleId {roleId}");
IBaseSpecification <RoleEntity, RoleEntity> roleSpecification = SpecificationBuilder
.Create <RoleEntity>()
.Where(x => x.Id == roleId)
.Where(x => x.Type == Data.Enums.Entity.RoleTypes.Global)
.Build();
RoleEntity role = await _roleDAO.SingleOrDefault(roleSpecification);
if (role == null)
{
_logger.LogError($"No GlobalRole. RoleId {roleId}");
return(CommonUtils.Result.Result.Fail(ROLE_NO_FOUND));
}
IdentityResult addResult = await _userManager.AddToRoleAsync(appUser, role.Name);
if (!addResult.Succeeded)
{
_logger.LogError($"Failed to add role. UserId {appUser.Id}, RoleId {roleId}");
return(CommonUtils.Result.Result.Fail(FAILED_TO_ADD_ROLE));
}
return(CommonUtils.Result.Result.Ok());
}
public async Task <Result> Remove(string userId)
{
IBaseSpecification <UserImageEntity, UserImageEntity> specification = SpecificationBuilder
.Create <UserImageEntity>()
.Where(x => x.UserId == userId)
.Select(x => new UserImageEntity(
x.Id))
.Build();
UserImageEntity userImage = await _userImageDAO.SingleOrDefault(specification);
if (userImage == null)
{
_logger.LogWarning($"User does not have a profile image. UserId {userId}");
return(Result.Ok());
}
bool removeResult = await _userImageDAO.Remove(userImage);
if (!removeResult)
{
_logger.LogError($"Failed to remove user image");
return(Result.Fail(FAILED_TO_REMOVE_USER_IMAGE));
}
return(Result.Ok());
}
public static IQueryable <TEntity> GetQuery(IQueryable <TEntity> inputQuery, IBaseSpecification <TEntity> spec)
{
var query = inputQuery;
// if(spec.Filter != null)
// {
// query = query.Where(spec.Filter);
// }
// !!!!!!!! FILTERS QUERIES MUST BE BEFORE PAGING !!!!!!!!!!!!
query = spec.Filters.Aggregate(query, (current, filter) => current.Where(filter));
if (spec.OrderBy != null)
{
query = query.OrderBy(spec.OrderBy);
}
if (spec.OrderByDescending != null)
{
query = query.OrderByDescending(spec.OrderByDescending);
}
if (spec.IsPagingEnabled)
{
query = query.Skip(spec.Skip).Take(spec.Take);
}
query = spec.Includes.Aggregate(query, (current, include) => current.Include(include));
return(query);
}
private async Task <Result> AddAdminRole(string userId, string groupId)
{
IBaseSpecification <RoleEntity, RoleEntity> getGroupAdminRoleSpecification = SpecificationBuilder
.Create <RoleEntity>()
.Where(x => x.Type == Data.Enums.Entity.RoleTypes.Group)
.WithName(IdentityUIRoles.GROUP_ADMIN)
.Build();
RoleEntity role = await _roleDAO.SingleOrDefault(getGroupAdminRoleSpecification);
if (role == null)
{
_logger.LogError($"GroupAdmin role not found. RoleName {IdentityUIRoles.GROUP_ADMIN}");
return(Result.Fail(ROLE_NOT_FOUND));
}
Result result = await _groupUserService.AddUserToGroupWithValidation(userId, groupId, role.Id);
if (result.Failure)
{
return(Result.Fail(result));
}
return(Result.Ok());
}
public virtual bool Exist(IBaseSpecification <TEntity> specification)
{
return(_context
.Set <TEntity>()
.ApplayBaseSpecification(specification)
.Any());
}
public async Task <Result <AuditAdminDetailsModel> > Get(long id)
{
IBaseSpecification <AuditEntity, AuditAdminDetailsModel> selectSpecification = SpecificationBuilder
.Create <AuditEntity>()
.Where(x => x.Id == id)
.Select(x => new AuditAdminDetailsModel(
x.Id,
x.ActionType.GetDescription(),
x.ObjectType,
x.ObjectIdentifier,
x.ObjectMetadata,
x.SubjectType.GetDescription(),
x.SubjectIdentifier,
x.SubjectMetadata,
x.GroupIdentifier,
x.Host,
x.RemoteIp,
x.ResourceName,
x.UserAgent,
x.TraceIdentifier,
x.AppVersion,
x.Metadata,
x.Created.ToString("o")))
.Build();
AuditAdminDetailsModel auditDetailsModel = await _auditDAO.SingleOrDefault(selectSpecification);
if (auditDetailsModel == null)
{
_logger.LogError($"No audit. AuditId {id}.");
return(Result.Fail <AuditAdminDetailsModel>("no_audit", "No Audit"));
}
return(Result.Ok(auditDetailsModel));
}
public async Task <Result <AuditDetailsModel> > Get(long id)
{
string userId = _httpContextAccessor.HttpContext.User.GetUserId();
IBaseSpecification <AuditEntity, AuditDetailsModel> selectSpecification = SpecificationBuilder
.Create <AuditEntity>()
.Where(x => x.Id == id)
.WithUser(userId)
.Select(x => new AuditDetailsModel(
x.Id,
x.ActionType.GetDescription(),
x.Created.ToString("o"),
x.ResourceName,
x.ObjectMetadata))
.Build();
AuditDetailsModel auditDetailsModal = await _auditDAO.SingleOrDefault(selectSpecification);
if (auditDetailsModal == null)
{
_logger.LogError($"No audit. AuditId {id}, UserId {userId}");
return(Result.Fail <AuditDetailsModel>("no_audit", "No Audit"));
}
return(Result.Ok(auditDetailsModal));
}
public static IQueryable <T> GetQuery(IQueryable <T> inputQuery, IBaseSpecification <T> spec)
{
var query = inputQuery;
if (spec.Criteria != null)
{
query = query.Where(spec.Criteria);
}
query = spec.Includes.Aggregate(query, (current, include) => current.Include(include));
if (spec.OrderBy != null)
{
query = query.OrderBy(spec.OrderBy);
}
if (spec.OrderByDescending != null)
{
query = query.OrderByDescending(spec.OrderByDescending);
}
if (spec.IsPagingEnabled)
{
query = query.Skip(spec.Skip).Take(spec.Take);
}
return(query);
}
public virtual TEntity Get(IBaseSpecification <TEntity> specification)
{
return(_context
.Set <TEntity>()
.ApplayBaseSpecification(specification)
.FirstOrDefault());
}
public async Task <Result <DataTableResult <AuditAdminTableModel> > > Get(DataTableRequest dataTableRequest, AuditTableRequest auditTableRequest)
{
ValidationResult dataTableValidationResult = _dataTableRequestValidator.Validate(dataTableRequest);
if (!dataTableValidationResult.IsValid)
{
_logger.LogWarning($"Invalid {nameof(DataTableRequest)} model");
return(Result.Fail <DataTableResult <AuditAdminTableModel> >(dataTableValidationResult.ToResultError()));
}
if (auditTableRequest == null)
{
_logger.LogWarning($"AuditTable request can not be null");
return(Result.Fail <DataTableResult <AuditAdminTableModel> >("can_not_be_null", "Can not be null"));
}
ValidationResult auditTableRequestValidationResult = _auditTableRequestValidator.Validate(auditTableRequest);
if (!auditTableRequestValidationResult.IsValid)
{
_logger.LogWarning($"Invalid {nameof(AuditTableRequest)} model");
return(Result.Fail <DataTableResult <AuditAdminTableModel> >(auditTableRequestValidationResult.ToResultError()));
}
IBaseSpecificationBuilder <AuditEntity> baseSpecification = SpecificationBuilder
.Create <AuditEntity>()
.WithActionType(auditTableRequest.ActionType)
.WithObjectType(auditTableRequest.ObjectType)
.WithObjectIdentifier(auditTableRequest.ObjectIdentifier)
.WithSubjectType(auditTableRequest.SubjectType)
.WithSubjectIdentifier(auditTableRequest.SubjectIdentifier)
.WithResourceName(auditTableRequest.ResourceName)
.InRange(auditTableRequest.From, auditTableRequest.To);
IBaseSpecification <AuditEntity, AuditAdminTableModel> selectSpecification = baseSpecification
.OrderBy(x => x.Created, auditTableRequest.OrderBy.Value)
.Paginate(dataTableRequest.Start, dataTableRequest.Length)
.Select(x => new AuditAdminTableModel(
x.Id,
x.ActionType.GetDescription(),
x.ObjectType,
x.ResourceName,
x.SubjectType.GetDescription(),
x.SubjectIdentifier,
x.Created.ToString("o")))
.Build();
int auditCount = await _auditDAO.Count(baseSpecification.Build());
List <AuditAdminTableModel> audits = await _auditDAO.Get(selectSpecification);
DataTableResult <AuditAdminTableModel> dataTableResult = new DataTableResult <AuditAdminTableModel>(
draw: dataTableRequest.Draw,
recordsTotal: auditCount,
recordsFiltered: auditCount,
error: null,
data: audits);
return(Result.Ok(dataTableResult));
}
public Task <TValue> Min <TValue>(IBaseSpecification <TEntity, TValue> baseSpecification)
{
return(_dbContext
.Set <TEntity>()
.ApplyBaseSpecification(baseSpecification)
.MinAsync());
}
public Task <TData> FirstOrDefault <TData>(IBaseSpecification <TEntity, TData> baseSpecification)
{
return(_dbContext
.Set <TEntity>()
.ApplyBaseSpecification(baseSpecification)
.FirstOrDefaultAsync());
}
public virtual async Task <Result> ValidateUser(string id)
{
IBaseSpecification <AppUserEntity, AppUserEntity> userExistsSpecification = SpecificationBuilder
.Create <AppUserEntity>()
.WithId(id)
.Build();
bool userExist = await _userDAO.Exist(userExistsSpecification);
if (!userExist)
{
_logger.LogError($"No user. UserId {id}");
return(Result.Fail(USER_NOT_FOUND));
}
IBaseSpecification <GroupUserEntity, GroupUserEntity> userAlreadyInGroupSpecification = SpecificationBuilder
.Create <GroupUserEntity>()
.Where(x => x.UserId == id)
.Build();
bool userAlreadyInGroup = await _groupUserDAO.Exist(userAlreadyInGroupSpecification);
if (userAlreadyInGroup)
{
_logger.LogError($"User is already in a group. UserId {id}");
return(Result.Fail(USER_IS_ALREADY_IN_GROUP));
}
return(Result.Ok());
}
public Task <bool> Exist <TData>(IBaseSpecification <TEntity, TData> baseSpecification)
{
return(_dbContext
.Set <TEntity>()
.ApplyBaseSpecification(baseSpecification)
.AnyAsync());
}
public virtual Task <int> Count <TData>(IBaseSpecification <TEntity, TData> baseSpecification)
{
return(_dbContext
.Set <TEntity>()
.ApplyBaseSpecification(baseSpecification)
.CountAsync());
}
public async Task <Result <Select2Result <Select2ItemBase> > > GetAvailableUsers(Select2Request select2Request)
{
ValidationResult validationResult = _select2Validator.Validate(select2Request);
if (!validationResult.IsValid)
{
_logger.LogWarning($"Invalid {nameof(Select2Request)} model");
return(Result.Fail <Select2Result <Select2ItemBase> >(validationResult.ToResultError()));
}
IBaseSpecification <AppUserEntity, Select2ItemBase> specification = SpecificationBuilder
.Create <AppUserEntity>()
.Where(x => x.Groups.Count == 0)
.SearchByUsername(select2Request.Term)
.Select(x => new Select2ItemBase(
x.Id,
x.UserName))
.Build();
List <Select2ItemBase> users = await _appUserDAO.Get(specification);
Select2Result <Select2ItemBase> select2Result = new Select2Result <Select2ItemBase>(
results: users);
return(Result.Ok(select2Result));
}
public async Task <Result> RemoveUser(string userId)
{
_logger.LogInformation($"Removing user. UserId {userId}");
IBaseSpecification <AppUserEntity, AppUserEntity> getUserSpecification = SpecificationBuilder
.Create <AppUserEntity>()
.Where(x => x.Id == userId)
.Build();
AppUserEntity appUser = await _userDAO.SingleOrDefault(getUserSpecification);
if (appUser == null)
{
_logger.LogWarning($"No User. UserId {userId}");
return(Result.Fail(USER_NOT_FOUND));
}
Result removeUserImageResult = await _profileImageService.Remove(userId);
if (removeUserImageResult.Failure)
{
return(Result.Fail(removeUserImageResult));
}
appUser.FirstName = null;
appUser.LastName = null;
Guid guid = Guid.NewGuid();
appUser.Email = $"deleted_email_{guid}";
appUser.UserName = $"deleted_username_{guid}";
appUser.SecurityStamp = Guid.NewGuid().ToString();
#if NET_CORE2
appUser.NormalizedEmail = _userManager.NormalizeKey(appUser.Email);
appUser.NormalizedEmail = _userManager.NormalizeKey(appUser.UserName);
#elif NET_CORE3
appUser.NormalizedEmail = _userManager.NormalizeEmail(appUser.Email);
appUser.NormalizedUserName = _userManager.NormalizeName(appUser.UserName);
#endif
bool updateResult = await _userDAO.Update(appUser);
if (!updateResult)
{
_logger.LogError($"Failed to update user. UserId {userId}");
return(Result.Fail(FAILED_TO_UPDATE_USER));
}
bool removeResult = _userRepository.Remove(appUser);
if (!removeResult)
{
_logger.LogError($"Failed to remove user. UserId {userId}");
return(Result.Fail(FAILED_TO_REMOVE_USER));
}
_logger.LogInformation($"User was removed. UserId {userId}");
return(Result.Ok());
}
public async Task <Core.Models.Result.Result <string> > GetProfileImageURL(string userId)
{
string cacheKey = string.Format(URL_CACHE_KEY, userId);
if (_memoryCache.TryGetValue(cacheKey, out string imageUrl))
{
return(Result.Ok <string>(imageUrl).ToOldResult());
}
IBaseSpecification <UserImageEntity, UserImageEntity> getUserImageSpecification = SpecificationBuilder
.Create <UserImageEntity>()
.Where(x => x.UserId == userId)
.Build();
UserImageEntity userImage = await _userImageDAO.SingleOrDefault(getUserImageSpecification);
if (userImage == null)
{
_logger.LogError($"No profile image. UserId {userId}");
return(Result.Fail <string>(PROFILE_IMAGE_NOT_FOUND).ToOldResult());
}
_memoryCache.Set(cacheKey, userImage.URL, IMAGE_IN_CACHE_TIME_SPAN);
return(Result.Ok <string>(userImage.URL).ToOldResult());
}
public Task <bool> Exist(IBaseSpecification <TEntity> specification)
{
return(_context
.Set <TEntity>()
.ApplayBaseSpecification(specification)
.AnyAsync());
}
public TEntity SingleOrDefault(IBaseSpecification <TEntity> specification)
{
return(_context
.Set <TEntity>()
.AsNoTracking()
.ApplayBaseSpecification(specification)
.SingleOrDefault());
}
public virtual Task <TData> SingleOrDefault <TData>(IBaseSpecification <TEntity, TData> baseSpecification)
{
return(_dbContext
.Set <TEntity>()
.AsNoTracking()
.ApplyBaseSpecification(baseSpecification)
.SingleOrDefaultAsync());
}
public virtual Task <List <TData> > Get <TData>(IBaseSpecification <TEntity, TData> baseSpecification)
{
return(_dbContext
.Set <TEntity>()
.AsNoTracking()
.ApplyBaseSpecification(baseSpecification)
.ToListAsync());
}
public Task <TEntity> FirstOrDefault(IBaseSpecification <TEntity> specification)
{
return(_context
.Set <TEntity>()
.AsNoTracking()
.ApplayBaseSpecification(specification)
.FirstOrDefaultAsync());
}
public Task <Result> Any(string id)
{
IBaseSpecification <GroupEntity, GroupEntity> specification = SpecificationBuilder
.Create <GroupEntity>()
.WithId(id)
.Build();
return(Any(specification));
}
public void DeleteForced(IBaseSpecification <TEntity> spec)
{
var list = BuildQuery(spec).ToList();
if (list.IsNotNullOrEmpty())
{
DbContext.RemoveRange(list);
}
}
public void Delete(IBaseSpecification <TEntity> spec)
{
var list = BuildQuery(spec).ToList();
foreach (var current in list)
{
Delete(current);
}
}
public Task <TValue> Min <TValue>(IBaseSpecification <TEntity, TValue> baseSpecification)
{
TValue result = _entities
.AsQueryable()
.ApplyBaseSpecification(baseSpecification)
.Min();
return(Task.FromResult(result));
}
public async Task <Result <List <TimeRangeStatisticsModel> > > GetRegistrationStatistics(string groupId, TimeRangeRequest timeRangeRequest)
{
ValidationResult validationResult = _timeRangeRequestValidator.Validate(timeRangeRequest);
if (!validationResult.IsValid)
{
_logger.LogError($"Invalid {typeof(TimeRangeRequest).Name} model");
return(Result.Fail <List <TimeRangeStatisticsModel> >(validationResult.ToResultError()));
}
IBaseSpecification <GroupUserEntity, DateTimeOffset> specification = SpecificationBuilder
.Create <GroupUserEntity>()
.Where(x => x.User._CreatedDate != null)
.Where(x => x.User._CreatedDate >= timeRangeRequest.From)
.Where(x => x.User._CreatedDate < timeRangeRequest.To)
.Where(x => x.GroupId == groupId)
.Select(x => x.User._CreatedDate.Value)
.Build();
List <DateTimeOffset> dateTimes = await _groupUserStore.Get(specification);
List <TimeRangeStatisticsModel> viewModel = dateTimes
.GroupBy(x => new { x.UtcDateTime.Year, x.UtcDateTime.Month, x.UtcDateTime.Day })
.Select(x => new TimeRangeStatisticsModel(
dateTime: new DateTime(x.Key.Year, x.Key.Month, x.Key.Day, 0, 0, 0, DateTimeKind.Utc),
value: x.Count()))
.ToList();
DateTime dateTime = new DateTime(
timeRangeRequest.From.UtcDateTime.Year,
timeRangeRequest.From.UtcDateTime.Month,
timeRangeRequest.From.UtcDateTime.Day,
0,
0,
0,
DateTimeKind.Utc);
for (; dateTime < timeRangeRequest.To; dateTime = dateTime.AddDays(1))
{
bool exists = viewModel
.Where(x => x.DateTime == dateTime)
.Any();
if (!exists)
{
viewModel.Add(new TimeRangeStatisticsModel(
dateTime: dateTime,
value: 0));
}
}
viewModel = viewModel
.OrderBy(x => x.DateTime)
.ToList();
return(Result.Ok(viewModel));
}
public Task <Result> Any(long id)
{
IBaseSpecification <GroupUserEntity, GroupUserEntity> specification = SpecificationBuilder
.Create <GroupUserEntity>()
.Where(x => x.Id == id)
.Build();
return(Any(specification));
}
public Task <List <TData> > Get <TData>(IBaseSpecification <TEntity, TData> baseSpecification)
{
List <TData> result = _entities
.AsQueryable()
.ApplyBaseSpecification(baseSpecification)
.ToList();
return(Task.FromResult(result));
}
