public async Task <TResult> Query(TCommand command) { if (!command.IsFromCache) { return(await _decoratedRemoteQuery.Query(command)); } var commandCacheKey = typeof(TCommand).FullName + command.ToJson(); var cachedItem = _cache.Get <TResult>(commandCacheKey, command.Region); if (cachedItem == null) { var item = await _decoratedRemoteQuery.Query(command); if (item == null) { return(item); } var cacheItem = new CacheItem <object>(commandCacheKey, command.Region, item, (ExpirationMode)command.ExpirationMode, command.Timeout); _cache.Add(cacheItem); return(item); } return(cachedItem); }
public override async Task <ActionResult <PagedList <OrderDto> > > Handle(ListOrdersCommand command) { var orders = await _listOrdersQuery.Query(command); var shippingMethodsDtoResult = await _listShippingMethodsQueryHandler.Handle(new ListShippingMethodsCommand()); if (shippingMethodsDtoResult.Failure) { return(Error(shippingMethodsDtoResult.ErrorMessages)); } var orderStatusesDtoResult = await _listOrderStatusesQueryHandler.Handle(new ListOrderStatusesCommand()); if (orderStatusesDtoResult.Failure) { return(Error(orderStatusesDtoResult.ErrorMessages)); } // TODO: fix workingLanguageId var ordersDto = _mapper.Map(orders, new PagedList <OrderDto>(), opt => opt.Items["WorkingLanguageId"] = 1); foreach (var orderDto in ordersDto.Items) { orderDto.OrderStatus = orderStatusesDtoResult.Object.FirstOrDefault(o => o.Value.ToString() == orderDto.OrderStatus).Text; orderDto.ShippingMethod = shippingMethodsDtoResult.Object.FirstOrDefault(o => o.Value.ToString() == orderDto.ShippingMethod).Text; } return(Ok(ordersDto)); }
public override async Task <ActionResult <RouteDto> > Handle(GetRouteByComponentCommand command) { // TODO: pagalvoti ar sitas bera reikalingas. var routes = await _listRoutesQuery.Query(new ListRoutesCommand()); return(Ok(null)); }
public override async Task <ActionResult <RouteDto> > Handle(GetRouteByUrlCommand command) { command.Url = command.Url?.TrimStart('/') ?? ""; var lastUrlChain = command.Url.Split('/').ToList().Last(); var routes = await _listRoutesQuery.Query(new ListRoutesCommand(lastUrlChain)); foreach (var route in routes) { if (route.Product != null && route.Product.Id > 0) { return(Ok(_mapper.Map(route, new RouteDto()))); } else if (route.Category != null && route.Category.Id > 0) { var category = await _getCategoryQuery.Query(new GetCategoryCommand(route.Category.Id, command.LanguageId)); if (category.GetCategoryChainedNavigation() == command.Url) { return(Ok(_mapper.Map(route, new RouteDto()))); } } } return(Ok(null)); }
public override async Task <ActionResult <List <ShippingMethodDto> > > Handle(ListShippingMethodsCommand command) { var shippingMethods = await _listShippingMethodsQuery.Query(command); if (shippingMethods == null) { return(Error()); } var phrases = await _listPhrasesByNameQuery.Query(new ListPhrasesByNameCommand(shippingMethods.Select(o => o.Code))); var shippingMethodsDto = new List <ShippingMethodDto>(); foreach (var shippingMethod in shippingMethods) { shippingMethodsDto.Add(new ShippingMethodDto() { Price = shippingMethod.Price, Text = (phrases.FirstOrDefault(o => o.Code == shippingMethod.Code)?.Value ?? shippingMethod.Code) + $" + {shippingMethod.Price.ToCurrencyString()}€", Value = shippingMethod.Code }); } return(Ok(shippingMethodsDto)); }
public override async Task <ActionResult <BasketDto> > Handle(CreateOrGetUnconfirmedBasketCommand command) { var basket = await _createOrGetUnconfirmedBasketQuery.Query(command); if (basket == null) { // if basket is null then send user is not authenticated error // TODO: take this info from phrases return(Error()); } var basketDto = new BasketDto(); basketDto.Id = basket.Id; if (basket.BasketItems.IsNullOrEmpty()) { return(Ok(basketDto)); } foreach (var basketItem in basket.BasketItems) { var basketItemDto = new BasketItemDto(); var productDto = (await _getProductQueryHandler.Handle(new GetProductCommand(basketItem.ProductId.Value, _workContext.WorkingLanguageId))).Object; basketItemDto.Id = basketItem.Id; basketItemDto.Product = productDto; basketItemDto.Price = basketItem.Price; basketItemDto.ProductDetailId = basketItem.ProductDetailId; basketItemDto.Quantity = basketItem.Quantity; basketDto.BasketItems.Add(basketItemDto); } return(Ok(basketDto)); }
public override async Task <ActionResult <ProductDto> > Handle(AddProductToBasketCommand command) { var productDtoResult = await _getProductQueryHandler.Handle(new GetProductCommand(command.ProductId, _workContext.WorkingLanguageId)); if (productDtoResult.Failure) { return(Error(productDtoResult.ErrorMessages)); } var productDto = productDtoResult.Object; var detailErrors = productDto.Fieldsets.MapToFields(command).ValidateFieldsets(); if (!detailErrors.IsNullOrEmpty()) { return(Error(detailErrors)); } var basket = await _addProductToBasketQuery.Query(command); if (basket == null) { // if basket is null then send user is not authenticated error // TODO: take this info from phrases return(Error(new Dictionary <string, DetailError>() { { "baseProductBody" + "." + "basketAdd", new DetailError(DetailErrorTypes.Field, "Prašome pirmiau prisijungti.") } })); } return(Ok(productDto)); }
public override async Task <Category> Query(DeleteCategoryCommand command) { var category = await DbContext.Categories.Include(o => o.Route).FirstOrDefaultAsync(o => o.Id == command.CategoryId); if (category == null) { return(null); } DbContext.ActionByEntityState(category.Route, EntityState.Deleted); await DbContext.SaveChangesAsync(); var routes = await _listRoutesQuery.Query(new ListRoutesCommand()); foreach (var route in routes.Where(o => o.Category == null && o.Product == null)) { DbContext.ActionByEntityState(route, EntityState.Deleted); } await DbContext.SaveChangesAsync(); _cache.ClearRegion(CacheRegions.Category); _cache.ClearRegion(CacheRegions.Product); return(category); }
public override async Task <ActionResult <SubmitCheckoutDto> > Handle(SubmitCheckoutCommand command) { var checkoutCategoryDtoResult = await _getCategoryByUrlQueryHandler.Handle(new GetCategoryByUrlCommand(command.RouteUrl)); if (checkoutCategoryDtoResult.Failure) { return(Error(checkoutCategoryDtoResult.ErrorMessages)); } var checkoutCategoryDto = checkoutCategoryDtoResult.Object; var orderDto = command.Order; if (orderDto.ShippingMethod == ShippingMethods.Shop) { checkoutCategoryDto.GetAnyField(nameof(orderDto.Address)).SetCharacteristic(CharacteristicCodes.IsRequired, false); checkoutCategoryDto.GetAnyField(nameof(orderDto.City)).SetCharacteristic(CharacteristicCodes.IsRequired, false); checkoutCategoryDto.GetAnyField(nameof(orderDto.PostCode)).SetCharacteristic(CharacteristicCodes.IsRequired, false); } if (orderDto.PaymentMethod == PaymentMethods.Cash) { checkoutCategoryDto.GetAnyField(nameof(orderDto.PaymentMethodType)).SetCharacteristic(CharacteristicCodes.IsRequired, false); } var detailErrors = checkoutCategoryDto.Fieldsets.MapToFields(orderDto).ValidateFieldsets(); if (!detailErrors.IsNullOrEmpty()) { return(Error(detailErrors)); } var basket = await _createOrGetUnconfirmedBasketQuery.Query(new CreateOrGetUnconfirmedBasketCommand()); if (basket.BasketItems.Count <= 0) { return(Error()); } basket.IsConfirmed = true; var paymentMethods = await _listPaymentMethodsQuery.Query(new ListPaymentMethodsCommand()); var shippingMethods = await _listShippingMethodsQuery.Query(new ListShippingMethodsCommand()); var order = new Order(); _mapper.Map(command.Order, new Order()); order.UserId = basket.UserId; order.BasketId = basket.Id; order.PaymentMethodId = paymentMethods.FirstOrDefault(o => o.Name == orderDto.PaymentMethod).Id; order.PaymentMethodTypeId = paymentMethods.FirstOrDefault(o => o.Name == orderDto.PaymentMethod).PaymentMethodTypes.FirstOrDefault(o => o.Name == orderDto.PaymentMethodType)?.Id; order.ShippingMethodId = shippingMethods.FirstOrDefault(o => o.Name == orderDto.ShippingMethod).Id; _dbContext.ActionByEntityState(basket, EntityState.Modified); _dbContext.ActionByEntityState(order, EntityState.Added); await _dbContext.SaveChangesAsync(); return(Ok(new SubmitCheckoutDto())); }
public override async Task <ActionResult <PagedList <CategoryDto> > > Handle(ListCategoriesCommand command) { var pagedCategories = await _listCategoriesQuery.Query(command); var pagedCategoriesDto = _mapper.Map(pagedCategories, new PagedList <CategoryDto>(), opt => opt.Items["WorkingLanguageId"] = command.LanguageId); return(Ok(pagedCategoriesDto.Items.ToPagedList(command))); }
public override async Task <ActionResult <PagedList <ProductDto> > > Handle(ListProductsCommand command) { var products = await _listProductsQuery.Query(command); var productsDto = _mapper.Map(products, new PagedList <ProductDto>(), opt => opt.Items["WorkingLanguageId"] = command.LanguageId); return(Ok(productsDto)); }
public async Task <ClassifierStore> Get() { var classifierStore = new ClassifierStore(); classifierStore.AngularComponents = await _listAngularComponentsQuery.Query(new ListAngularComponentsCommand()); classifierStore.CategoryTypes = await _listCategoryTypesQuery.Query(new ListCategoryTypesCommand()); return(classifierStore); }
public override async Task <ActionResult <BasketItemDto> > Handle(DeleteBasketItemCommand command) { var basketItem = await _deleteBasketItemQuery.Query(command); if (basketItem == null) { return(Error()); } return(Ok(new BasketItemDto())); }
public override async Task <ActionResult <CategoryDto> > Handle(DeleteCategoryCommand command) { var category = await _deleteCategoryQuery.Query(command); if (category == null) { // Nothing to delete return(Error()); } return(Ok(null)); }
public override async Task <ActionResult <ProductDto> > Handle(DeleteProductCommand command) { var product = await _deleteProductQuery.Query(command); if (product == null) { // Nothing to delete return(Error()); } return(Ok(null)); }
public override async Task <ActionResult <LanguageDto> > Handle(GetLanguageCommand command) { var language = await _getLanguageQuery.Query(command); if (language == null) { ActionResult <LanguageDto> .Error(); } var languageDto = _mapper.Map <LanguageDto>(language); return(ActionResult <LanguageDto> .Ok(languageDto)); }
public override async Task <ActionResult <OptionDto> > Handle(GetSystemSettingCommand command) { var systemSettingQuery = await _getSystemSettingQuery.Query(command); if (systemSettingQuery == null) { ActionResult <OptionDto> .Error(); } var inputFormDto = _mapper.Map <OptionDto>(systemSettingQuery); return(ActionResult <OptionDto> .Ok(inputFormDto)); }
public override async Task <ActionResult <List <PhraseDto> > > Handle(ListPhrasesByTermCommand command) { var phrases = await _listPhrasesQuery.Query(command); if (phrases == null) { return(Error()); } var phrasesDto = _mapper.Map(phrases, new List <PhraseDto>()); return(Ok(phrasesDto)); }
public override async Task <ActionResult <RouteDto> > Handle(GetRouteCommand command) { var route = await _getRouteQuery.Query(command); if (route == null) { return(Error()); } var routeDto = _mapper.Map(route, new RouteDto()); return(Ok(routeDto)); }
public override async Task <ActionResult <InputFormDto> > Handle(GetInputFormCommand command) { var inputFormQuery = await _getInputFormQuery.Query(command); if (inputFormQuery == null) { ActionResult <InputFormDto> .Error(); } var inputFormDto = _mapper.Map <InputFormDto>(inputFormQuery); return(ActionResult <InputFormDto> .Ok(inputFormDto)); }
public override async Task <ActionResult <CategoryDto> > Handle(GetCategoryCommand command) { var category = await _getCategoryQuery.Query(command); if (category == null) { return(Error()); } var categoryDto = _mapper.Map(category, new CategoryDto(), opt => opt.Items["WorkingLanguageId"] = command.LanguageId); return(Ok(categoryDto)); }
public override async Task <InputForm> Query(GetInputFormCommand command) { var query = DbContext.InputForms .Include(o => o.InputFormOptions); if (string.IsNullOrEmpty(command.InputFormName)) { var activeInputForm = await _getSystemSettingQuery.Query(new GetSystemSettingCommand(SystemSettingOptions.ActiveInputForm.Name)); command.InputFormName = activeInputForm.Value; } return(await query.Where(o => o.Code == command.InputFormName).FirstOrDefaultAsync()); }
public override async Task <ActionResult <OrderDto> > Handle(GetOrderCommand command) { var order = await _getOrderQuery.Query(command); if (order == null) { return(Error()); } // TODO: fix WorkingLanguageId var orderDto = _mapper.Map(order, new OrderDto(), opt => opt.Items["WorkingLanguageId"] = 1); return(Ok(orderDto)); }
public override async Task <ActionResult <ProductDto> > Handle(GetProductCommand command) { var product = await _getProductQuery.Query(command); if (product == null) { return(Error()); } var productDto = _mapper.Map(product, new ProductDto(), opt => opt.Items["WorkingLanguageId"] = command.LanguageId); productDto.Navigations.LastOrDefault().Parameters.Add("IsLastBreadcrumbUrlActive", true); return(Ok(productDto)); }
public override async Task <ActionResult <OrderDto> > Handle(SaveOrderCommand command) { var editOrderCategoryDtoResult = await _getCategoryByUrlQueryHandler.Handle(new GetCategoryByUrlCommand(command.RouteUrl, _workContext.WorkingLanguageId)); if (editOrderCategoryDtoResult.Failure) { return(Error(editOrderCategoryDtoResult.ErrorMessages)); } var editOrderCategoryDto = editOrderCategoryDtoResult.Object; var orderDto = command.Order; var detailErrors = editOrderCategoryDto.Fieldsets.MapToFields(orderDto).ValidateFieldsets(); if (!detailErrors.IsNullOrEmpty()) { return(Error(detailErrors)); } var order = await _getOrderQuery.Query(new GetOrderCommand(command.Order.Id)); if (order == null) { return(Error()); } _mapper.Map(command.Order, order); var paymentMethods = await _listPaymentMethodsQuery.Query(new ListPaymentMethodsCommand()); var shippingMethods = await _listShippingMethodsQuery.Query(new ListShippingMethodsCommand()); var orderStatuses = await _listOrderStatusesQuery.Query(new ListOrderStatusesCommand()); order.PaymentMethodId = paymentMethods.FirstOrDefault(o => o.Code == orderDto.PaymentMethod).Id; order.PaymentMethodTypeId = paymentMethods.FirstOrDefault(o => o.Code == orderDto.PaymentMethod).PaymentMethodTypes.FirstOrDefault(o => o.Code == orderDto.PaymentMethodType)?.Id; order.ShippingMethodId = shippingMethods.FirstOrDefault(o => o.Code == orderDto.ShippingMethod).Id; order.OrderStatusId = orderStatuses.FirstOrDefault(o => o.Code == orderDto.OrderStatus).Id; _dbContext.AddOrUpdate(order); await _dbContext.SaveChangesAsync(); return(Ok(orderDto)); }
public override async Task <BasketItem> Query(DeleteBasketItemCommand command) { var basket = await _createOrGetUnconfirmedBasketQuery.Query(new CreateOrGetUnconfirmedBasketCommand()); if (basket == null) { return(null); } var basketItem = basket.BasketItems.FirstOrDefault(o => o.Id == command.BasketItemId); if (basketItem != null) { DbContext.ActionByEntityState(basketItem, EntityState.Deleted); await DbContext.SaveChangesAsync(); } return(basketItem); }
public override async Task <ActionResult <CategoryDto> > Handle(SaveCategoryCommand command) { var saveCategoryDtoResult = await _getCategoryByUrlQueryHandler.Handle(new GetCategoryByUrlCommand(command.SaveCategory.RouteUrl, command.LanguageId)); if (saveCategoryDtoResult.Failure) { return(Error(saveCategoryDtoResult.ErrorMessages)); } var saveCategoryDto = saveCategoryDtoResult.Object; var detailErrors = saveCategoryDto.Fieldsets.MapToFields(command.SaveCategory.Category).ValidateFieldsets(); if (!detailErrors.IsNullOrEmpty()) { return(Error(detailErrors)); } var classifierStore = await _classifierStoresRepository.Get(); var availableCharacteristics = await _listCharacteristicsQuery.Query(new ListCharacteristicsCommand()); var category = await _getCategoryQuery.Query(new GetCategoryCommand(command.SaveCategory.Category.Id, command.LanguageId, true) { IsFromCache = false }) ?? new Category(); var categoryDto = command.SaveCategory.Category; categoryDto = await CategoryDtoDefaults(categoryDto); _mapper.Map(categoryDto, category); category.Route.AngularComponentId = classifierStore.AngularComponents.First(o => o.Code == categoryDto.AngularComponentCode).Id; category.CategoryTypeId = classifierStore.CategoryTypes.First(o => o.Code == categoryDto.CategoryTypeCode).Id; category.Images.MergeImages(availableCharacteristics, categoryDto.Images); category.Characteristics.MergeCharacteristics(availableCharacteristics, categoryDto.Characteristics); await _saveCategoryQuery.Query(new SaveCategoryQueryCommand(category)); return(Ok(categoryDto)); }
public override async Task <ActionResult <ProductDto> > Handle(SaveProductCommand command) { var saveProductDtoResult = await _getCategoryByUrlQueryHandler.Handle(new GetCategoryByUrlCommand(command.SaveProduct.RouteUrl, command.LanguageId)); if (saveProductDtoResult.Failure) { return(Error(saveProductDtoResult.ErrorMessages)); } var saveProductDto = saveProductDtoResult.Object; var detailErrors = saveProductDto.Fieldsets.MapToFields(command.SaveProduct.Product).ValidateFieldsets(); if (!detailErrors.IsNullOrEmpty()) { return(Error(detailErrors)); } var classifierStore = await _classifierStoresRepository.Get(); var availableCharacteristics = await _listCharacteristicsQuery.Query(new ListCharacteristicsCommand()); var product = await _getProductQuery.Query(new GetProductCommand(command.SaveProduct.Product.Id, command.LanguageId) { IsFromCache = false }) ?? new Product(); var productDto = command.SaveProduct.Product; _mapper.Map(productDto, product); product.Route.AngularComponentId = classifierStore.AngularComponents.First(o => o.Code == productDto.AngularComponentCode).Id; product.Images.MergeImages(availableCharacteristics, productDto.Images); product.Characteristics.MergeCharacteristics(availableCharacteristics, productDto.Characteristics); product = await BeforeProductSave(product); await _saveProductQuery.Query(new SaveProductQueryCommand(product)); return(Ok(productDto)); }
public override async Task <Basket> Query(AddProductToBasketCommand command) { var product = await _getProductQuery.Query(new GetProductCommand(command.ProductId, _workContext.WorkingLanguageId)); if (product == null) { return(null); } var basket = await _createOrGetUnconfirmedBasketQuery.Query(new CreateOrGetUnconfirmedBasketCommand()); if (basket == null) { return(null); } var basketItem = basket.BasketItems.FirstOrDefault(o => o.ProductId == command.ProductId && o.ProductDetailId == command.ProductDetailId); if (basketItem == null) { basketItem = new BasketItem(); basketItem.BasketId = basket.Id; basketItem.ProductDetailId = command.ProductDetailId; basketItem.ProductId = product.Id; basketItem.Price = product.GetTotalPrice(); basketItem.Quantity = command.Quantity; } else { basketItem.Quantity += command.Quantity; } DbContext.AddOrUpdate(basketItem); await DbContext.SaveChangesAsync(); return(basket); }
public override async Task <ActionResult <List <PaymentMethodDto> > > Handle(ListPaymentMethodsCommand command) { var paymentMethods = await _listPaymentMethodsQuery.Query(command); if (paymentMethods == null) { return(Error()); } var phrases = await _listPhrasesByNameQuery.Query(new ListPhrasesByNameCommand(paymentMethods.Select(o => o.Code).Concat(paymentMethods.SelectMany(o => o.PaymentMethodTypes.Select(i => i.Code))))); var paymentMethodsDto = new List <PaymentMethodDto>(); foreach (var paymentMethod in paymentMethods) { var paymentMethodDto = new PaymentMethodDto() { Text = phrases.FirstOrDefault(o => o.Code == paymentMethod.Code)?.Value ?? paymentMethod.Code, Value = paymentMethod.Code }; foreach (var paymentMethodType in paymentMethod.PaymentMethodTypes) { var paymentMethodTypeDto = new PaymentMethodTypeDto() { Text = phrases.FirstOrDefault(o => o.Code == paymentMethodType.Code)?.Value ?? paymentMethodType.Code, Value = paymentMethodType.Code }; paymentMethodDto.PaymentMethodTypes.Add(paymentMethodTypeDto); } paymentMethodsDto.Add(paymentMethodDto); } return(Ok(paymentMethodsDto)); }