public static PagedResult <TResult> Select <TSource, TResult>(this PagedResult <TSource> result,
Func <TSource, TResult> selector)
{
var mappedResults = result.Items.Select(selector);
return(PagedResult <TResult> .From(result, mappedResults));
}
public async Task return_one_item_when_result_contains_one_item()
{
//Arrange
var products = new List <Product>
{
new Product(_guid, "", "", 1, _guid)
};
var pagedResultBaseMock = new PagedResultBaseMock();
var pageProducts = PagedResult <Product> .From(pagedResultBaseMock, products);
_productRepository.Setup(r => r.BrowseAsync(_query)).ReturnsAsync(pageProducts);
//Act
var handler = new BrowseProductHandler(_productRepository.Object, _logger.Object);
var result = await handler.HandleAsync(_query);
var productList = new List <Product>();
foreach (var product in result.Items)
{
productList.Add(new Product(product.Id, product.Name, product.Description, product.Price, product.CategoryId));
}
//Assert
Assert.NotNull(result);
Assert.Equal(products.Count, productList.Count);
Assert.Equal(products[0].Name, productList[0].Name);
Assert.Equal(products[0].Id, productList[0].Id);
Assert.Equal(products[0].Description, productList[0].Description);
Assert.Equal(products[0].Price, productList[0].Price);
Assert.Equal(products[0].CategoryId, productList[0].CategoryId);
}
public async Task <PagedDto <StoryDto> > HandleAsync(BrowseStories query)
{
var now = query.Now.ToUnixTimeMilliseconds();
var documents = _database.GetCollection <StoryDocument>("stories")
.AsQueryable()
.Where(x => x.From <= now && x.To >= now);
var input = query.Query;
if (!string.IsNullOrWhiteSpace(input))
{
documents = documents.Where(x =>
x.Title.Contains(input) || x.Author.Name.Contains(input) || x.Tags.Contains(input));
}
var result = await documents.OrderByDescending(x => x.CreatedAt).PaginateAsync(query);
var storyIds = result.Items.Select(x => x.Id);
var rates = await _database.GetCollection <StoryRatingDocument>("ratings")
.AsQueryable()
.Where(x => storyIds.Contains(x.StoryId))
.ToListAsync();
var pagedResult = PagedResult <StoryDto> .From(result, result.Items.Select(x => x.ToDto(rates)));
return(new PagedDto <StoryDto>
{
CurrentPage = pagedResult.CurrentPage,
TotalPages = pagedResult.TotalPages,
ResultsPerPage = pagedResult.ResultsPerPage,
TotalResults = pagedResult.TotalResults,
Items = pagedResult.Items
});
}
public async Task return_one_item_when_result_contains_one_item()
{
//Arrange
var productCategories = new List <ProductCategory> {
_productCategory
};
var pagedResultBaseMock = new PagedResultBaseMock();
var pageProductCategories = PagedResult <ProductCategory> .From(pagedResultBaseMock, productCategories);
_productCategoryRepository.Setup(r => r.BrowseAsync(_query)).ReturnsAsync(pageProductCategories);
//Act
var handler = new BrowseProductCategoryHandler(_productCategoryRepository.Object, _logger.Object);
var result = await handler.HandleAsync(_query);
var productCategoryList = new List <ProductCategory>();
foreach (var productCategory in result.Items)
{
productCategoryList.Add(new ProductCategory(productCategory.Id, productCategory.Name));
}
//Assert
Assert.NotNull(result);
Assert.Equal(productCategories.Count, productCategoryList.Count);
Assert.Equal(productCategories[0].Name, productCategoryList[0].Name);
Assert.Equal(productCategories[0].Id, productCategoryList[0].Id);
}
public async Task <PagedResult <WardenCheckResultDto> > BrowseChecksAsync(BrowseWardenCheckResults query)
{
var iterations = await _database.WardenIterations().Query(new BrowseWardenIterations
{
OrganizationId = query.OrganizationId,
WardenName = query.WardenName,
WatcherName = query.WatcherName,
Page = query.Page,
Results = query.Results
}).PaginateAsync(query);
var checkResults = new List <WardenCheckResultDto>();
foreach (var iteration in iterations.Items)
{
var checks = iteration.Results.Where(r =>
r.WatcherCheckResult.Watcher.Name.EqualsCaseInvariant(query.WatcherName))
.Select(x => new WardenCheckResultDto(x)
{
IterationId = iteration.Id
});
checkResults.AddRange(checks);
}
return(PagedResult <WardenCheckResultDto> .From(iterations, checkResults));
}
public async Task <PagedDto <UserDto> > HandleAsync(BrowseUsers query)
{
var result = await _database.GetCollection <UserDocument>("users")
.AsQueryable()
.OrderByDescending(x => x.CreatedAt)
.PaginateAsync(query);
var followers = new HashSet <Guid>();
if (query.UserId.HasValue)
{
var userId = query.UserId.Value;
followers = new HashSet <Guid>(await _database.GetCollection <FollowerDocument>("followers")
.AsQueryable()
.Where(x => x.FollowerId == userId)
.Select(x => x.FolloweeId)
.ToListAsync());
}
var pagedResult = PagedResult <UserDto> .From(result, result.Items.Select(x => Map(x, followers)));
return(new PagedDto <UserDto>
{
CurrentPage = pagedResult.CurrentPage,
TotalPages = pagedResult.TotalPages,
ResultsPerPage = pagedResult.ResultsPerPage,
TotalResults = pagedResult.TotalResults,
Items = pagedResult.Items
});
}
public virtual async Task <PagedResult <TDto> > HandleAsync(TBrowseQuery query)
{
var pagedResult = await BrowseAsync(query);
var products = pagedResult.Items.Select(p => _mapper.Map <TDomain, TDto>(p)).ToList();
return(PagedResult <TDto> .From(pagedResult, products));
}
public async Task <IPagedResult <LicenseDto> > BrowseAsync(Guid customerId, BrowseLicenses query)
{
var licenses = await _licenseRepository.BrowseAsync(customerId, query);
return(PagedResult <LicenseDto> .From(
(PagedResultBase)licenses,
_mapper.Map <IEnumerable <License>, IEnumerable <LicenseDto> >(licenses.Items)));
}
public async Task <PagedResult <CustomerDto> > HandleAsync(BrowseCustomers query)
{
var pagedResult = await mongoRepository.BrowseAsync(_ => true, query);
var customers = pagedResult.Items.Select(c => new CustomerDto(c.Id, c.FullName, c.Email, c.Phone, c.Address));
return(PagedResult <CustomerDto> .From(pagedResult, customers));
}
public async Task <PagedResult <ProductDetailsModel> > Handle(GetProductsPageQuery request, CancellationToken cancellationToken)
{
var query = (await _context.Products.ToListAsync()).AsQueryable();
var dto = _mapper.Map <PageDto>(request);
var result = PagedResult <ProductDetailsModel> .From(query, dto, _mapperConfiguration);
return(result);
}
public DepositsReportForRpc(DepositsReport report)
{
TotalValue = report.TotalValue;
ClaimedValue = report.ClaimedValue;
RefundedValue = report.RefundedValue;
RemainingValue = report.RemainingValue;
Deposits = PagedResult <DepositReportItemForRpc> .From(report.Deposits,
report.Deposits.Items.Select(d => new DepositReportItemForRpc(d)).ToArray());
}
public ConsumersReportForRpc(ConsumersReport report)
{
TotalValue = report.TotalValue;
ClaimedValue = report.ClaimedValue;
PendingValue = report.PendingValue;
Income = report.Income;
Cost = report.Cost;
Consumers = PagedResult <ConsumerReportItemForRpc> .From(report.Consumers,
report.Consumers.Items.Select(c => new ConsumerReportItemForRpc(c)).ToArray());
}
public async Task <ResultWrapper <PagedResult <DataAssetForRpc> > > ndm_getDataAssets(GetDataAssets?query = null)
{
var headers = await _providerService.GetDataAssetsAsync(query ?? new GetDataAssets
{
Results = int.MaxValue
});
return(ResultWrapper <PagedResult <DataAssetForRpc> > .Success(PagedResult <DataAssetForRpc> .From(headers,
headers.Items.Select(d => new DataAssetForRpc(d)).ToArray())));
}
public async Task <ResultWrapper <PagedResult <ConsumerForRpc> > > ndm_getConsumers(GetConsumers?query = null)
{
var consumers = await _providerService.GetConsumersAsync(query ?? new GetConsumers
{
Results = int.MaxValue
});
return(ResultWrapper <PagedResult <ConsumerForRpc> > .Success(PagedResult <ConsumerForRpc> .From(consumers,
consumers.Items.Select(c => new ConsumerForRpc(c)).ToArray())));
}
public async Task <ResultWrapper <PagedResult <DepositDetailsForRpc> > > ndm_getDeposits(GetDeposits query)
{
var deposits = await _consumerService.GetDepositsAsync(query ?? new GetDeposits
{
Results = int.MaxValue
});
return(ResultWrapper <PagedResult <DepositDetailsForRpc> > .Success(PagedResult <DepositDetailsForRpc> .From(
deposits, deposits.Items.Select(d => new DepositDetailsForRpc(d)).ToArray())));
}
public PaymentClaimsReportForRpc(PaymentClaimsReport report)
{
TotalValue = report.TotalValue;
ClaimedValue = report.ClaimedValue;
PendingValue = report.PendingValue;
Income = report.Income;
Cost = report.Cost;
PaymentClaims = PagedResult <PaymentClaimForRpc> .From(report.PaymentClaims,
report.PaymentClaims.Items.Select(c => new PaymentClaimForRpc(c)).ToArray());
}
public async Task <ResultWrapper <PagedResult <DepositDetailsForRpc> > > ndm_getDeposits(GetDeposits?query)
{
uint timestamp = (uint)_timestamper.UnixTime.Seconds;
PagedResult <DepositDetails> deposits = await _consumerService.GetDepositsAsync(query ?? new GetDeposits
{
Results = int.MaxValue
});
return(ResultWrapper <PagedResult <DepositDetailsForRpc> > .Success(PagedResult <DepositDetailsForRpc> .From(
deposits, deposits.Items.Select(d => new DepositDetailsForRpc(d, timestamp)).ToArray())));
}
public async Task <ResultWrapper <PagedResult <DepositApprovalForRpc> > > ndm_getProviderDepositApprovals(
GetProviderDepositApprovals?query = null)
{
var depositApprovals = await _providerService.GetDepositApprovalsAsync(query ?? new GetProviderDepositApprovals
{
Results = int.MaxValue
});
return(ResultWrapper <PagedResult <DepositApprovalForRpc> > .Success(PagedResult <DepositApprovalForRpc> .From(
depositApprovals, depositApprovals.Items.Select(d => new DepositApprovalForRpc(d)).ToArray())));
}
public async Task <Maybe <PagedResult <RemarkCategory> > > BrowseCategoriesAsync(BrowseRemarkCategories query)
{
var categories = await _provider.GetCollectionAsync(
async() => await _categoryRepository.BrowseAsync(query),
async() => await _serviceClient.BrowseCategoriesAsync <RemarkCategory>(query));
if (categories.HasNoValue)
{
return(null);
}
return(PagedResult <RemarkCategory> .From(categories.Value, categories.Value.Items.Reverse()));
}
public async Task <PagedResult <GameEventSourceDto> > HandleAsync(BrowseGameEventSource query)
{
var pagedResult = await _gameEventSourceRepository.BrowseAsync(query);
var result = pagedResult.Items.Select(c => new GameEventSourceDto
{
Id = c.Id,
Score = c.Score,
IsWin = c.IsWin
});
return(PagedResult <GameEventSourceDto> .From(pagedResult, result));
}
public async Task <PagedResult <ProductCategoryDto> > HandleAsync(BrowseProductCategory query)
{
_logger.LogInformation("Browsing product categories by Ids");
var pagedResult = await _productCategoryRepository.BrowseAsync(query);
_logger.LogInformation("Browsed product categories by Ids");
var productCategory = pagedResult.Items.Select(p => new ProductCategoryDto
{
Id = p.Id,
Name = p.Name
}).ToList();
return(PagedResult <ProductCategoryDto> .From(pagedResult, productCategory));
}
public async Task <PagedResult <GameEventSourceDto> > HandleAsync(BrowseGameEventSource query)
{
var pagedResult = await _database.GetCollection <GameEventSource>("gameEventSources")
.AsQueryable().Where(x => true).PaginateAsync(query);
var result = pagedResult.Items.Select(c => new GameEventSourceDto
{
Id = c.Id,
Score = c.Score,
IsWin = c.IsWin
});
return(PagedResult <GameEventSourceDto> .From(pagedResult, result));
}
public async Task <PagedResult <TodoItemDto> > HandleAsync(BrowseTodosForUser query)
{
var pagedResult = await _repository.BrowseTodosForUser(query);
var todoItems = pagedResult.Items.Select(todo => new TodoItemDto()
{
Id = todo.Id,
Title = todo.Title,
Description = todo.Description,
IsDone = todo.IsDone,
UserId = todo.UserId
}).ToList();
return(PagedResult <TodoItemDto> .From(pagedResult, todoItems));
}
public async Task <PagedResult <OrganizationDto> > BrowseAsync(BrowseOrganizations query)
{
if (query == null)
{
return(PagedResult <OrganizationDto> .Empty);
}
var organizations = await _database.Organizations()
.Query(query)
.OrderBy(x => x.Name)
.PaginateAsync(query);
return(PagedResult <OrganizationDto> .From(organizations,
organizations.Items.Select(x => new OrganizationDto(x))));
}
public async Task <PagedResult <OrderDto> > HandleAsync(BrowseOrders query)
{
var pagedResult = await _ordersRepository.BrowseAsync(query);
var orders = pagedResult.Items.Select(o => new OrderDto
{
Id = o.Id,
CustomerId = o.CustomerId,
ItemsCount = o.Items.Count(),
TotalAmount = o.TotalAmount,
Currency = o.Currency,
Status = o.Status.ToString().ToLowerInvariant()
});
return(PagedResult <OrderDto> .From(pagedResult, orders));
}
public async Task <PagedResult <ProductDto> > HandleAsync(QueryProducts query)
{
var pagedResult = await _productRepository.QueryPagedAsync(query);
var products = pagedResult.Items.Select(p => new ProductDto
{
Id = p.Id,
Name = p.Name,
Description = p.Description,
Vendor = p.Vendor,
Price = p.Price,
Quantity = p.Quantity
});
return(PagedResult <ProductDto> .From(pagedResult, products));
}
public async Task return_0_items_when_not_contain_any_documents()
{
var documents = new List <Document>();
var pagedResultBaseMock = new PagedResultBaseMock();
var pageDocuments = PagedResult <Document> .From(pagedResultBaseMock, documents);
_documentRepository.Setup(r => r.BrowseAsync(_query)).ReturnsAsync(pageDocuments);
//Act
var handler = new BrowseDocumentsByExternalIdHandler(_documentRepository.Object, _logger.Object);
var result = await handler.HandleAsync(_query);
//Assert
Assert.NotNull(result);
Assert.Equal(documents.Count, result.Count());
}
public async Task <PagedResult <ProductDto> > HandleAsync(BrowseProduct query)
{
_logger.LogInformation($"Browsing product by Id: '{query.Id}");
var pagedResult = await _productRepository.BrowseAsync(query);
_logger.LogInformation($"Browsed product by Id: '{query.Id}");
var products = pagedResult.Items.Select(p => new ProductDto
{
Id = p.Id,
Name = p.Name,
Description = p.Description,
Price = p.Price,
CategoryId = p.CategoryId
}).ToList();
return(PagedResult <ProductDto> .From(pagedResult, products));
}
public static async Task <PagedResult <T> > Paginate <T>(this IMongoQueryable <T> collection, string orderBy,
string sortOrderDirection = DefaultSort, int page = DefaultPage, int resultsPerPage = DefaultPageSize, CancellationToken cancellationToken = default)
{
if (page <= 0)
{
page = 1;
}
if (resultsPerPage <= 0)
{
resultsPerPage = 10;
}
var isEmpty = await collection.AnyAsync(cancellationToken) == false;
if (isEmpty)
{
return(PagedResult <T> .Empty);
}
var totalResults = await collection.CountAsync(cancellationToken);
var totalPages = (int)Math.Ceiling((decimal)totalResults / resultsPerPage);
List <T> data;
if (string.IsNullOrWhiteSpace(orderBy))
{
data = await collection.Limit(page, resultsPerPage).ToListAsync(cancellationToken);
return(PagedResult <T> .From(data, page, resultsPerPage, totalPages, totalResults));
}
var sortOrder = SortOrder.From(sortOrderDirection);
if (sortOrder == SortOrder.Ascending)
{
data = await collection.OrderBy(ToLambda <T>(orderBy)).Limit(page, resultsPerPage).ToListAsync(cancellationToken);
}
else
{
data = await collection.OrderByDescending(ToLambda <T>(orderBy)).Limit(page, resultsPerPage).ToListAsync(cancellationToken);
}
return(PagedResult <T> .From(data, page, resultsPerPage, totalPages, totalResults));
}
public async Task <PagedResult <WardenIterationDto> > BrowseIterationsAsync(BrowseWardenIterations query)
{
if (query == null)
{
return(PagedResult <WardenIterationDto> .Empty);
}
if (query.OrganizationId == Guid.Empty)
{
return(PagedResult <WardenIterationDto> .Empty);
}
var iterations = await _database.WardenIterations()
.Query(query)
.PaginateAsync(query);
return(PagedResult <WardenIterationDto> .From(iterations,
iterations.Items.Select(x => new WardenIterationDto(x))));
}
