protected virtual IQueryable <StoreShippingMethodEntity> GetQuery(
IShippingRepository repository,
ShippingMethodsSearchCriteria criteria,
IEnumerable <SortInfo> sortInfos)
{
var query = repository.StoreShippingMethods;
if (!string.IsNullOrEmpty(criteria.Keyword))
{
query = query.Where(x => x.Code.Contains(criteria.Keyword) || x.Id.Contains(criteria.Keyword));
}
if (!criteria.StoreId.IsNullOrEmpty())
{
query = query.Where(x => x.StoreId == criteria.StoreId);
}
if (!criteria.Codes.IsNullOrEmpty())
{
query = query.Where(x => criteria.Codes.Contains(x.Code));
}
if (!criteria.TaxType.IsNullOrEmpty())
{
query = query.Where(x => criteria.TaxType.Contains(x.TaxType));
}
if (criteria.IsActive.HasValue)
{
query = query.Where(x => x.IsActive == criteria.IsActive.Value);
}
query = query.OrderBySortInfos(sortInfos);
return(query);
}
public async Task TestFillingTaxTypeForShipment(string shipmentTaxType, string shippingMethodTaxType, string expectedTaxType)
{
// Arrange
var order = new CustomerOrder
{
StoreId = TestStoreId,
Shipments = new List <Shipment>
{
new Shipment
{
ShipmentMethodCode = TestShipmentMethodCode,
TaxType = shipmentTaxType
}
}
};
var store = new Store
{
Id = TestStoreId,
};
var shippingMethods = new List <ShippingMethod>
{
new TestShippingMethod(TestShipmentMethodCode)
{
TaxType = shippingMethodTaxType
}
};
var searchCriteria = new ShippingMethodsSearchCriteria
{
IsActive = true,
Keyword = TestShipmentMethodCode
};
_shippingMethodsSearchService.Setup(x => x.SearchShippingMethodsAsync(searchCriteria)).ReturnsAsync(() => new ShippingMethodsSearchResult
{
TotalCount = 1,
Results = shippingMethods
});
_storeService.Setup(x => x.GetByIdsAsync(new[] { TestStoreId }, null)).ReturnsAsync(new[] { store });
var target = new OrderTaxTypeResolver(_storeService.Object, _shippingMethodsSearchService.Object);
// Act
await target.ResolveTaxTypeForOrderAsync(order);
// Assert
foreach (var shipment in order.Shipments)
{
Assert.Equal(expectedTaxType, shipment.TaxType);
}
}
public async Task <IEnumerable <ShippingRate> > GetAvailableShippingRatesAsync(CartAggregate cartAggr)
{
if (cartAggr == null)
{
return(Enumerable.Empty <ShippingRate>());
}
//Request available shipping rates
var shippingEvaluationContext = new ShippingEvaluationContext(cartAggr.Cart);
var criteria = new ShippingMethodsSearchCriteria
{
IsActive = true,
Take = _takeOnSearch,
StoreId = cartAggr.Store?.Id
};
var activeAvailableShippingMethods = (await _shippingMethodsSearchService.SearchShippingMethodsAsync(criteria)).Results;
var availableShippingRates = activeAvailableShippingMethods
.SelectMany(x => x.CalculateRates(shippingEvaluationContext))
.Where(x => x.ShippingMethod == null || x.ShippingMethod.IsActive)
.ToArray();
if (availableShippingRates.IsNullOrEmpty())
{
return(Enumerable.Empty <ShippingRate>());
}
//Evaluate promotions cart and apply rewards for available shipping methods
var evalContext = _mapper.Map <PromotionEvaluationContext>(cartAggr);
var promoEvalResult = await cartAggr.EvaluatePromotionsAsync(evalContext);
foreach (var shippingRate in availableShippingRates)
{
shippingRate.ApplyRewards(promoEvalResult.Rewards);
}
var taxProvider = await GetActiveTaxProviderAsync(cartAggr.Store.Id);
if (taxProvider != null)
{
var taxEvalContext = _mapper.Map <TaxEvaluationContext>(cartAggr);
taxEvalContext.Lines.Clear();
taxEvalContext.Lines.AddRange(availableShippingRates.SelectMany(x => _mapper.Map <IEnumerable <TaxLine> >(x)));
var taxRates = taxProvider.CalculateRates(taxEvalContext);
foreach (var shippingRate in availableShippingRates)
{
shippingRate.ApplyTaxRates(taxRates);
}
}
return(availableShippingRates);
}
protected virtual IList <SortInfo> GetSortInfos(ShippingMethodsSearchCriteria criteria)
{
var sortInfos = criteria.SortInfos;
if (sortInfos.IsNullOrEmpty())
{
sortInfos = new[]
{
new SortInfo {
SortColumn = "Name"
}
};
}
return(sortInfos);
}
protected virtual IList <SortInfo> BuildSortExpression(ShippingMethodsSearchCriteria criteria)
{
var sortInfos = criteria.SortInfos;
if (sortInfos.IsNullOrEmpty())
{
sortInfos = new[]
{
new SortInfo {
SortColumn = nameof(StoreShippingMethodEntity.Code)
}
};
}
return(sortInfos);
}
public virtual async Task <ICollection <ShippingRate> > GetShippingRatesAsync(string shippingMethodCode)
{
var shippingEvaluationContext = new ShippingEvaluationContext(Cart);
var criteria = new ShippingMethodsSearchCriteria
{
IsActive = true,
Take = int.MaxValue,
StoreId = Store.Id,
Codes = new[] { shippingMethodCode }
};
var shippingMethod = (await _shippingMethodsSearchService.SearchShippingMethodsAsync(criteria))
.Results.FirstOrDefault();
return(shippingMethod?.CalculateRates(shippingEvaluationContext).ToList());
}
public virtual async Task <ICollection <ShippingRate> > GetAvailableShippingRatesAsync()
{
// TODO: Remake with shipmentId
var shippingEvaluationContext = new ShippingEvaluationContext(Cart);
var criteria = new ShippingMethodsSearchCriteria
{
IsActive = true,
Take = int.MaxValue,
StoreId = Store.Id
};
var activeAvailableShippingMethods = (await _shippingMethodsSearchService.SearchShippingMethodsAsync(criteria)).Results;
var availableShippingRates = activeAvailableShippingMethods
.SelectMany(x => x.CalculateRates(shippingEvaluationContext))
.Where(x => x.ShippingMethod == null || x.ShippingMethod.IsActive)
.ToArray();
return(availableShippingRates);
}
public async Task <ActionResult <ShippingMethodsSearchResult> > SearchShippingMethods([FromBody] ShippingMethodsSearchCriteria criteria)
{
var result = await _shippingMethodsSearchService.SearchShippingMethodsAsync(criteria);
return(Ok(result));
}
public async Task <ShippingMethodsSearchResult> SearchShippingMethodsAsync(ShippingMethodsSearchCriteria criteria)
{
var cacheKey = CacheKey.With(GetType(), "SearchShippingMethodsAsync", criteria.GetCacheKey());
return(await _memCache.GetOrCreateExclusiveAsync(cacheKey, async (cacheEntry) =>
{
cacheEntry.AddExpirationToken(ShippingCacheRegion.CreateChangeToken());
var result = AbstractTypeFactory <ShippingMethodsSearchResult> .TryCreateInstance();
var tmpSkip = 0;
var tmpTake = 0;
var sortInfos = GetSortInfos(criteria);
using (var repository = _repositoryFactory())
{
repository.DisableChangesTracking();
var query = GetQuery(repository, criteria, sortInfos);
result.TotalCount = await query.CountAsync();
if (criteria.Take > 0)
{
var shippingMethodsIds = await query.Select(x => x.Id)
.Skip(criteria.Skip)
.Take(criteria.Take)
.ToArrayAsync();
result.Results = (await _shippingMethodsService.GetByIdsAsync(shippingMethodsIds, criteria.ResponseGroup))
.AsQueryable()
.OrderBySortInfos(sortInfos)
.ToArray();
}
}
//Need to concatenate persistent methods with registered types and still not persisted
tmpSkip = Math.Min(result.TotalCount, criteria.Skip);
tmpTake = Math.Min(criteria.Take, Math.Max(0, result.TotalCount - criteria.Skip));
criteria.Skip = criteria.Skip - tmpSkip;
criteria.Take = criteria.Take - tmpTake;
if (criteria.Take > 0 && !criteria.WithoutTransient)
{
var transientMethodsQuery = AbstractTypeFactory <ShippingMethod> .AllTypeInfos.Select(x => AbstractTypeFactory <ShippingMethod> .TryCreateInstance(x.Type.Name))
.OfType <ShippingMethod>().AsQueryable();
if (!string.IsNullOrEmpty(criteria.Keyword))
{
transientMethodsQuery = transientMethodsQuery.Where(x => x.Code.Contains(criteria.Keyword));
}
var allPersistentTypes = result.Results.Select(x => x.GetType()).Distinct();
transientMethodsQuery = transientMethodsQuery.Where(x => !allPersistentTypes.Contains(x.GetType()));
result.TotalCount += transientMethodsQuery.Count();
var transientProviders = transientMethodsQuery.Skip(criteria.Skip).Take(criteria.Take).ToList();
foreach (var transientProvider in transientProviders)
{
await _settingsManager.DeepLoadSettingsAsync(transientProvider);
}
result.Results = result.Results.Concat(transientProviders).AsQueryable().OrderBySortInfos(sortInfos).ToList();
}
return result;
}));
}
