コード例 #1
0
        public async Task RunAsync()
        {
            await foreach (var documentCollectionItem in _documentCollectionRepository.GetAllItemsAsync())
            {
                var query = new  ApiQueryRequest
                {
                    Filter = $"{common.ImageIds}~{All}~{documentCollectionItem.Id}"
                };

                var count = await _animalRepository.GetCountAsync(query.ToDbQuery());

                if (count == 0)
                {
                    count = await _articleRepository.GetCountAsync(query.ToDbQuery());
                }

                if (count == 0)
                {
                    foreach (var fileId in documentCollectionItem.TypeNameToDocumentId.Values)
                    {
                        await _bucket.RemoveFileAsync(fileId);

                        _logger.LogInformation($"Deleted file from 'bucket' with id: {fileId}");
                    }

                    await _documentCollectionRepository.DeleteAsync(documentCollectionItem.Id);

                    _logger.LogInformation($"Deleted item from 'document collection' with id: {documentCollectionItem.Id}");
                }
            }
        }
コード例 #2
0
        public async Task <ActionResult <CollectionApiResponse <RecipeShortModel> > > GetRecipesAsync(
            [FromQuery] ApiQueryRequest request)
        {
            var result = await Mediator.Send(new GetRecipeListCommand { Request = request });

            return(Ok(result));
        }
コード例 #3
0
        protected async Task<ActionResult<CollectionSegmentApiResponse<TResponse>>> GetCollectionAsync<TCollectin, TResponse>(
            IBlCollectinQueryAsync<TCollectin> service,
            ApiQueryRequest queryRequest,
            IMapper mapper)
            where TResponse : class
        {
            BlCollectonResponse<TCollectin> serviceResponse = await service.GetAsync(queryRequest);
            List<TResponse> result = mapper.Map<List<TCollectin>, List<TResponse>>(serviceResponse.Collection);

            return Collection(result, serviceResponse.TotalCount, queryRequest.Page, queryRequest.Size);
        }
コード例 #4
0
        public async Task <BlCollectonResponse <TEntityDto> > GetAsync(ApiQueryRequest queryRequest)
        {
            var dbQuery = queryRequest.ToDbQuery();
            var count   = await _repository.GetCountAsync(dbQuery);

            List <TEntityDto> itemDtos = await GetCollectionAsync(count, dbQuery);

            return(new BlCollectonResponse <TEntityDto>
            {
                Collection = itemDtos,
                TotalCount = count
            });
        }
コード例 #5
0
        public static DbQuery ToDbQuery(this ApiQueryRequest apiQueryRequest)
        {
            var isNotDeletedExpr = $"{baseItem.IsDeleted}~{StrictFilterContractConstants.Eq}~'false'";
            var filter           = string.IsNullOrWhiteSpace(apiQueryRequest.Filter)
                ? isNotDeletedExpr
                : $"{isNotDeletedExpr};{apiQueryRequest.Filter}";

            return(new DbQuery
            {
                Filter = filter,
                Page = apiQueryRequest.Page,
                Size = apiQueryRequest.Size,
                Sort = apiQueryRequest.Sort
            });
        }
コード例 #6
0
        public async Task <BlCollectonResponse <RequestDto> > GetAsync(ApiQueryRequest queryRequest, ICollection <Claim> roles)
        {
            var initStatuses = GetQueryStatuses(queryRequest.Filter, $"status.id~{StrictFilterContractConstants.Eq}~");

            var dbQuery = queryRequest.ToDbQuery();
            var isAdmin = IsRoleAdmin(roles);

            if (!isAdmin)
            {
                List <string> requestStatuses = GetRequestStatuses(roles, actions.Get);

                foreach (var initStatus in initStatuses)
                {
                    var isContain = requestStatuses.Contains(initStatus);
                    if (!isContain)
                    {
                        throw new ForbiddenOperationRequestException(_messageForbiddenFields);
                    }
                }

                string filterExpr = string.Empty;
                if (requestStatuses.Count > 0)
                {
                    filterExpr     = string.Join("OR", requestStatuses.Select(x => @"{status.id~" + StrictFilterContractConstants.Eq + "~'" + x + "'}").ToList());
                    dbQuery.Filter = filterExpr;
                }
                else
                {
                    throw new ForbiddenOperationRequestException(_messageMissingRole);
                }
            }

            var count = await _repository.GetCountAsync(dbQuery);

            var filteredByRoleItems = await GetCollectionAsync(count, dbQuery);

            return(new BlCollectonResponse <RequestDto>
            {
                Collection = filteredByRoleItems,
                TotalCount = count
            });
        }
コード例 #7
0
        private async Task <CollectionApiResponse <RecipeShortModel> > GetRecipeShortModels(
            ApiQueryRequest request,
            CancellationToken cancellationToken)
        {
            var parentId = request.ParentId?.ToString();

            var page = await _applicationDbContext.Set <Recipe>()
                       .Where(x => x.ParentId == parentId)
                       .OrderBy(x => x.Title)
                       .Select(x => new RecipeShortModel
            {
                Id        = x.Id,
                ParentId  = x.ParentId,
                Title     = x.Title,
                CreatedAt = x.CreatedAt
            })
                       .GetPageAsync(request, cancellationToken);

            return(page);
        }
コード例 #8
0
        public async Task <int> GetCountAsync(ApiQueryRequest query)
        {
            var dbQuery = query.ToDbQuery();

            return(await _repository.GetCountAsync(dbQuery));
        }
コード例 #9
0
 public static async Task <CollectionApiResponse <T> > GetPageAsync <T>(this IQueryable <T> source, ApiQueryRequest request,
                                                                        CancellationToken cancellationToken)
 {
     return(await GetPageAsync(source, request.Page, request.Size, cancellationToken));
 }
コード例 #10
0
        public async Task <ActionResult <CollectionSegmentApiResponse <RequestModel> > > GetAsync([FromQuery] ApiQueryRequest queryRequest)
        {
            var roles           = GetUserRoles();
            var serviceResponse = await _requestService.GetAsync(queryRequest, roles);

            List <RequestModel> result = _mapper.Map <List <RequestDto>, List <RequestModel> >(serviceResponse.Collection);

            return(Collection(result, serviceResponse.TotalCount, queryRequest.Page, queryRequest.Size));
        }
コード例 #11
0
 public async Task <BlCollectonResponse <RequestDto> > GetAsync(ApiQueryRequest queryRequest, ICollection <Claim> roles) => await requestService.GetAsync(queryRequest, roles);
コード例 #12
0
 public async Task <ActionResult <CollectionSegmentApiResponse <FinancialReportModel> > > GetAsync([FromQuery] ApiQueryRequest queryRequest)
 {
     return(await GetCollectionAsync <FinancialReportDto, FinancialReportModel>(_financialReportService, queryRequest, _mapper));
 }
コード例 #13
0
 public async Task <BlCollectonResponse <TOut> > GetAsync(ApiQueryRequest query) => await fullCrudService.GetAsync(query);
コード例 #14
0
 public async Task <ActionResult <CollectionSegmentApiResponse <TagModel> > > GetAsync([FromQuery] ApiQueryRequest queryRequest)
 {
     return(await GetCollectionAsync <TagDto, TagModel>(_tagService, queryRequest, _mapper));
 }
コード例 #15
0
        public virtual async Task <BlCollectonResponse <GetUsersManagementViewModel> > GetAsync(ApiQueryRequest queryRequest)
        {
            var dbQuery = queryRequest.ToDbQuery();

            var users = await _userRepository.GetAsync(dbQuery);

            var totalNumberOf = await _userRepository.GetCountAsync(dbQuery);

            var userCollection = _mapper.Map <IEnumerable <ApplicationUser>, List <GetUsersManagementViewModel> >(users);

            foreach (var userModel in userCollection)
            {
                var identityUser = users.SingleOrDefault(x => x.Id == userModel.UserId);
                userModel.Roles.AddRange(await _userManager.GetRolesAsync(identityUser));
            }

            return(new BlCollectonResponse <GetUsersManagementViewModel>
            {
                Collection = userCollection, TotalCount = totalNumberOf
            });
        }
コード例 #16
0
 public async Task <ActionResult <List <FinancialReportByYearDto> > > GetYearsAsync([FromQuery] ApiQueryRequest queryRequest)
 {
     return(Item(await _financialReportService.GetReportsByYearsAsync()));
 }
コード例 #17
0
        public async Task <BlCollectonResponse <GetDocumentsOrganizationViewItem> > GetAsync(ApiQueryRequest queryRequest)
        {
            var dbQuery = queryRequest.ToDbQuery();
            var files   = await _orgDocRepository.GetAsync(dbQuery);

            var totalNumberOf = await _orgDocRepository.GetCountAsync(dbQuery);

            var result = files.Select(x => new GetDocumentsOrganizationViewItem
            {
                Id       = x.BucketId,
                FileName = x.Name
            }).ToList();

            return(new BlCollectonResponse <GetDocumentsOrganizationViewItem>
            {
                Collection = result, TotalCount = totalNumberOf
            });
        }
コード例 #18
0
        GetDocuments([FromQuery] ApiQueryRequest queryRequest)
        {
            var source = await _organizationDocumentsService.GetAsync(queryRequest);

            return(Collection(source.Collection, source.TotalCount, queryRequest.Page, queryRequest.Size));
        }
コード例 #19
0
 public async Task <ActionResult <CollectionSegmentApiResponse <HistoryModel> > > GetAsync([FromQuery] ApiQueryRequest queryRequest)
 {
     return(await GetCollectionAsync <HistoryDto, HistoryModel>(service, queryRequest, mapper));
 }
コード例 #20
0
        public async Task <ActionResult <CollectionSegmentApiResponse <GetUsersManagementViewModel> > > GetAsync([FromQuery] ApiQueryRequest queryParams)
        {
            var source = await _usersManagementService.GetAsync(queryParams);

            return(Collection(source.Collection, source.TotalCount, queryParams.Page, queryParams.Size));
        }
コード例 #21
0
 public async Task <int> GetCountAsync(ApiQueryRequest query) => await fullCrudService.GetCountAsync(query);
コード例 #22
0
 public async Task <ActionResult <CollectionSegmentApiResponse <VacancyModel> > > GetAsync([FromQuery] ApiQueryRequest queryRequest)
 {
     return(await GetCollectionAsync <VacancyDto, VacancyModel>(_vacancyService, queryRequest, _mapper));
 }