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)); }