Expanded the product availability section

code_samples/api/product_catalog/src/Command/ProductCommand.php

@@ -2,6 +2,7 @@
 
 namespace App\Command;
 
+use App\ProductCatalog\Availability\PurchasableWithoutStockAvailabilityContext;
 use Ibexa\Contracts\Core\Repository\PermissionResolver;
 use Ibexa\Contracts\Core\Repository\UserService;
 use Ibexa\Contracts\ProductCatalog\Local\LocalProductServiceInterface;
@@ -98,26 +99,34 @@ protected function execute(InputInterface $input, OutputInterface $output): int
 
         $product = $this->productService->getProduct('NEWMODIFIEDPRODUCT');
 
-        $productAvailabilityCreateStruct = new ProductAvailabilityCreateStruct($product, true, true);
+        $productAvailabilityCreateStruct = new ProductAvailabilityCreateStruct($product, false, true);
 
         $this->productAvailabilityService->createProductAvailability($productAvailabilityCreateStruct);
 
         if ($this->productAvailabilityService->hasAvailability($product)) {
             $availability = $this->productAvailabilityService->getAvailability($product);
 
-            $output->write($availability->isAvailable() ? 'Available' : 'Unavailable');
-            $output->writeln(' with stock ' . $availability->getStock());
-
-            $availability = $this->productAvailabilityService->getAvailability($product);
+            $output->writeln($availability->getAvailability() ? 'Available flag: true' : 'Available flag: false');
+            $output->writeln($availability->getComputedAvailability() ? 'Can be ordered: true' : 'Can be ordered: false');
+            $output->writeln('Stock: ' . $availability->getStock());
 
             $productAvailabilityUpdateStruct = new ProductAvailabilityUpdateStruct($product, true, false, 80);
 
             $this->productAvailabilityService->updateProductAvailability($productAvailabilityUpdateStruct);
 
-            $output->write($availability->isAvailable() ? 'Available' : 'Unavailable');
+            $output->writeln($availability->getAvailability() ? 'Available flag: true' : 'Available flag: false');
+            $output->writeln($availability->getComputedAvailability() ? 'Can be ordered: true' : 'Can be ordered: false');
             $output->writeln(' available now with stock ' . $availability->getStock());
         }
 
+        $availability = $this->productAvailabilityService->getAvailability(
+            $product,
+            new PurchasableWithoutStockAvailabilityContext()
+        );
+
+        $canBeOrdered = $availability->getComputedAvailability();
+        $output->writeln('Can be ordered: ' . ($canBeOrdered ? 'true' : 'false') . ', Stock: ' . $availability->getStock());
+
         $this->localProductService->deleteProduct($product);
 
         return self::SUCCESS;

code_samples/pim/availability/config/custom_services.yaml

@@ -0,0 +1,4 @@
+services:
+    App\ProductCatalog\Availability\ProductAvailabilityPurchasableWithoutStockStrategy:
+        tags:
+            - { name: ibexa.product_catalog.availability.strategy }

code_samples/pim/availability/src/ProductAvailabilityPurchasableWithoutStockStrategy.php

@@ -0,0 +1,70 @@
+<?php declare(strict_types=1);
+
+namespace App\ProductCatalog\Availability;
+
+use Ibexa\Contracts\ProductCatalog\ProductAvailabilityStrategyInterface;
+use Ibexa\Contracts\ProductCatalog\Values\Availability\AvailabilityContextInterface;
+use Ibexa\Contracts\ProductCatalog\Values\Availability\AvailabilityInterface;
+use Ibexa\Contracts\ProductCatalog\Values\ProductInterface;
+use Ibexa\ProductCatalog\Local\Persistence\Legacy\ProductAvailability\HandlerInterface;
+use Ibexa\ProductCatalog\Local\Repository\Values\Availability;
+
+final class ProductAvailabilityPurchasableWithoutStockStrategy implements ProductAvailabilityStrategyInterface
+{
+    private HandlerInterface $handler;
+
+    public function __construct(HandlerInterface $handler)
+    {
+        $this->handler = $handler;
+    }
+
+    public function accept(AvailabilityContextInterface $context): bool
+    {
+        return $context instanceof PurchasableWithoutStockAvailabilityContext;
+    }
+
+    public function getProductAvailability(
+        ProductInterface $product,
+        AvailabilityContextInterface $context
+    ): AvailabilityInterface {
+        $productAvailability = $this->handler->find($product->getCode());
+
+        $rawAvailableFlag = $productAvailability->isAvailable();
+        $stock = $productAvailability->getStock();
+        $isInfinite = $productAvailability->isInfinite();
+
+        $computedAvailable = $this->calculateAvailability(
+            $rawAvailableFlag,
+            $stock,
+            $isInfinite,
+        );
+
+        return new Availability(
+            $product,
+            $rawAvailableFlag,
+            $computedAvailable,
+            $isInfinite,
+            $stock,
+        );
+    }
+
+    private function calculateAvailability(
+        bool $rawAvailable,
+        ?int $stock,
+        bool $isInfinite
+    ): bool {
+        if ($rawAvailable === false) {
+            return false;
+        }
+
+        if ($isInfinite) {
+            return true;
+        }
+
+        if ($stock === null) {
+            return true;
+        }
+
+        return $stock >= 0;
+    }
+}

code_samples/pim/availability/src/PurchasableWithoutStockAvailabilityContext.php

@@ -0,0 +1,9 @@
+<?php declare(strict_types=1);
+
+namespace App\ProductCatalog\Availability;
+
+use Ibexa\Contracts\ProductCatalog\Values\Availability\AvailabilityContextInterface;
+
+final class PurchasableWithoutStockAvailabilityContext implements AvailabilityContextInterface
+{
+}

docs/pim/create_custom_availability_strategy.md

@@ -0,0 +1,54 @@
+---
+description: Implement custom availability strategies to handle different business scenarios, for example pre-orders or per-region availability.
+---
+
+# Create custom availability strategy
+
+The product catalog uses an availability strategy to calculate [computed availability](products.md#availability-and-computed-availability) for a product.
+Computed availability decides whether the customers can order the product.
+The default availability strategy is based on the product availability and stock amount.
+
+You can replace this logic with a custom strategy to handle specific business scenarios, for example preorders, minimum order quantities, or per-region availability.
+
+The following example implements an availability strategy which allows buying products when they're set as available, without taking their stock into account.
+You could use it for [virtual products](products.md#product-types) or in preorder scenarios.
+
+## Create custom availability context
+
+Use an availability context to pass the parameters needed by the strategy to evaluate computed availability.
+To do it, create a class that implements the [`AvailabilityContextInterface`](/api/php_api/php_api_reference/classes/Ibexa-Contracts-ProductCatalog-Values-Availability-AvailabilityContextInterface.html) interface:
+
+``` php
+[[= include_file('code_samples/pim/availability/src/PurchasableWithoutStockAvailabilityContext.php') =]]
+```
+
+## Create custom availability strategy
+
+Create a class that implements the [`ProductAvailabilityStrategyInterface`](/api/php_api/php_api_reference/classes/Ibexa-Contracts-ProductCatalog-ProductAvailabilityStrategyInterface.html) interface:
+
+``` php
+[[= include_file('code_samples/pim/availability/src/ProductAvailabilityPurchasableWithoutStockStrategy.php') =]]
+```
+
+The strategy has two methods:
+
+- `accept()` decides if the strategy can handle the provided availability context
+- `getProductAvailability()` returns an [`AvailabilityInterface`](/api/php_api/php_api_reference/classes/Ibexa-Contracts-ProductCatalog-Values-Availability-AvailabilityInterface.html) object
+
+When constructing the `AvailabilityInterface` object, provide the stock amount, the availability flag, and the result of your custom availability logic.
+
+## Register strategy as a service
+
+If you're not using [autowiring]([[= symfony_doc =]]/service_container/autowiring.html), tag the strategy service with `ibexa.product_catalog.availability.strategy`:
+
+``` yaml
+[[= include_file('code_samples/pim/availability/config/custom_services.yaml') =]]
+```
+
+## Use custom context
+
+To evaluate product availability using a custom strategy, pass the custom context as the second argument to [`ProductAvailabilityServiceInterface::getAvailability()`](/api/php_api/php_api_reference/classes/Ibexa-Contracts-ProductCatalog-ProductAvailabilityServiceInterface.html):
+
+```php
+[[= include_code('code_samples/api/product_catalog/src/Command/ProductCommand.php', 122, 127, remove_indent=True) =]]
+```

docs/pim/customize_pim.md

@@ -12,4 +12,5 @@ You can customize various areas of the Product Information Management solution t
     "pim/create_product_code_generator",
     "pim/create_custom_catalog_filter",
     "pim/create_custom_name_schema_strategy",
+    "pim/create_custom_availability_strategy",
 ], columns=4) =]]