public async Task <IHttpActionResult> Search(CustomerOrderSearchCriteria criteria)
{
//Scope bound ACL filtration
criteria = await FilterOrderSearchCriteria(HttpContext.Current.User.Identity.Name, criteria);
var result = _searchService.SearchCustomerOrders(criteria);
var retVal = new CustomerOrderSearchResult
{
CustomerOrders = result.Results.ToList(),
TotalCount = result.TotalCount
};
return(Ok(retVal));
}
public IHttpActionResult Search(CustomerOrderSearchCriteria criteria)
{
//Scope bound ACL filtration
//criteria = FilterOrderSearchCriteria(HttpContext.Current.User.Identity.Name, criteria);
// var result = _searchService.SearchCustomerOrders(criteria);
//var retVal = new webModel.CustomerOrderSearchResult
//{
// CustomerOrders = result.Results.ToList(),
// TotalCount = result.TotalCount
//};
var retVal = _orderShipmenyService.SearchCustomerOrdersExt(criteria);
return(Ok(retVal));
}
protected virtual IList <SortInfo> BuildSortExpression(CustomerOrderSearchCriteria criteria)
{
var sortInfos = criteria.SortInfos;
if (sortInfos.IsNullOrEmpty())
{
sortInfos = new[]
{
new SortInfo
{
SortColumn = nameof(CustomerOrderEntity.CreatedDate),
SortDirection = SortDirection.Descending
}
};
}
return(sortInfos);
}
private async Task <IReadOnlyCollection <IndexDocumentChange> > PerformGettingOrders(int skip, int take)
{
if (_startDate == null && _endDate == null)
{
var searchCriteria = new CustomerOrderSearchCriteria {
Skip = skip, Take = take
};
var searchResult = await _orderSearchService.SearchCustomerOrdersAsync(searchCriteria);
return(searchResult.Results
.Select(x => new IndexDocumentChange
{
ChangeDate = x.ModifiedDate ?? DateTime.MinValue,
DocumentId = x.Id,
ChangeType = IndexDocumentChangeType.Modified
})
.ToArray());
}
else
{
var customerOrderType = GetCustomerOrderType();
var searchResult = await _changeLogSearchService.SearchAsync(new ChangeLogSearchCriteria
{
ObjectType = customerOrderType,
StartDate = _startDate,
EndDate = _endDate
});
return(searchResult.Results.Select(x => x.ObjectId)
.Distinct()
.Skip(skip)
.Take(take)
.Select(x => new IndexDocumentChange
{
ChangeDate = DateTime.MinValue,
DocumentId = x,
ChangeType = IndexDocumentChangeType.Modified
})
.ToArray());
}
}
protected override void EnsureThatAllOperationsHaveNumber(CustomerOrder order)
{
var store = StoreService.GetById(order.StoreId);
foreach (var operation in order.GetFlatObjectsListWithInterface <Domain.Commerce.Model.IOperation>())
{
if (operation.Number == null)
{
if (operation.OperationType == "CustomerOrder")
{
CustomerOrderSearchCriteria criteria = new CustomerOrderSearchCriteria()
{
Sort = "createdDate:desc", Take = 1, ResponseGroup = "default"
};
var lastOrder = _orderSearchService.SearchCustomerOrders(criteria).Results.First();
if (lastOrder != null)
{
operation.Number = (Convert.ToInt32(lastOrder.Number) + 1).ToString();
}
}
else
{
var objectTypeName = operation.OperationType;
// take uppercase chars to form operation type, or just take 2 first chars. (CustomerOrder => CO, PaymentIn => PI, Shipment => SH)
var opType = string.Concat(objectTypeName.Select(c => char.IsUpper(c) ? c.ToString() : ""));
if (opType.Length < 2)
{
opType = objectTypeName.Substring(0, 2).ToUpper();
}
var numberTemplate = opType + "{0:yyMMdd}-{1:D5}";
if (store != null)
{
numberTemplate = store.Settings.GetSettingValue("Order." + objectTypeName + "NewNumberTemplate", numberTemplate);
}
operation.Number = UniqueNumberGenerator.GenerateNumber(numberTemplate);
}
}
}
}
public void Map_TermFilter()
{
// Arrange
var mapperCfg = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new OrderMappingProfile());
});
var mapper = mapperCfg.CreateMapper();
var terms = new List <IFilter>
{
new TermFilter {
FieldName = "CustomerId", Values = new[] { Guid.NewGuid().ToString() }
},
new TermFilter {
FieldName = "CustomerIds", Values = new[] { Guid.NewGuid().ToString() }
},
new TermFilter {
FieldName = "SubscriptionIds", Values = new string [] { }
},
new TermFilter {
FieldName = "SubscriptionIds", Values = null
}
};
// Action
var criteria = new CustomerOrderSearchCriteria();
mapper.Map(terms, criteria);
// Assert
Assert.NotNull(criteria);
Assert.NotNull(criteria.CustomerId);
Assert.NotNull(criteria.CustomerIds);
Assert.NotNull(criteria.CustomerId);
Assert.Null(criteria.SubscriptionIds);
}
protected virtual Expression <Func <CustomerOrderEntity, bool> > GetKeywordPredicate(CustomerOrderSearchCriteria criteria)
{
return(order => order.Number.Contains(criteria.Keyword) || order.CustomerName.Contains(criteria.Keyword));
}
private CustomerOrderSearchCriteria FilterOrderSearchCriteria(string userName, CustomerOrderSearchCriteria criteria)
{
if (!_securityService.UserHasAnyPermission(userName, null, OrderPredefinedPermissions.Read))
{
//Get defined user 'read' permission scopes
var readPermissionScopes = _securityService.GetUserPermissions(userName)
.Where(x => x.Id.StartsWith(OrderPredefinedPermissions.Read))
.SelectMany(x => x.AssignedScopes)
.ToList();
//Check user has a scopes
//Stores
criteria.StoreIds = readPermissionScopes.OfType <OrderStoreScope>()
.Select(x => x.Scope)
.Where(x => !String.IsNullOrEmpty(x))
.ToArray();
var responsibleScope = readPermissionScopes.OfType <OrderResponsibleScope>().FirstOrDefault();
//employee id
if (responsibleScope != null)
{
criteria.EmployeeId = userName;
}
}
return(criteria);
}
public GenericSearchResult <CustomerOrder> SearchCustomerOrdersExt(CustomerOrderSearchCriteria criteria)
{
var retVal = new GenericSearchResult <CustomerOrder>();
using (var repository = _orderRepositoryFactoryEx())
{
var query = repository.CustomerOrders;
var queryShipment = repository.ShipmentExtended.Where(s => s.IsApproved == true);
var orderIds = queryShipment.Select(x => x.CustomerOrderId).ToArray();
query = query.Where(x => orderIds.Contains(x.Id));
//by default does not return prototypes
if (!criteria.WithPrototypes)
{
query = query.Where(x => !x.IsPrototype);
}
if (!criteria.Numbers.IsNullOrEmpty())
{
query = query.Where(x => criteria.Numbers.Contains(x.Number));
}
else if (!string.IsNullOrEmpty(criteria.Keyword))
{
query = query.Where(x => x.Number.Contains(criteria.Keyword) || x.CustomerName.Contains(criteria.Keyword));
}
if (criteria.OnlyRecurring)
{
query = query.Where(x => x.SubscriptionId != null);
}
if (!criteria.SubscriptionIds.IsNullOrEmpty())
{
query = query.Where(x => criteria.SubscriptionIds.Contains(x.SubscriptionId));
}
if (criteria.CustomerId != null)
{
query = query.Where(x => x.CustomerId == criteria.CustomerId);
}
if (criteria.Statuses != null && criteria.Statuses.Any())
{
query = query.Where(x => criteria.Statuses.Contains(x.Status));
}
if (criteria.StoreIds != null && criteria.StoreIds.Any())
{
query = query.Where(x => criteria.StoreIds.Contains(x.StoreId));
}
if (criteria.EmployeeId != null)
{
query = query.Where(x => x.EmployeeId == criteria.EmployeeId);
}
if (criteria.StartDate != null)
{
query = query.Where(x => x.CreatedDate >= criteria.StartDate);
}
if (criteria.EndDate != null)
{
query = query.Where(x => x.CreatedDate <= criteria.EndDate);
}
var sortInfos = criteria.SortInfos;
if (sortInfos.IsNullOrEmpty())
{
sortInfos = new[] { new SortInfo {
SortColumn = ReflectionUtility.GetPropertyName <CustomerOrderEntity>(x => x.CreatedDate), SortDirection = SortDirection.Descending
} };
}
query = query.OrderBySortInfos(sortInfos);
retVal.TotalCount = query.Count();
var orderCustomerIds = query.Select(x => x.Id).Skip(criteria.Skip).Take(criteria.Take).ToArray();
var orders = GetByIds(orderCustomerIds, criteria.ResponseGroup);
retVal.Results = orders.AsQueryable <CustomerOrder>().OrderBySortInfos(sortInfos).ToList();
return(retVal);
}
}
public virtual async Task <Subscription[]> GetByIdsAsync(string[] subscriptionIds, string responseGroup = null)
{
var cacheKey = CacheKey.With(GetType(), nameof(GetByIdsAsync), string.Join("-", subscriptionIds), responseGroup);
return(await PlatformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async cacheEntry =>
{
var retVal = new List <Subscription>();
var subscriptionResponseGroup = EnumUtility.SafeParse(responseGroup, SubscriptionResponseGroup.Full);
using (var repository = SubscriptionRepositoryFactory())
{
repository.DisableChangesTracking();
var subscriptionEntities = await repository.GetSubscriptionsByIdsAsync(subscriptionIds, responseGroup);
foreach (var subscriptionEntity in subscriptionEntities)
{
var subscription = AbstractTypeFactory <Subscription> .TryCreateInstance();
if (subscription != null)
{
subscription = subscriptionEntity.ToModel(subscription) as Subscription;
if (subscriptionResponseGroup.HasFlag(SubscriptionResponseGroup.WithChangeLog))
{
//Load change log by separate request
ChangeLogService.LoadChangeLogs(subscription);
}
retVal.Add(subscription);
}
}
}
CustomerOrder[] orderPrototypes = null;
CustomerOrder[] subscriptionOrders = null;
if (subscriptionResponseGroup.HasFlag(SubscriptionResponseGroup.WithOrderPrototype))
{
orderPrototypes = await CustomerOrderService.GetByIdsAsync(retVal.Select(x => x.CustomerOrderPrototypeId).ToArray());
}
if (subscriptionResponseGroup.HasFlag(SubscriptionResponseGroup.WithRelatedOrders))
{
//Loads customer order prototypes and related orders for each subscription via order service
var criteria = new CustomerOrderSearchCriteria
{
SubscriptionIds = subscriptionIds
};
subscriptionOrders = (await CustomerOrderSearchService.SearchCustomerOrdersAsync(criteria)).Results.ToArray();
}
foreach (var subscription in retVal)
{
if (!orderPrototypes.IsNullOrEmpty())
{
subscription.CustomerOrderPrototype = orderPrototypes.FirstOrDefault(x => x.Id == subscription.CustomerOrderPrototypeId);
}
if (!subscriptionOrders.IsNullOrEmpty())
{
subscription.CustomerOrders = subscriptionOrders.Where(x => x.SubscriptionId == subscription.Id).ToList();
subscription.CustomerOrdersIds = subscription.CustomerOrders.Select(x => x.Id).ToArray();
}
cacheEntry.AddExpirationToken(SubscriptionCacheRegion.CreateChangeToken(subscription));
}
return retVal.ToArray();
}));
}
public CustomerOrderSearchCriteriaBuilder()
{
_searchCriteria = AbstractTypeFactory <CustomerOrderSearchCriteria> .TryCreateInstance();
}
public async Task <ActionResult <GenericSearchResult <CustomerOrder> > > Search([FromBody] CustomerOrderSearchCriteria criteria)
{
//Scope bound ACL filtration
criteria = FilterOrderSearchCriteria(User.Identity.Name, criteria);
var result = await _searchService.SearchCustomerOrdersAsync(criteria);
return(Ok(result));
}
public virtual async Task <CustomerOrderSearchResult> SearchCustomerOrdersAsync(CustomerOrderSearchCriteria criteria)
{
var cacheKey = CacheKey.With(GetType(), nameof(SearchCustomerOrdersAsync), criteria.GetCacheKey());
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(OrderSearchCacheRegion.CreateChangeToken());
using (var repository = _repositoryFactory())
{
repository.DisableChangesTracking();
var result = AbstractTypeFactory <CustomerOrderSearchResult> .TryCreateInstance();
var query = BuildQuery(repository, criteria);
var sortInfos = BuildSortExpression(criteria);
result.TotalCount = await query.CountAsync();
if (criteria.Take > 0)
{
var orderIds = await query.OrderBySortInfos(sortInfos).ThenBy(x => x.Id)
.Select(x => x.Id)
.Skip(criteria.Skip).Take(criteria.Take)
.ToArrayAsync();
var unorderedResults = await _customerOrderService.GetByIdsAsync(orderIds, criteria.ResponseGroup);
result.Results = unorderedResults.OrderBy(x => Array.IndexOf(orderIds, x.Id)).ToList();
}
return result;
}
}));
}
public async Task <ActionResult <CustomerOrderSearchResult> > SearchCustomerOrder([FromBody] CustomerOrderSearchCriteria criteria)
{
var authorizationResult = await _authorizationService.AuthorizeAsync(User, criteria, new OrderAuthorizationRequirement(ModuleConstants.Security.Permissions.Read));
if (!authorizationResult.Succeeded)
{
return(Unauthorized());
}
var result = await _searchService.SearchCustomerOrdersAsync(criteria);
return(Ok(result));
}
public virtual async Task <CustomerOrderSearchResult> SearchCustomerOrdersAsync(CustomerOrderSearchCriteria criteria)
{
var cacheKey = CacheKey.With(GetType(), "SearchCustomerOrdersAsync", criteria.GetCacheKey());
return(await _platformMemoryCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(OrderSearchCacheRegion.CreateChangeToken());
using (var repository = _repositoryFactory())
{
repository.DisableChangesTracking();
var result = AbstractTypeFactory <CustomerOrderSearchResult> .TryCreateInstance();
var orderResponseGroup = EnumUtility.SafeParseFlags(criteria.ResponseGroup, CustomerOrderResponseGroup.Full);
var query = GetOrdersQuery(repository, criteria);
var sortInfos = criteria.SortInfos;
if (sortInfos.IsNullOrEmpty())
{
sortInfos = new[]
{
new SortInfo
{
SortColumn = ReflectionUtility.GetPropertyName <CustomerOrderEntity>(x => x.CreatedDate),
SortDirection = SortDirection.Descending
}
};
}
query = query.OrderBySortInfos(sortInfos);
result.TotalCount = await query.CountAsync();
var orderIds = await query.Select(x => x.Id).Skip(criteria.Skip).Take(criteria.Take).ToArrayAsync();
result.Results = (await _customerOrderService.GetByIdsAsync(orderIds, criteria.ResponseGroup)).AsQueryable()
.OrderBySortInfos(sortInfos)
.ToList();
return result;
}
}));
}
private async Task <CustomerOrderSearchCriteria> FilterOrderSearchCriteria(string userName, CustomerOrderSearchCriteria criteria)
{
var user = await _securityService.FindByNameAsync(userName, UserDetails.Reduced);
criteria.ResponseGroup = OrderReadPricesPermission.ApplyResponseGroupFiltering(user, _securityService.GetUserPermissions(userName), criteria.ResponseGroup);
if (!_securityService.UserHasAnyPermission(userName, null, OrderPredefinedPermissions.Read))
{
//Get defined user 'read' permission scopes
var readPermissionScopes = _securityService.GetUserPermissions(userName)
.Where(x => x.Id.StartsWith(OrderPredefinedPermissions.Read))
.SelectMany(x => x.AssignedScopes)
.ToList();
//Check user has a scopes
//Stores
criteria.StoreIds = readPermissionScopes.OfType <OrderStoreScope>()
.Select(x => x.Scope)
.Where(x => !string.IsNullOrEmpty(x))
.ToArray();
//employee id
var responsibleScope = readPermissionScopes.OfType <OrderResponsibleScope>().FirstOrDefault();
if (responsibleScope != null)
{
criteria.EmployeeId = userName;
}
}
return(criteria);
}
protected virtual IQueryable <CustomerOrderEntity> GetOrdersQuery(IOrderRepository repository, CustomerOrderSearchCriteria criteria)
{
var query = repository.CustomerOrders;
// Don't return prototypes by default
if (!criteria.WithPrototypes)
{
query = query.Where(x => !x.IsPrototype);
}
if (criteria.OnlyRecurring)
{
query = query.Where(x => x.SubscriptionId != null);
}
if (criteria.CustomerId != null)
{
query = query.Where(x => x.CustomerId == criteria.CustomerId);
}
if (criteria.EmployeeId != null)
{
query = query.Where(x => x.EmployeeId == criteria.EmployeeId);
}
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.SubscriptionIds.IsNullOrEmpty())
{
query = query.Where(x => criteria.SubscriptionIds.Contains(x.SubscriptionId));
}
if (criteria.Statuses != null && criteria.Statuses.Any())
{
query = query.Where(x => criteria.Statuses.Contains(x.Status));
}
if (criteria.StoreIds != null && criteria.StoreIds.Any())
{
query = query.Where(x => criteria.StoreIds.Contains(x.StoreId));
}
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);
}
public async Task <ActionResult <CustomerOrderSearchResult> > SearchCustomerOrder([FromBody] CustomerOrderSearchCriteria criteria)
{
var authorizationResult = await _authorizationService.AuthorizeAsync(User, criteria, new OrderAuthorizationRequirement(ModuleConstants.Security.Permissions.Read));
if (!authorizationResult.Succeeded)
{
return(Unauthorized());
}
var result = await _searchService.SearchCustomerOrdersAsync(criteria);
//It is a important to return serialized data by such way. Instead you have a slow response time for large outputs
//https://github.com/dotnet/aspnetcore/issues/19646
return(Content(JsonConvert.SerializeObject(result, _jsonOptions.SerializerSettings), "application/json"));
}
