public ActionResult VariantExists(VariantPickerVariantExistsViewModel viewModel)
        {
            var getProductResponse = new GetProductResponse();

            if (_getProductPipeline.Execute(new GetProductPipelineArgs(new GetProductRequest(new ProductIdentifier(viewModel.ProductSku, null)), getProductResponse)) == PipelineExecutionResult.Error)
            {
                return(Json(new { ProductVariantSku = "" }));
            }

            var product = getProductResponse.Product;

            if (!product.ProductDefinition.IsProductFamily())
            {
                return(Json(new { ProductVariantSku = "" }));
            }
            if (!viewModel.VariantNameValueDictionary.Any())
            {
                return(Json(new { ProductVariantSku = "" }));
            }

            var variant = product.Variants.FirstOrDefault(v => v.ProductProperties
                                                          .Where(pp => pp.ProductDefinitionField.DisplayOnSite)
                                                          .Where(pp => pp.ProductDefinitionField.IsVariantProperty)
                                                          .Where(pp => !pp.ProductDefinitionField.Deleted)
                                                          .All(p => viewModel.VariantNameValueDictionary
                                                               .Any(kv => kv.Key.Equals(p.ProductDefinitionField.Name, StringComparison.InvariantCultureIgnoreCase) && kv.Value.Equals(p.Value, StringComparison.InvariantCultureIgnoreCase)))
                                                          );
            var variantSku = variant != null ? variant.VariantSku : "";


            return(Json(new { ProductVariantSku = variantSku }));
        }
Example #2
0
        public ActionResult VariantExists(VariantPickerVariantExistsViewModel viewModel)
        {
            Ucommerce.Search.Models.Product product;
            try
            {
                product = _catalogLibrary.GetProduct(viewModel.ProductSku);
            }
            catch (Exception e)
            {
                return(Json(new { ProductVariantSku = "" }));
            }

            if (product.ProductType != ProductType.ProductFamily)
            {
                return(Json(new { ProductVariantSku = "" }));
            }
            if (!viewModel.VariantNameValueDictionary.Any())
            {
                return(Json(new { ProductVariantSku = "" }));
            }

            var variant =
                _catalogLibrary
                .GetVariants(product)
                .FirstOrDefault(v => v.GetUserDefinedFields()
                                .All(variantProperty => viewModel.VariantNameValueDictionary
                                     .Any(kvp =>
                                          kvp.Key.Equals(variantProperty.Key, StringComparison.InvariantCultureIgnoreCase) &&
                                          kvp.Value.Equals(variantProperty.Value.ToString(), StringComparison.InvariantCultureIgnoreCase))));

            var variantSku = variant != null ? variant.VariantSku : "";


            return(Json(new { ProductVariantSku = variantSku }));
        }
Example #3
0
        public ActionResult GetAvailableCombinations(VariantPickerVariantExistsViewModel viewModel)
        {
            var selectedDictionary = viewModel.VariantNameValueDictionary.Where(x => x.Value != "").ToList();

            var currentProduct = _catalogLibrary.GetProduct(viewModel.ProductSku);

            IList <ProductPropertiesViewModel>      result           = new List <ProductPropertiesViewModel>();
            IList <Ucommerce.Search.Models.Product> possibleVariants = new List <Ucommerce.Search.Models.Product>();

            foreach (var kvp in selectedDictionary)
            {
                var variants = _catalogLibrary.GetVariants(currentProduct);

                foreach (var v in variants)
                {
                    if (v.GetUserDefinedFields().Any(x =>
                                                     x.Key.Equals(kvp.Key, StringComparison.InvariantCultureIgnoreCase) &&
                                                     x.Value.ToString().Equals(kvp.Value, StringComparison.InvariantCultureIgnoreCase)))
                    {
                        possibleVariants.Add(v);
                    }
                }

                foreach (var possibleVariant in possibleVariants)
                {
                    var properties = possibleVariant.GetUserDefinedFields()
                                     .Where(property => !property.Key.ToString().Equals(kvp.Key.ToString(), StringComparison.InvariantCultureIgnoreCase) &&
                                            !property.Value.ToString().Equals(kvp.Value.ToString(), StringComparison.InvariantCultureIgnoreCase));

                    foreach (var prop in properties)
                    {
                        ProductPropertiesViewModel property = new ProductPropertiesViewModel();
                        property.PropertyName = prop.Key;
                        property.Values.Add(prop.Value.ToString());

                        result.Add(property);
                    }
                }
            }

            return(Json(new { properties = result }));
        }
        public ActionResult GetAvailableCombinations(VariantPickerVariantExistsViewModel viewModel)
        {
            var selectedDictionary = viewModel.VariantNameValueDictionary.Where(x => x.Value != "").ToList();

            var currentProduct = _catalogLibraryInternal.GetProduct(viewModel.ProductSku);

            IList <ProductPropertiesViewModel> result = new List <ProductPropertiesViewModel>();
            IList <Product> possibleVariants          = new List <Product>();

            foreach (var kvp in selectedDictionary)
            {
                var variants = currentProduct.Variants;
                foreach (var v in variants)
                {
                    if (v.ProductProperties.Any(x => x.ProductDefinitionField.Name == kvp.Key && x.Value == kvp.Value))
                    {
                        possibleVariants.Add(v);
                    }
                }

                foreach (var possibleVariant in possibleVariants)
                {
                    var properties = ProductProperty.All()
                                     .Where(x => x.ProductDefinitionField.Name != kvp.Key && x.Value != kvp.Value && x.Product == possibleVariant).Distinct();
                    foreach (var prop in properties)
                    {
                        ProductPropertiesViewModel property = new ProductPropertiesViewModel();
                        property.PropertyName = prop.ProductDefinitionField.Name;
                        property.Values.Add(prop.Value);

                        result.Add(property);
                    }
                }
            }

            return(Json(new { properties = result }));
        }