feat(cart): enhance item update functionality to support variant changes and stock management; update related request validation and resource formatting; add tests for variant handling in cart

2026-08-10 12:08:09 -03:00 · 2026-08-10 12:08:09 -03:00 · c6351d706f
parent 2693df2cbf
commit c6351d706f
8 changed files with 225 additions and 15 deletions
--- a/app/Domains/Cart/Controllers/CartController.php
+++ b/app/Domains/Cart/Controllers/CartController.php
@ -54,16 +54,26 @@ class CartController extends Controller
        Tenant $tenant,
        CartItem $cartItem,
    ): CartResource {
+        $updatesVariant = $request->exists('variant_id');
+
        return CartResource::make(
-            $this->cartService->updateItemQuantity(
+            $this->cartService->updateItem(
                $tenant,
                $request,
                $cartItem->getKey(),
                (int) $request->validated('cantidad'),
+                $updatesVariant
+                    ? ($request->validated('variant_id') !== null
+                        ? (int) $request->validated('variant_id')
+                        : null)
+                    : $cartItem->variant_id,
+                $updatesVariant,
            )
        )->additional([
-            'code' => 'cart.quantity_updated',
-            'message' => __('api.cart.quantity_updated'),
+            'code' => $updatesVariant ? 'cart.item_updated' : 'cart.quantity_updated',
+            'message' => $updatesVariant
+                ? __('api.cart.item_updated')
+                : __('api.cart.quantity_updated'),
        ]);
    }

--- a/app/Domains/Cart/Models/Cart.php
+++ b/app/Domains/Cart/Models/Cart.php
@ -124,27 +124,85 @@ class Cart extends Model
        });
    }

-    public function updateItem(int $cartItemId, int $quantity): CartItem
-    {
+    public function updateItem(
+        int $cartItemId,
+        int $quantity,
+        ?int $variantId = null,
+        bool $updateVariant = false,
+    ): CartItem {
        if ($quantity <= 0) {
            throw ValidationException::withMessages([
                'cantidad' => __('api.cart.positive_quantity'),
            ]);
        }

-        return DB::transaction(function () use ($cartItemId, $quantity): CartItem {
+        return DB::transaction(function () use (
+            $cartItemId,
+            $quantity,
+            $variantId,
+            $updateVariant,
+        ): CartItem {
            /** @var CartItem $item */
            $item = $this->items()
                ->where('id', $cartItemId)
                ->lockForUpdate()
                ->firstOrFail();

-            $selectedItem = $this->resolveScopedItem(
+            $currentSelection = $this->resolveScopedItem(
                $item->catalog_item_id,
                $item->variant_id,
                true,
            );
            $inventoryService = app(CatalogInventoryService::class);
+
+            if ($updateVariant && $variantId !== $item->variant_id) {
+                $nextSelection = $this->resolveScopedItem(
+                    $item->catalog_item_id,
+                    $variantId,
+                    true,
+                );
+                $otherVariantsQuantity = (int) $this->items()
+                    ->where('catalog_item_id', $item->catalog_item_id)
+                    ->whereKeyNot($item->getKey())
+                    ->sum('cantidad');
+                $this->assertUserPurchaseLimit(
+                    $nextSelection,
+                    $otherVariantsQuantity + $quantity,
+                );
+
+                $inventoryService->release($currentSelection, $item->cantidad);
+                $availableQuantity = $inventoryService->availableQuantity($nextSelection);
+
+                if ($availableQuantity !== null && $availableQuantity < $quantity) {
+                    throw ValidationException::withMessages([
+                        'variant_id' => __('api.cart.insufficient_stock', ['max' => $availableQuantity]),
+                    ]);
+                }
+
+                $targetItem = $this->items()
+                    ->where('catalog_item_id', $item->catalog_item_id)
+                    ->where('variant_id', $variantId)
+                    ->whereKeyNot($item->getKey())
+                    ->lockForUpdate()
+                    ->first();
+
+                $inventoryService->reserve($nextSelection, $quantity);
+
+                if ($targetItem !== null) {
+                    $targetItem->cantidad += $quantity;
+                    $targetItem->save();
+                    $item->delete();
+
+                    return $targetItem->fresh();
+                }
+
+                $item->variant_id = $variantId;
+                $item->cantidad = $quantity;
+                $item->save();
+
+                return $item->fresh();
+            }
+
            $delta = $quantity - $item->cantidad;

            if ($delta > 0) {
@ -153,12 +211,12 @@ class Cart extends Model
                    ->whereKeyNot($item->getKey())
                    ->sum('cantidad');
                $this->assertUserPurchaseLimit(
-                    $selectedItem,
+                    $currentSelection,
                    $otherVariantsQuantity + $quantity,
                );
            }

-            $availableQuantity = $inventoryService->availableQuantity($selectedItem);
+            $availableQuantity = $inventoryService->availableQuantity($currentSelection);

            if ($delta > 0 && $availableQuantity !== null && $availableQuantity < $delta) {
                $maxAvailable = $availableQuantity + $item->cantidad;
@ -171,11 +229,11 @@ class Cart extends Model
            $item->save();

            if ($delta > 0) {
-                $inventoryService->reserve($selectedItem, $delta);
+                $inventoryService->reserve($currentSelection, $delta);
            }

            if ($delta < 0) {
-                $inventoryService->release($selectedItem, abs($delta));
+                $inventoryService->release($currentSelection, abs($delta));
            }

            return $item->fresh();
--- a/app/Domains/Cart/Requests/UpdateCartItemQuantityRequest.php
+++ b/app/Domains/Cart/Requests/UpdateCartItemQuantityRequest.php
@ -19,7 +19,7 @@ class UpdateCartItemQuantityRequest extends FormRequest
        return [
            'cantidad' => ['required', 'integer', 'min:1'],
            'catalog_item_id' => ['prohibited'],
-            'variant_id' => ['prohibited'],
+            'variant_id' => ['sometimes', 'nullable', 'integer'],
        ];
    }
 }
--- a/app/Domains/Cart/Resources/CartItemResource.php
+++ b/app/Domains/Cart/Resources/CartItemResource.php
@ -3,8 +3,11 @@
 namespace App\Domains\Cart\Resources;

 use App\Domains\Cart\Models\CartItem;
+use App\Domains\Catalog\Enums\InventoryPolicy;
+use App\Domains\Catalog\Models\Variant;
 use Illuminate\Http\Request;
 use Illuminate\Http\Resources\Json\JsonResource;
+use Illuminate\Support\Collection;

 /**
 * @mixin CartItem
@ -36,10 +39,42 @@ class CartItemResource extends JsonResource
            'product' => $selectedItem === null ? null : [
                'nombre' => $selectedItem->getName(),
                'imagen' => $imageUrl,
+                'variants' => $this->catalogItem->variants
+                    ->map(fn (Variant $variant): array => [
+                        'id' => $variant->id,
+                        'precio' => $this->formatMoney($variant->getPrice()),
+                        'stock_tecnico' => $this->catalogItem->inventory_policy === InventoryPolicy::Unlimited
+                            ? null
+                            : $variant->inventory->availableStock(),
+                        'values' => $this->variantValues($variant),
+                    ])
+                    ->values(),
            ],
        ];
    }

+    /** @return Collection<string, string|array<int, string>> */
+    private function variantValues(Variant $variant): Collection
+    {
+        $values = $variant->selectionValues();
+        $eventDates = $variant->selectedEventDates();
+
+        if ($eventDates->isNotEmpty()) {
+            $labels = $eventDates
+                ->map(fn ($eventDate): string => $eventDate->date->format('d/m/Y').' · '
+                    .substr($eventDate->time_start, 0, 5).' a '
+                    .substr($eventDate->time_end, 0, 5))
+                ->values();
+
+            $values->put(
+                'event_date',
+                $labels->count() === 1 ? $labels->first() : $labels->all(),
+            );
+        }
+
+        return $values;
+    }
+
    protected function formatMoney(float|int|string|null $amount): string
    {
        return number_format((float) ($amount ?? 0), 2, '.', '');
--- a/app/Domains/Cart/Services/CartService.php
+++ b/app/Domains/Cart/Services/CartService.php
@ -51,11 +51,17 @@ class CartService
        ];
    }

-    public function updateItemQuantity(Tenant $tenant, Request $request, int $cartItemId, int $quantity): Cart
-    {
+    public function updateItem(
+        Tenant $tenant,
+        Request $request,
+        int $cartItemId,
+        int $quantity,
+        ?int $variantId,
+        bool $updateVariant,
+    ): Cart {
        $identity = $this->requireIdentity($request);
        $cart = $this->findCartOrFail($tenant, $identity);
-        $cart->updateItem($cartItemId, $quantity);
+        $cart->updateItem($cartItemId, $quantity, $variantId, $updateVariant);

        return $this->loadCart($cart);
    }
@ -101,6 +107,10 @@ class CartService
        return $cart->fresh()->load([
            'items.catalogItem.attachments',
            'items.catalogItem.inventory',
+            'items.catalogItem.variants.inventory',
+            'items.catalogItem.variants.definitions.itemAttribute.attribute',
+            'items.catalogItem.variants.eventDates',
+            'items.catalogItem.variants.eventDate',
            'items.variant.attachments',
            'items.variant.inventory',
            'items.variant.definitions.itemAttribute.attribute',
--- a/lang/en/api.php
+++ b/lang/en/api.php
@ -24,6 +24,7 @@ return [
    'cart' => [
        'item_added' => 'Product added to cart.',
        'quantity_updated' => 'Product quantity updated.',
+        'item_updated' => 'Product updated.',
        'item_removed' => 'Product removed from cart.',
        'positive_quantity' => 'The quantity must be greater than zero.',
        'insufficient_stock' => 'There is not enough stock for the requested product. Maximum available: :max.',
--- a/lang/es/api.php
+++ b/lang/es/api.php
@ -24,6 +24,7 @@ return [
    'cart' => [
        'item_added' => 'Producto agregado al carrito.',
        'quantity_updated' => 'Cantidad de producto actualizada.',
+        'item_updated' => 'Producto actualizado.',
        'item_removed' => 'Producto eliminado del carrito.',
        'positive_quantity' => 'La cantidad debe ser mayor a cero.',
        'insufficient_stock' => 'Stock insuficiente para el producto solicitado. Máximo disponible: :max.',
--- a/tests/Feature/Cart/CartControllerTest.php
+++ b/tests/Feature/Cart/CartControllerTest.php
@ -256,6 +256,101 @@ class CartControllerTest extends TestCase
        ]);
    }

+    public function test_it_changes_an_item_variant_and_moves_the_stock_reservation(): void
+    {
+        $tenant = $this->createTenant('acme');
+        [$item, $firstVariant] = $this->createVariantItem($tenant, 10, '15.00');
+        $secondInventory = Inventory::query()->create(['real_stock' => 8]);
+        $secondVariant = $item->variants()->create([
+            'inventory_id' => $secondInventory->id,
+            'precio' => '20.00',
+        ]);
+        $createResponse = $this->postJson('/api/tenants/acme/cart/items', [
+            'catalog_item_id' => $item->id,
+            'variant_id' => $firstVariant->id,
+            'cantidad' => 2,
+        ]);
+        $guestToken = $createResponse->getCookie('guest_token', false)?->getValue();
+        $cartItemId = $createResponse->json('data.items.0.id');
+
+        $this->call(
+            'PATCH',
+            "/api/tenants/acme/cart/items/{$cartItemId}",
+            [],
+            ['guest_token' => $guestToken],
+            [],
+            ['HTTP_Accept' => 'application/json', 'CONTENT_TYPE' => 'application/json'],
+            json_encode(['cantidad' => 2, 'variant_id' => $secondVariant->id]),
+        )
+            ->assertOk()
+            ->assertJsonPath('data.items.0.variant_id', $secondVariant->id)
+            ->assertJsonPath('data.items.0.precio_unitario', '20.00')
+            ->assertJsonCount(2, 'data.items.0.product.variants');
+
+        $this->assertDatabaseHas('inventories', [
+            'id' => $firstVariant->inventory_id,
+            'reserved_stock' => 0,
+        ]);
+        $this->assertDatabaseHas('inventories', [
+            'id' => $secondInventory->id,
+            'reserved_stock' => 2,
+        ]);
+    }
+
+    public function test_changing_to_a_variant_already_in_the_cart_merges_both_rows(): void
+    {
+        $tenant = $this->createTenant('acme');
+        [$item, $firstVariant] = $this->createVariantItem($tenant, 10, '15.00');
+        $secondInventory = Inventory::query()->create(['real_stock' => 10]);
+        $secondVariant = $item->variants()->create(['inventory_id' => $secondInventory->id]);
+
+        $firstResponse = $this->postJson('/api/tenants/acme/cart/items', [
+            'catalog_item_id' => $item->id,
+            'variant_id' => $firstVariant->id,
+            'cantidad' => 2,
+        ]);
+        $guestToken = $firstResponse->getCookie('guest_token', false)?->getValue();
+        $firstCartItemId = $firstResponse->json('data.items.0.id');
+
+        $this->call(
+            'POST',
+            '/api/tenants/acme/cart/items',
+            [],
+            ['guest_token' => $guestToken],
+            [],
+            ['HTTP_Accept' => 'application/json', 'CONTENT_TYPE' => 'application/json'],
+            json_encode([
+                'catalog_item_id' => $item->id,
+                'variant_id' => $secondVariant->id,
+                'cantidad' => 3,
+            ]),
+        )->assertOk();
+
+        $this->call(
+            'PATCH',
+            "/api/tenants/acme/cart/items/{$firstCartItemId}",
+            [],
+            ['guest_token' => $guestToken],
+            [],
+            ['HTTP_Accept' => 'application/json', 'CONTENT_TYPE' => 'application/json'],
+            json_encode(['cantidad' => 2, 'variant_id' => $secondVariant->id]),
+        )
+            ->assertOk()
+            ->assertJsonCount(1, 'data.items')
+            ->assertJsonPath('data.items.0.variant_id', $secondVariant->id)
+            ->assertJsonPath('data.items.0.cantidad', 5);
+
+        $this->assertDatabaseCount('carrito_items', 1);
+        $this->assertDatabaseHas('inventories', [
+            'id' => $firstVariant->inventory_id,
+            'reserved_stock' => 0,
+        ]);
+        $this->assertDatabaseHas('inventories', [
+            'id' => $secondInventory->id,
+            'reserved_stock' => 5,
+        ]);
+    }
+
    public function test_it_requires_a_variant_when_the_item_has_variant_inventory(): void
    {
        $tenant = $this->createTenant('acme');