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; })); }