Inhalte aufrufen

Profilbild
- - - - -

BundleProduct mit AttributKombinationen


  • Bitte melden Sie sich an, um eine Antwort zu verfassen.
Keine Antworten zum Thema vorhanden

#1 daniel@streetec

daniel@streetec

    Member

  • Members
  • PunktPunkt
  • 12 Beiträge

Geschrieben: 05 May 2023 - 13:46

Hi,

mit meinem Produkt Konfigurator bin ich mittlerweile schon weiter gekommen. Man kann jetzt alles konfigurieren und in den Warenkorb legen.

Angehängte Datei  Konfigurator_Produkte.png   70.9K   1 Anzahl Downloads

 

Wie man in dem Screenshot sehen kann, kann der Kunde jetzt allerdings die kostenlose Beigabe "Nabendeckel" (es gibt auch aufpreispflichtige Varianten) beliebig in der Menge anpassen, wobei deren Anzahl an die Anzahl an Basisräder gekoppelt sein müsste.

 

Meine erste Intention wäre jetzt, das ganze über Product Bundles zu lösen, was jetzt aber nicht direkt einfach ist, da es tausende von Konfigurationsmöglichkeiten des Basisrades und der Nabendeckel gibt.

 

Gibt es hier eine schöne "saubere" Variante das Problem im Rahmen meines Moduls zu lösen? Kann ich ggf. irgendwie eine Middleware für den Warenkorb Programmieren, die genau das überprüft? Oder alternativ Bundle-Produkte "on the fly" generieren?

 

Die Funktion zum in den Warenkorb legen sieht aktuell so aus:

mountingKitQuery = mountingKitQueryObject.ProductVariantQuery;

            var baseWheelProduct = await _db.Products.FirstOrDefaultAsync(p => p.Id == productId);
            var baseWheelVariant = JsonConvert.DeserializeObject<ProductVariantQuery>(baseWheelQuery);

            baseWheelVariant.AddVariant(
                new ProductVariantQueryItem(string.Empty)
                {
                    ProductId = productId.Value,
                    BundleItemId = 0,
                    AttributeId = finishAttribute.ProductAttributeId,
                    VariantAttributeId = finishAttribute.Id,
                    Value = finishAttributeValue.Id.ToString()
                });

            var mountingKitProduct = await _db.Products.FirstOrDefaultAsync(p => p.Id == _settings.MountingKitProductId);
            var mountingKitVariant = JsonConvert.DeserializeObject<ProductVariantQuery>(mountingKitQuery);

            var baseWheelCtx = new AddToCartContext()
            {
                Product = baseWheelProduct,
                VariantQuery = baseWheelVariant,
                CartType = ShoppingCartType.ShoppingCart,
                Quantity = amount ?? 4,
                CustomerEnteredPrice = new Smartstore.Core.Common.Money(),
                AutomaticallyAddBundleProducts = true,
                AutomaticallyAddRequiredProducts = false
            };

            if (!(await _shoppingCartService.AddToCartAsync(baseWheelCtx)))
            {
                return Json(new { Success = false });
            }

            var mountingKitCtx = new AddToCartContext()
            {
                Product = mountingKitProduct,
                VariantQuery = mountingKitVariant,
                CartType = ShoppingCartType.ShoppingCart,
                Quantity = amount ?? 4,
                CustomerEnteredPrice = new Smartstore.Core.Common.Money(),
                AutomaticallyAddBundleProducts = true,
                AutomaticallyAddRequiredProducts = false
            };

            if (!(await _shoppingCartService.AddToCartAsync(mountingKitCtx)))
            {
                return Json(new { Success = false });
            }

            if(rimProtectorId.HasValue)
            {
                var rimProtector = await _db.RimProtectors().FirstOrDefaultAsync(p => p.Id == rimProtectorId);
                var rimProtectorProduct = await _db.Products.FindByIdAsync(_settings.RimProtectorProductId);
                var rimProtectorQuery = JsonConvert.DeserializeObject<ProductVariantQuery>(rimProtector.ProductVariantQuery);

                var rimProtectorCtx = new AddToCartContext()
                {
                    Product = rimProtectorProduct,
                    VariantQuery = rimProtectorQuery,
                    CartType = ShoppingCartType.ShoppingCart,
                    Quantity = amount ?? 4,
                    CustomerEnteredPrice = new Money(),
                    AutomaticallyAddBundleProducts = true,
                    AutomaticallyAddRequiredProducts = false
                };

                if (!(await _shoppingCartService.AddToCartAsync(rimProtectorCtx)))
                {
                    return Json(new { Success = false });
                }
            }

            if (centerCapId.HasValue)
            {
                var centerCap = await _db.CenterCaps().FirstOrDefaultAsync(c => c.Id == centerCapId);
                var centerCapProduct = await _db.Products.FindByIdAsync(_settings.CenterCapProductId);
                var centerCapQuery = JsonConvert.DeserializeObject<ProductVariantQuery>(centerCap.ProductVariantQuery);

                var centerCapCtx = new AddToCartContext()
                {
                    Product = centerCapProduct,
                    VariantQuery = centerCapQuery,
                    CartType = ShoppingCartType.ShoppingCart,
                    Quantity = amount ?? 4,
                    CustomerEnteredPrice = new Money(),
                    AutomaticallyAddBundleProducts = true,
                    AutomaticallyAddRequiredProducts = false
                };

                if (!(await _shoppingCartService.AddToCartAsync(centerCapCtx)))
                {
                    return Json(new { Success = false });
                }
            }

            if(valveCapId.HasValue)
            {
                var valveCap = await _db.ValveCaps().FirstOrDefaultAsync(c => c.Id == valveCapId);
                var valveCapProduct = await _db.Products.FindByIdAsync(_settings.ValveCapProductId);
                var valveCapQuery = JsonConvert.DeserializeObject<ProductVariantQuery>(valveCap.ProductVariantQuery);

                var valveCapCtx = new AddToCartContext()
                {
                    Product = valveCapProduct,
                    VariantQuery = valveCapQuery,
                    CartType = ShoppingCartType.ShoppingCart,
                    Quantity = amount ?? 4,
                    CustomerEnteredPrice = new Money(),
                    AutomaticallyAddBundleProducts = true,
                    AutomaticallyAddRequiredProducts = false
                };

                if (!(await _shoppingCartService.AddToCartAsync(valveCapCtx)))
                {
                    return Json(new { Success = false });
                }
            }


            success = true;
            return Json(new { Success = success });