public virtual async Task <PaymentSearchResult> SearchPaymentsAsync(PaymentSearchCriteria criteria)
{
var cacheKey = CacheKey.With(GetType(), nameof(PaymentSearchCriteria), criteria.GetCacheKey());
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(OrderSearchCacheRegion.CreateChangeToken());
using (var repository = _repositoryFactory())
{
repository.DisableChangesTracking();
var result = AbstractTypeFactory <PaymentSearchResult> .TryCreateInstance();
var query = BuildQuery(repository, criteria);
var sortInfos = BuildSortExpression(criteria);
result.TotalCount = await query.CountAsync();
if (criteria.Take > 0)
{
var ids = await query.OrderBySortInfos(sortInfos).ThenBy(x => x.Id)
.Select(x => x.Id)
.Skip(criteria.Skip).Take(criteria.Take)
.ToArrayAsync();
var unorderedResults = await _paymentService.GetByIdsAsync(ids, criteria.ResponseGroup);
result.Results = unorderedResults.OrderBy(x => Array.IndexOf(ids, x.Id)).ToList();
}
return result;
}
}));
}
public async Task <IPagedList <PaymentIn> > SearchPaymentsAsync(PaymentSearchCriteria criteria)
{
if (criteria == null)
{
throw new ArgumentNullException(nameof(criteria));
}
var workContext = _workContextAccessor.WorkContext;
var result = await _orderApi.SearchPaymentsAsync(criteria.ToPaymentSearchCriteriaDto());
return(new StaticPagedList <PaymentIn>(result.Results.Select(x => x.ToOrderInPayment(workContext.AllCurrencies, workContext.CurrentLanguage)),
criteria.PageNumber, criteria.PageSize, result.TotalCount.Value));
}
public async Task <ActionResult <PaymentSearchResult> > SearchOrderPayments([FromBody] PaymentSearchCriteria criteria)
{
var authorizationResult = await _authorizationService.AuthorizeAsync(User, criteria, new OrderAuthorizationRequirement(ModuleConstants.Security.Permissions.Read));
if (!authorizationResult.Succeeded)
{
return(Unauthorized());
}
var result = await _paymentSearchService.SearchPaymentsAsync(criteria);
return(Ok(result));
}
protected virtual IList <SortInfo> BuildSortExpression(PaymentSearchCriteria criteria)
{
var sortInfos = criteria.SortInfos;
if (sortInfos.IsNullOrEmpty())
{
sortInfos = new[]
{
new SortInfo
{
SortColumn = nameof(PaymentInEntity.CreatedDate),
SortDirection = SortDirection.Descending
}
};
}
return(sortInfos);
}
public async Task <ActionResult <PaymentSearchResult> > SearchPayments([FromBody] PaymentSearchCriteria criteria)
{
if (criteria == null)
{
criteria = new PaymentSearchCriteria();
}
var authorizationResult = await _authorizationService.AuthorizeAsync(User, null, SecurityConstants.Permissions.CanViewOrders);
if (!authorizationResult.Succeeded)
{
//Does not allow to see a other customer orders
return(Unauthorized());
}
var result = await _paymentSearchService.SearchPaymentsAsync(criteria);
return(new PaymentSearchResult
{
Results = result.ToArray(),
TotalCount = result.TotalItemCount
});
}
public static orderDto.PaymentSearchCriteria ToPaymentSearchCriteriaDto(this PaymentSearchCriteria criteria)
{
var result = new orderDto.PaymentSearchCriteria
{
OrderId = criteria.OrderId,
OrderNumber = criteria.OrderNumber,
Keyword = criteria.Keyword,
Status = criteria.Status,
Statuses = criteria.Statuses,
StoreIds = criteria.StoreIds,
StartDate = criteria.StartDate,
EndDate = criteria.EndDate,
CapturedStartDate = criteria.CapturedStartDate,
CapturedEndDate = criteria.CapturedEndDate,
AuthorizedStartDate = criteria.AuthorizedStartDate,
AuthorizedEndDate = criteria.AuthorizedEndDate,
Skip = criteria.Start,
Take = criteria.PageSize,
Sort = criteria.Sort
};
return(result);
}
protected virtual IQueryable <PaymentInEntity> BuildQuery(IOrderRepository repository, PaymentSearchCriteria criteria)
{
var query = repository.InPayments;
if (!criteria.Ids.IsNullOrEmpty())
{
query = query.Where(x => criteria.Ids.Contains(x.Id));
}
if (!string.IsNullOrEmpty(criteria.OrderId))
{
query = query.Where(x => x.CustomerOrderId == criteria.OrderId);
}
else if (!string.IsNullOrEmpty(criteria.OrderNumber))
{
query = query.Where(x => x.CustomerOrder.Number == criteria.OrderNumber);
}
if (criteria.EmployeeId != null)
{
query = query.Where(x => x.CustomerOrder.EmployeeId == criteria.EmployeeId);
}
if (!criteria.StoreIds.IsNullOrEmpty())
{
query = query.Where(x => criteria.StoreIds.Contains(x.CustomerOrder.StoreId));
}
if (!criteria.Statuses.IsNullOrEmpty())
{
query = query.Where(x => criteria.Statuses.Contains(x.Status));
}
if (!criteria.CustomerId.IsNullOrEmpty())
{
query = query.Where(x => x.CustomerId == criteria.CustomerId);
}
if (criteria.StartDate != null)
{
query = query.Where(x => x.CreatedDate >= criteria.StartDate);
}
if (criteria.EndDate != null)
{
query = query.Where(x => x.CreatedDate <= criteria.EndDate);
}
if (criteria.CapturedStartDate != null)
{
query = query.Where(x => x.CapturedDate >= criteria.CapturedStartDate);
}
if (criteria.CapturedEndDate != null)
{
query = query.Where(x => x.CapturedDate <= criteria.CapturedEndDate);
}
if (criteria.AuthorizedStartDate != null)
{
query = query.Where(x => x.AuthorizedDate >= criteria.AuthorizedStartDate);
}
if (criteria.AuthorizedEndDate != null)
{
query = query.Where(x => x.AuthorizedDate <= criteria.AuthorizedEndDate);
}
if (!criteria.Numbers.IsNullOrEmpty())
{
query = query.Where(x => criteria.Numbers.Contains(x.Number));
}
else if (!string.IsNullOrEmpty(criteria.Keyword))
{
query = query.Where(GetKeywordPredicate(criteria));
}
return(query);
}
protected virtual Expression <Func <PaymentInEntity, bool> > GetKeywordPredicate(PaymentSearchCriteria criteria)
{
return(payment => payment.Number.Contains(criteria.Keyword));
}
public ActionResult Index([Bind(Include = "Page, Sort")] PageSortCriteria pageSortCriteria, [Bind(Include = "Amount, PaymentType")] PaymentSearchCriteria searchCriteria = null)
{
PaymentListVM vm = new PaymentListVM
{
Payments = UOW.Payments.GetAllPaged(pageSortCriteria, searchCriteria),
PageSortCriteria = pageSortCriteria,
SearchCriteria = searchCriteria
};
return(View(vm));
}
public PaymentsSearchCriteriaBuilder()
{
_searchCriteria = AbstractTypeFactory <PaymentSearchCriteria> .TryCreateInstance();
}
