コード例 #1
0
        public async Task <SupplierAttributeGetPagedListResponse> GetPagedListAsync(
            Guid accountId,
            SupplierAttributeGetPagedListRequest request,
            CancellationToken ct)
        {
            var attributes = _storage.SupplierAttributes
                             .AsNoTracking()
                             .Where(x =>
                                    x.AccountId == accountId &&
                                    (request.Types == null || !request.Types.Any() || request.Types.Contains(x.Type)) &&
                                    (request.Key.IsEmpty() || EF.Functions.ILike(x.Key, $"{request.Key}%")) &&
                                    (!request.IsDeleted.HasValue || x.IsDeleted == request.IsDeleted) &&
                                    (!request.MinCreateDate.HasValue || x.CreateDateTime >= request.MinCreateDate) &&
                                    (!request.MaxCreateDate.HasValue || x.CreateDateTime <= request.MaxCreateDate) &&
                                    (!request.MinModifyDate.HasValue || x.ModifyDateTime >= request.MinModifyDate) &&
                                    (!request.MaxModifyDate.HasValue || x.ModifyDateTime <= request.MaxModifyDate));

            return(new SupplierAttributeGetPagedListResponse
            {
                TotalCount = await attributes
                             .CountAsync(ct),
                LastModifyDateTime = await attributes
                                     .MaxAsync(x => x != null?x.ModifyDateTime ?? x.CreateDateTime : (DateTime?)null, ct),
                Attributes = await attributes
                             .SortBy(request.SortBy, request.OrderBy)
                             .Skip(request.Offset)
                             .Take(request.Limit)
                             .ToListAsync(ct)
            });
        }
コード例 #2
0
        public async Task WhenGetPagedList_ThenSuccess()
        {
            var headers = await _defaultRequestHeadersService.GetAsync();

            var key = "Test".WithGuid();
            await Task.WhenAll(
                _create.SupplierAttribute
                .WithType(AttributeType.Text)
                .WithKey(key)
                .BuildAsync());

            var filterTypes = new List <AttributeType> {
                AttributeType.Text
            };

            var request = new SupplierAttributeGetPagedListRequest
            {
                Key   = key,
                Types = filterTypes
            };

            var response = await _supplierAttributesClient.GetPagedListAsync(request, headers);

            var results = response.Attributes
                          .Skip(1)
                          .Zip(response.Attributes, (previous, current) => current.CreateDateTime >= previous.CreateDateTime);

            Assert.NotEmpty(response.Attributes);
            Assert.All(results, Assert.True);
        }
コード例 #3
0
 public Task <SupplierAttributeGetPagedListResponse> GetPagedListAsync(
     SupplierAttributeGetPagedListRequest request,
     Dictionary <string, string> headers = default,
     CancellationToken ct = default)
 {
     return(_factory.PostAsync <SupplierAttributeGetPagedListResponse>(
                _host + "/Suppliers/Attributes/v1/GetPagedList", null, request, headers, ct));
 }
コード例 #4
0
        public async Task <ActionResult <SupplierAttributeGetPagedListResponse> > GetPagedList(
            SupplierAttributeGetPagedListRequest request,
            CancellationToken ct = default)
        {
            var response = await _supplierAttributesService.GetPagedListAsync(_userContext.AccountId, request, ct);

            return(ReturnIfAllowed(
                       response,
                       Roles.Suppliers,
                       response.Attributes.Select(x => x.AccountId)));
        }