Beispiel #1
0
        /// <summary>
        /// Delete a customer group product
        /// </summary>
        /// <param name="customerGroupProduct">Customer group product</param>
        public virtual async Task DeleteCustomerGroupProduct(CustomerGroupProduct customerGroupProduct)
        {
            if (customerGroupProduct == null)
            {
                throw new ArgumentNullException(nameof(customerGroupProduct));
            }

            await _customerGroupProductRepository.DeleteAsync(customerGroupProduct);

            //clear cache
            await _cacheBase.RemoveAsync(string.Format(CacheKey.CUSTOMERGROUPSPRODUCTS_ROLE_KEY, customerGroupProduct.CustomerGroupId));

            await _cacheBase.RemoveByPrefix(CacheKey.PRODUCTS_CUSTOMER_GROUP_PATTERN);

            //event notification
            await _mediator.EntityDeleted(customerGroupProduct);
        }
Beispiel #2
0
        /// <summary>
        /// Deletes a product specification attribute mapping
        /// </summary>
        /// <param name="productSpecificationAttribute">Product specification attribute</param>
        public virtual async Task DeleteProductSpecificationAttribute(ProductSpecificationAttribute productSpecificationAttribute)
        {
            if (productSpecificationAttribute == null)
            {
                throw new ArgumentNullException("productSpecificationAttribute");
            }

            var updatebuilder = Builders <Product> .Update;
            var update        = updatebuilder.Pull(p => p.ProductSpecificationAttributes, productSpecificationAttribute);
            await _productRepository.Collection.UpdateOneAsync(new BsonDocument("_id", productSpecificationAttribute.ProductId), update);

            //clear cache
            await _cacheBase.RemoveAsync(string.Format(CacheKey.PRODUCTS_BY_ID_KEY, productSpecificationAttribute.ProductId));

            //event notification
            await _mediator.EntityDeleted(productSpecificationAttribute);
        }
        /// <summary>
        /// Attach a tag to the order
        /// </summary>
        /// <param name="orderTag">Order's identification</param>
        public virtual async Task AttachOrderTag(string orderTagId, string orderId)
        {
            //assign to product
            await _orderRepository.AddToSet(orderId, x => x.OrderTags, orderTagId);

            var orderTag = await GetOrderTagById(orderTagId);

            //update product tag
            await _orderTagRepository.UpdateField(orderTagId, x => x.Count, orderTag.Count + 1);

            //cache
            await _cacheBase.RemoveAsync(string.Format(CacheKey.ORDERS_BY_ID_KEY, orderId));

            await _cacheBase.RemoveAsync(string.Format(CacheKey.ORDERTAG_COUNT_KEY, orderTagId));

            //event notification
            await _mediator.EntityUpdated(orderTag);
        }
        /// <summary>
        /// Deletes a product attribute mapping
        /// </summary>
        /// <param name="productAttributeMapping">Product attribute mapping</param>
        public virtual async Task DeleteProductAttributeMapping(ProductAttributeMapping productAttributeMapping)
        {
            if (productAttributeMapping == null)
            {
                throw new ArgumentNullException("productAttributeMapping");
            }

            var updatebuilder = Builders <Product> .Update;
            var update        = updatebuilder.PullFilter(p => p.ProductAttributeMappings, y => y.Id == productAttributeMapping.Id);
            await _productRepository.Collection.UpdateManyAsync(new BsonDocument("_id", productAttributeMapping.ProductId), update);

            //cache
            await _cacheBase.RemoveAsync(string.Format(CacheKey.PRODUCTS_BY_ID_KEY, productAttributeMapping.ProductId));

            //event notification
            await _mediator.EntityDeleted(productAttributeMapping);
        }
Beispiel #5
0
        /// <summary>
        /// Attach a tag to the order
        /// </summary>
        /// <param name="orderTag">Order's identification</param>
        public virtual async Task AttachOrderTag(string orderTagId, string orderId)
        {
            var updateBuilder = Builders <Order> .Update;
            var update        = updateBuilder.AddToSet(p => p.OrderTags, orderTagId);
            await _orderRepository.Collection.UpdateOneAsync(new BsonDocument("_id", orderId), update);

            // update ordertag with count's order and new order id
            var updateBuilderTag = Builders <OrderTag> .Update
                                   .Inc(x => x.Count, 1);

            await _orderTagRepository.Collection.UpdateOneAsync(new BsonDocument("_id", orderTagId), updateBuilderTag);

            var orderTag = await _orderTagRepository.GetByIdAsync(orderTagId);

            //cache
            await _cacheBase.RemoveAsync(string.Format(CacheKey.ORDERS_BY_ID_KEY, orderId));

            await _cacheBase.RemoveAsync(string.Format(CacheKey.ORDERTAG_COUNT_KEY, orderTagId));

            //event notification
            await _mediator.EntityUpdated(orderTag);
        }
Beispiel #6
0
        public async Task <bool> Handle(UpdateProductReviewTotalsCommand request, CancellationToken cancellationToken)
        {
            if (request.Product == null)
            {
                throw new ArgumentNullException("product");
            }

            int approvedRatingSum       = 0;
            int notApprovedRatingSum    = 0;
            int approvedTotalReviews    = 0;
            int notApprovedTotalReviews = 0;

            var reviews = await _productReviewService.GetAllProductReviews(null, null, null, null, null,
                                                                           null, request.Product.Id, 0, int.MaxValue);

            foreach (var pr in reviews)
            {
                if (pr.IsApproved)
                {
                    approvedRatingSum += pr.Rating;
                    approvedTotalReviews++;
                }
                else
                {
                    notApprovedRatingSum += pr.Rating;
                    notApprovedTotalReviews++;
                }
            }

            request.Product.ApprovedRatingSum       = approvedRatingSum;
            request.Product.NotApprovedRatingSum    = notApprovedRatingSum;
            request.Product.ApprovedTotalReviews    = approvedTotalReviews;
            request.Product.NotApprovedTotalReviews = notApprovedTotalReviews;

            var filter = Builders <Product> .Filter.Eq("Id", request.Product.Id);

            var update = Builders <Product> .Update
                         .Set(x => x.ApprovedRatingSum, request.Product.ApprovedRatingSum)
                         .Set(x => x.NotApprovedRatingSum, request.Product.NotApprovedRatingSum)
                         .Set(x => x.ApprovedTotalReviews, request.Product.ApprovedTotalReviews)
                         .Set(x => x.NotApprovedTotalReviews, request.Product.NotApprovedTotalReviews);

            await _productRepository.Collection.UpdateOneAsync(filter, update);

            //cache
            await _cacheBase.RemoveAsync(string.Format(CacheKey.PRODUCTS_BY_ID_KEY, request.Product.Id));

            return(true);
        }
        public virtual async Task UpdateCustomerActionType(CustomerActionType customerActionType)
        {
            if (customerActionType == null)
            {
                throw new ArgumentNullException(nameof(customerActionType));
            }

            await _customerActionTypeRepository.UpdateAsync(customerActionType);

            //clear cache
            await _cacheBase.RemoveAsync(CacheKey.CUSTOMER_ACTION_TYPE);

            //event notification
            await _mediator.EntityUpdated(customerActionType);
        }
        /// <summary>
        /// Attach a tag to the product
        /// </summary>
        /// <param name="productPicture">Product picture</param>
        public virtual async Task AttachProductTag(ProductTag productTag)
        {
            if (productTag == null)
            {
                throw new ArgumentNullException("productTag");
            }

            var updatebuilder = Builders <Product> .Update;
            var update        = updatebuilder.AddToSet(p => p.ProductTags, productTag.Name);
            await _productRepository.Collection.UpdateOneAsync(new BsonDocument("_id", productTag.ProductId), update);

            var builder   = Builders <ProductTag> .Filter;
            var filter    = builder.Eq(x => x.Id, productTag.Id);
            var updateTag = Builders <ProductTag> .Update
                            .Inc(x => x.Count, 1);

            await _productTagRepository.Collection.UpdateManyAsync(filter, updateTag);

            //cache
            await _cacheBase.RemoveAsync(string.Format(CacheKey.PRODUCTS_BY_ID_KEY, productTag.ProductId));

            //event notification
            await _mediator.EntityInserted(productTag);
        }
Beispiel #9
0
        public bool DeleteCurrency(string currencyName)
        {
            IEnumerable <Currency> result = GetAllActive().ToList().Where(c => c.name.Contains(currencyName));

            if (result.Any())
            {
                var item = result.FirstOrDefault();
                item.isActive = false;
                _cache.RemoveAsync(currencyName);
                return(_repoCurrency.Update <Currency>(item));
            }
            else
            {
                _logger.LogError($"Called DeleteCurrency cannot found any currency for {currencyName}");
                return(false);
            }
        }
        public async Task <bool> Handle(UpdateIntervalPropertiesCommand request, CancellationToken cancellationToken)
        {
            if (request.Product == null)
            {
                throw new ArgumentNullException("product");
            }

            var filter = Builders <Product> .Filter.Eq("Id", request.Product.Id);

            var update = Builders <Product> .Update
                         .Set(x => x.Interval, request.Interval)
                         .Set(x => x.IntervalUnitId, (int)request.IntervalUnit)
                         .Set(x => x.IncBothDate, request.IncludeBothDates);

            await _productRepository.Collection.UpdateOneAsync(filter, update);

            //cache
            await _cacheBase.RemoveAsync(string.Format(CacheKey.PRODUCTS_BY_ID_KEY, request.Product.Id));

            //event notification
            await _mediator.EntityUpdated(request.Product);

            return(true);
        }
        /// <summary>
        /// Adjust inventory
        /// </summary>
        /// <param name="product">Product</param>
        /// <param name="quantityToChange">Quantity to increase or descrease</param>
        /// <param name="attributes">Attributes</param>
        public virtual async Task AdjustInventory(Product product, int quantityToChange, IList <CustomAttribute> attributes = null, string warehouseId = "")
        {
            if (product == null)
            {
                throw new ArgumentNullException("product");
            }

            if (quantityToChange == 0)
            {
                return;
            }

            if (product.ManageInventoryMethod == ManageInventoryMethod.ManageStock)
            {
                var prevStockQuantity = product.GetTotalStockQuantity(warehouseId: warehouseId);

                //update stock quantity
                if (product.UseMultipleWarehouses)
                {
                    //use multiple warehouses
                    if (quantityToChange < 0)
                    {
                        await ReserveInventory(product, quantityToChange, warehouseId);
                    }
                    else
                    {
                        await UnblockReservedInventory(product, quantityToChange, warehouseId);
                    }

                    product.StockQuantity = product.ProductWarehouseInventory.Sum(x => x.StockQuantity);
                    await UpdateStockProduct(product);
                }
                else
                {
                    //do not use multiple warehouses
                    //simple inventory management
                    product.StockQuantity += quantityToChange;
                    await UpdateStockProduct(product);
                }

                //check if minimum quantity is reached
                if (quantityToChange < 0 && product.MinStockQuantity >= product.GetTotalStockQuantity(warehouseId: ""))
                {
                    switch (product.LowStockActivity)
                    {
                    case LowStockActivity.DisableBuyButton:
                        product.DisableBuyButton      = true;
                        product.DisableWishlistButton = true;

                        var filter = Builders <Product> .Filter.Eq("Id", product.Id);

                        var update = Builders <Product> .Update
                                     .Set(x => x.DisableBuyButton, product.DisableBuyButton)
                                     .Set(x => x.DisableWishlistButton, product.DisableWishlistButton)
                                     .Set(x => x.LowStock, true)
                                     .CurrentDate("UpdatedOnUtc");

                        await _productRepository.Collection.UpdateOneAsync(filter, update);

                        //cache
                        await _cacheBase.RemoveAsync(string.Format(CacheKey.PRODUCTS_BY_ID_KEY, product.Id));

                        //event notification
                        await _mediator.EntityUpdated(product);

                        break;

                    case LowStockActivity.Unpublish:
                        product.Published = false;
                        var filter2 = Builders <Product> .Filter.Eq("Id", product.Id);

                        var update2 = Builders <Product> .Update
                                      .Set(x => x.Published, product.Published)
                                      .CurrentDate("UpdatedOnUtc");

                        await _productRepository.Collection.UpdateOneAsync(filter2, update2);

                        //cache
                        await _cacheBase.RemoveAsync(string.Format(CacheKey.PRODUCTS_BY_ID_KEY, product.Id));

                        if (product.ShowOnHomePage)
                        {
                            await _cacheBase.RemoveByPrefix(CacheKey.PRODUCTS_SHOWONHOMEPAGE);
                        }

                        //event notification
                        await _mediator.EntityUpdated(product);

                        break;

                    default:
                        break;
                    }
                }
                //qty is increased. product is back in stock (minimum stock quantity is reached again)?
                if (_catalogSettings.PublishBackProductWhenCancellingOrders)
                {
                    if (quantityToChange > 0 && prevStockQuantity <= product.MinStockQuantity && product.MinStockQuantity < product.GetTotalStockQuantity(warehouseId: ""))
                    {
                        switch (product.LowStockActivity)
                        {
                        case LowStockActivity.DisableBuyButton:
                            var filter = Builders <Product> .Filter.Eq("Id", product.Id);

                            var update = Builders <Product> .Update
                                         .Set(x => x.DisableBuyButton, product.DisableBuyButton)
                                         .Set(x => x.DisableWishlistButton, product.DisableWishlistButton)
                                         .Set(x => x.LowStock, true)
                                         .CurrentDate("UpdatedOnUtc");

                            await _productRepository.Collection.UpdateOneAsync(filter, update);

                            //cache
                            await _cacheBase.RemoveAsync(string.Format(CacheKey.PRODUCTS_BY_ID_KEY, product.Id));

                            break;

                        case LowStockActivity.Unpublish:
                            product.Published = false;
                            var filter2 = Builders <Product> .Filter.Eq("Id", product.Id);

                            var update2 = Builders <Product> .Update
                                          .Set(x => x.Published, product.Published)
                                          .CurrentDate("UpdatedOnUtc");

                            await _productRepository.Collection.UpdateOneAsync(filter2, update2);

                            //cache
                            await _cacheBase.RemoveAsync(string.Format(CacheKey.PRODUCTS_BY_ID_KEY, product.Id));

                            if (product.ShowOnHomePage)
                            {
                                await _cacheBase.RemoveByPrefix(CacheKey.PRODUCTS_SHOWONHOMEPAGE);
                            }

                            break;

                        default:
                            break;
                        }
                    }
                }

                //send email notification
                if (quantityToChange < 0 && product.GetTotalStockQuantity(warehouseId: warehouseId) < product.NotifyAdminForQuantityBelow)
                {
                    await _mediator.Send(new SendQuantityBelowStoreOwnerNotificationCommand()
                    {
                        Product = product
                    });
                }
            }

            if (attributes != null && product.ManageInventoryMethod == ManageInventoryMethod.ManageStockByAttributes)
            {
                var combination = _productAttributeParser.FindProductAttributeCombination(product, attributes);
                if (combination != null)
                {
                    combination.ProductId = product.Id;
                    if (!product.UseMultipleWarehouses)
                    {
                        combination.StockQuantity += quantityToChange;
                        await _productAttributeService.UpdateProductAttributeCombination(combination);
                    }
                    else
                    {
                        if (quantityToChange < 0)
                        {
                            await ReserveInventoryCombination(product, combination, quantityToChange, warehouseId);
                        }
                        else
                        {
                            await UnblockReservedInventoryCombination(product, combination, quantityToChange, warehouseId);
                        }
                    }

                    product.StockQuantity += quantityToChange;
                    await UpdateStockProduct(product);

                    //send email notification
                    if (quantityToChange < 0 && combination.StockQuantity < combination.NotifyAdminForQuantityBelow)
                    {
                        await _mediator.Send(new SendQuantityBelowStoreOwnerNotificationCommand()
                        {
                            Product = product,
                            ProductAttributeCombination = combination
                        });
                    }
                }
            }

            if (product.ManageInventoryMethod == ManageInventoryMethod.ManageStockByBundleProducts)
            {
                foreach (var item in product.BundleProducts)
                {
                    var p1 = await _productRepository.GetByIdAsync(item.ProductId);

                    if (p1 != null && (p1.ManageInventoryMethod == ManageInventoryMethod.ManageStock || p1.ManageInventoryMethod == ManageInventoryMethod.ManageStockByAttributes))
                    {
                        await AdjustInventory(p1, quantityToChange *item.Quantity, attributes, warehouseId);
                    }
                }
            }

            //bundled products
            var attributeValues = _productAttributeParser.ParseProductAttributeValues(product, attributes);

            foreach (var attributeValue in attributeValues)
            {
                if (attributeValue.AttributeValueType == AttributeValueType.AssociatedToProduct)
                {
                    //associated product (bundle)
                    var associatedProduct = await _productRepository.GetByIdAsync(attributeValue.AssociatedProductId);

                    if (associatedProduct != null)
                    {
                        await AdjustInventory(associatedProduct, quantityToChange *attributeValue.Quantity, null, warehouseId);
                    }
                }
            }

            //event notification
            await _mediator.EntityUpdated(product);
        }