public virtual CustomerDownloadableProductsModel PrepareCustomerDownloadableProductsModel()
        {
            var model = new CustomerDownloadableProductsModel();
            var items = _orderService.GetDownloadableOrderItems(_workContext.CurrentCustomer.Id);

            foreach (var item in items)
            {
                var itemModel = new CustomerDownloadableProductsModel.DownloadableProductsModel
                {
                    OrderItemGuid     = item.OrderItemGuid,
                    OrderId           = item.OrderId,
                    CreatedOn         = _dateTimeHelper.ConvertToUserTime(item.Order.CreatedOnUtc, DateTimeKind.Utc),
                    ProductName       = item.Product.GetLocalized(x => x.Name),
                    ProductSeName     = item.Product.GetSeName(),
                    ProductAttributes = item.AttributeDescription,
                    ProductId         = item.ProductId
                };
                model.Items.Add(itemModel);

                if (_downloadService.IsDownloadAllowed(item))
                {
                    itemModel.DownloadId = item.Product.DownloadId;
                }

                if (_downloadService.IsLicenseDownloadAllowed(item))
                {
                    itemModel.LicenseId = item.LicenseDownloadId.HasValue ? item.LicenseDownloadId.Value : 0;
                }
            }

            return(model);
        }
        public async Task <CustomerDownloadableProductsModel> Handle(GetDownloadableProducts request, CancellationToken cancellationToken)
        {
            var model = new CustomerDownloadableProductsModel();

            var query = new GetOrderQuery
            {
                StoreId = request.Store.Id
            };

            if (!await _groupService.IsOwner(request.Customer))
            {
                query.CustomerId = request.Customer.Id;
            }
            else
            {
                query.OwnerId = request.Customer.Id;
            }

            var orders = await _mediator.Send(query);

            foreach (var order in orders)
            {
                foreach (var orderitem in order.OrderItems)
                {
                    var product = await _productService.GetProductByIdIncludeArch(orderitem.ProductId);

                    if (product != null && product.IsDownload)
                    {
                        var itemModel = new CustomerDownloadableProductsModel.DownloadableProductsModel
                        {
                            OrderItemGuid     = orderitem.OrderItemGuid,
                            OrderId           = order.Id,
                            OrderNumber       = order.OrderNumber,
                            CreatedOn         = _dateTimeService.ConvertToUserTime(order.CreatedOnUtc, DateTimeKind.Utc),
                            ProductName       = product.GetTranslation(x => x.Name, request.Language.Id),
                            ProductSeName     = product.GetSeName(request.Language.Id),
                            ProductAttributes = orderitem.AttributeDescription,
                            ProductId         = orderitem.ProductId
                        };
                        model.Items.Add(itemModel);

                        if (order.IsDownloadAllowed(orderitem, product))
                        {
                            itemModel.DownloadId = product.DownloadId;
                        }

                        if (order.IsLicenseDownloadAllowed(orderitem, product))
                        {
                            itemModel.LicenseId = !string.IsNullOrEmpty(orderitem.LicenseDownloadId) ? orderitem.LicenseDownloadId : "";
                        }
                    }
                }
            }

            return(model);
        }
Exemple #3
0
        public virtual async Task <CustomerDownloadableProductsModel> PrepareDownloadableProducts(string customerId)
        {
            var model = new CustomerDownloadableProductsModel();
            var items = await _orderService.GetAllOrderItems(null, customerId, null, null,
                                                             null, null, null, true);

            var productService = _serviceProvider.GetRequiredService <IProductService>();

            foreach (var item in items)
            {
                var order = await _orderService.GetOrderByOrderItemId(item.Id);

                var product = await productService.GetProductByIdIncludeArch(item.ProductId);

                var itemModel = new CustomerDownloadableProductsModel.DownloadableProductsModel
                {
                    OrderItemGuid     = item.OrderItemGuid,
                    OrderId           = order.Id,
                    OrderNumber       = order.OrderNumber,
                    CreatedOn         = _dateTimeHelper.ConvertToUserTime(item.CreatedOnUtc, DateTimeKind.Utc),
                    ProductName       = product.GetLocalized(x => x.Name, _workContext.WorkingLanguage.Id),
                    ProductSeName     = product.GetSeName(_workContext.WorkingLanguage.Id),
                    ProductAttributes = item.AttributeDescription,
                    ProductId         = item.ProductId
                };
                model.Items.Add(itemModel);

                if (await _downloadService.IsDownloadAllowed(item))
                {
                    itemModel.DownloadId = product.DownloadId;
                }

                if (await _downloadService.IsLicenseDownloadAllowed(item))
                {
                    itemModel.LicenseId = !String.IsNullOrEmpty(item.LicenseDownloadId) ? item.LicenseDownloadId : "";
                }
            }
            return(model);
        }
Exemple #4
0
        /// <summary>
        /// Prepare the customer downloadable products model
        /// </summary>
        /// <returns>Customer downloadable products model</returns>
        public virtual CustomerDownloadableProductsModel PrepareCustomerDownloadableProductsModel()
        {
            var model = new CustomerDownloadableProductsModel();
            var items = _orderService.GetDownloadableOrderItems(_workContext.CurrentCustomer.Id);

            foreach (var item in items)
            {
                var order   = _orderService.GetOrderById(item.OrderId);
                var product = _productService.GetProductById(item.ProductId);

                var itemModel = new CustomerDownloadableProductsModel.DownloadableProductsModel
                {
                    OrderItemGuid     = item.OrderItemGuid,
                    OrderId           = order.Id,
                    CustomOrderNumber = order.CustomOrderNumber,
                    CreatedOn         = _dateTimeHelper.ConvertToUserTime(order.CreatedOnUtc, DateTimeKind.Utc),
                    ProductName       = _localizationService.GetLocalized(product, x => x.Name),
                    ProductSeName     = _urlRecordService.GetSeName(product),
                    ProductAttributes = item.AttributeDescription,
                    ProductId         = item.ProductId
                };
                model.Items.Add(itemModel);

                if (_downloadService.IsDownloadAllowed(item))
                {
                    itemModel.DownloadId = product.DownloadId;
                }

                if (_downloadService.IsLicenseDownloadAllowed(item))
                {
                    itemModel.LicenseId = item.LicenseDownloadId ?? 0;
                }
            }

            return(model);
        }
        public virtual CustomerDownloadableProductsModel PrepareDownloadableProducts(string customerId)
        {
            var model = new CustomerDownloadableProductsModel();
            var items = _orderService.GetAllOrderItems(null, customerId, null, null,
                                                       null, null, null, true);
            var productService = EngineContext.Current.Resolve <IProductService>();

            foreach (var item in items)
            {
                var order     = _orderService.GetOrderByOrderItemId(item.Id);
                var product   = productService.GetProductByIdIncludeArch(item.ProductId);
                var itemModel = new CustomerDownloadableProductsModel.DownloadableProductsModel
                {
                    OrderItemGuid     = item.OrderItemGuid,
                    OrderId           = order.Id,
                    OrderNumber       = order.OrderNumber,
                    CreatedOn         = _dateTimeHelper.ConvertToUserTime(item.CreatedOnUtc, DateTimeKind.Utc),
                    ProductName       = product.GetLocalized(x => x.Name),
                    ProductSeName     = product.GetSeName(),
                    ProductAttributes = item.AttributeDescription,
                    ProductId         = item.ProductId
                };
                model.Items.Add(itemModel);

                if (_downloadService.IsDownloadAllowed(item))
                {
                    itemModel.DownloadId = product.DownloadId;
                }

                if (_downloadService.IsLicenseDownloadAllowed(item))
                {
                    itemModel.LicenseId = !String.IsNullOrEmpty(item.LicenseDownloadId) ? item.LicenseDownloadId : "";
                }
            }
            return(model);
        }
Exemple #6
0
        public async Task <CustomerDownloadableProductsModel> Handle(GetDownloadableProducts request, CancellationToken cancellationToken)
        {
            var model = new CustomerDownloadableProductsModel();
            var items = await _orderService.GetAllOrderItems(null, request.Customer.Id, null, null,
                                                             null, null, null, true);

            foreach (var item in items)
            {
                var order = await _orderService.GetOrderByOrderItemId(item.Id);

                var product = await _productService.GetProductByIdIncludeArch(item.ProductId);

                var itemModel = new CustomerDownloadableProductsModel.DownloadableProductsModel {
                    OrderItemGuid     = item.OrderItemGuid,
                    OrderId           = order.Id,
                    OrderNumber       = order.OrderNumber,
                    CreatedOn         = _dateTimeHelper.ConvertToUserTime(item.CreatedOnUtc, DateTimeKind.Utc),
                    ProductName       = product.GetLocalized(x => x.Name, request.Language.Id),
                    ProductSeName     = product.GetSeName(request.Language.Id),
                    ProductAttributes = item.AttributeDescription,
                    ProductId         = item.ProductId
                };
                model.Items.Add(itemModel);

                if (_downloadService.IsDownloadAllowed(order, item, product))
                {
                    itemModel.DownloadId = product.DownloadId;
                }

                if (_downloadService.IsLicenseDownloadAllowed(order, item, product))
                {
                    itemModel.LicenseId = !string.IsNullOrEmpty(item.LicenseDownloadId) ? item.LicenseDownloadId : "";
                }
            }
            return(model);
        }