[Global] Disponibilité produit : amélioration isProductAvailable()

Builder/Order/OrderShopBuilder.php

 use Doctrine\ORM\EntityManagerInterface;
 use Lc\CaracoleBundle\Builder\Credit\CreditHistoryBuilder;
 use Lc\CaracoleBundle\Builder\File\DocumentBuilder;
+use Lc\CaracoleBundle\Event\Order\CartChangeEvent;
 use Lc\CaracoleBundle\Event\Order\OrderShopChangeStatusEvent;
 use Lc\CaracoleBundle\Factory\Credit\CreditHistoryFactory;
 use Lc\CaracoleBundle\Factory\File\DocumentFactory;
     protected FlashBagTranslator $flashBagTranslator;
 
     public function __construct(
-        EntityManagerInterface             $entityManager,
-        OrderShopStore                     $orderShopStore,
-        OrderShopSolver                    $orderShopSolver,
-        OrderStatusStore                   $orderStatusStore,
-        OrderProductStore                  $orderProductStore,
-        ProductFamilyStore                 $productFamilyStore,
-        OrderProductBuilder                $orderProductBuilder,
-        DocumentBuilder                    $documentBuilder,
-        PriceSolver                        $priceSolver,
-        EventDispatcherInterface           $eventDispatcher,
-        FlashBagInterface                  $flashBag,
-        OpeningResolver                    $openingResolver,
-        ProductSolver                      $productSolver,
-        OrderShopResolver                  $orderShopResolver,
-        OrderProductReductionCatalogSolver $orderProductReductionCatalogSolver,
-        DistributionBuilder                $distributionBuilder,
-        MerchantResolver                   $merchantResolver,
-        CreditHistoryBuilder               $creditHistoryBuilder,
-        FlashBagTranslator                 $flashBagTranslator
-    )
-    {
+            EntityManagerInterface $entityManager,
+            OrderShopStore $orderShopStore,
+            OrderShopSolver $orderShopSolver,
+            OrderStatusStore $orderStatusStore,
+            OrderProductStore $orderProductStore,
+            ProductFamilyStore $productFamilyStore,
+            OrderProductBuilder $orderProductBuilder,
+            DocumentBuilder $documentBuilder,
+            PriceSolver $priceSolver,
+            EventDispatcherInterface $eventDispatcher,
+            FlashBagInterface $flashBag,
+            OpeningResolver $openingResolver,
+            ProductSolver $productSolver,
+            OrderShopResolver $orderShopResolver,
+            OrderProductReductionCatalogSolver $orderProductReductionCatalogSolver,
+            DistributionBuilder $distributionBuilder,
+            MerchantResolver $merchantResolver,
+            CreditHistoryBuilder $creditHistoryBuilder,
+            FlashBagTranslator $flashBagTranslator
+    ) {
         $this->entityManager = $entityManager;
         $this->orderShopStore = $orderShopStore;
         $this->orderShopSolver = $orderShopSolver;
     }
 
     public function create(
-        SectionInterface $section,
-        UserInterface    $user = null,
-        VisitorInterface $visitor = null
-    ): OrderShopInterface
-    {
+            SectionInterface $section,
+            UserInterface $user = null,
+            VisitorInterface $visitor = null
+    ): OrderShopInterface {
         $orderShopFactory = new OrderShopFactory();
         $orderShop = $orderShopFactory->create($section, $user, $visitor);
 
     protected array $cacheCartCurrentBySection = [];
 
     public function createIfNotExist(
-        SectionInterface $section,
-        UserInterface    $user = null,
-        VisitorInterface $visitor = null,
-        bool             $cache = false
-    ): OrderShopInterface
-    {
-
+            SectionInterface $section,
+            UserInterface $user = null,
+            VisitorInterface $visitor = null,
+            bool $cache = false
+    ): OrderShopInterface {
         $cart = null;
 
         // cache
         $cacheIdCartCurrent = 'cart_current_' . $section->getId();
         if ($cache
-            && isset($this->cacheCartCurrentBySection[$cacheIdCartCurrent])
-            && $this->cacheCartCurrentBySection[$cacheIdCartCurrent]) {
-
+                && isset($this->cacheCartCurrentBySection[$cacheIdCartCurrent])
+                && $this->cacheCartCurrentBySection[$cacheIdCartCurrent]) {
             return $this->cacheCartCurrentBySection[$cacheIdCartCurrent];
         }
 
             if ($cartUser) {
                 $cart = $cartUser;
             } elseif ($cartVisitor) {
-
                 if ($user && $cartVisitor && !$cartVisitor->getUser()) {
                     $cartVisitor->setUser($user);
                     $this->entityManager->update($cartVisitor);
     }
 
     public function setOrderStatus(
-        OrderShopInterface $orderShop,
-        string             $alias,
-        bool               $forceByAdmin = false
-    ): OrderShopInterface
-    {
+            OrderShopInterface $orderShop,
+            string $alias,
+            bool $forceByAdmin = false
+    ): OrderShopInterface {
         $orderStatus = $this->orderStatusStore->getOneByAlias($alias);
 
         if ($orderStatus) {
             if ($orderShop->getOrderStatus() === null
-                || $orderShop->getOrderStatus()->getNextStatusAllowed()->contains($orderStatus)) {
+                    || $orderShop->getOrderStatus()->getNextStatusAllowed()->contains($orderStatus)) {
                 $this->applyChangeOrderStatus($orderShop, $orderStatus, $forceByAdmin);
             }
         } else {
     }
 
     public function applyChangeOrderStatus(
-        OrderShopInterface   $orderShop,
-        OrderStatusInterface $orderStatus,
-        bool                 $forceByAdmin = false
-    ): void
-    {
+            OrderShopInterface $orderShop,
+            OrderStatusInterface $orderStatus,
+            bool $forceByAdmin = false
+    ): void {
         $this->eventDispatcher->dispatch(
-            new OrderShopChangeStatusEvent($orderShop, $orderStatus, $forceByAdmin),
-            OrderShopChangeStatusEvent::PRE_CHANGE_STATUS
+                new OrderShopChangeStatusEvent($orderShop, $orderStatus, $forceByAdmin),
+                OrderShopChangeStatusEvent::PRE_CHANGE_STATUS
         );
 
         $orderShop->setOrderStatusProtected($orderStatus);
         $orderShop->addOrderStatusHistory($orderStatusHistory);
 
         $this->eventDispatcher->dispatch(
-            new OrderShopChangeStatusEvent($orderShop, $orderStatus, $forceByAdmin),
-            OrderShopChangeStatusEvent::POST_CHANGE_STATUS
+                new OrderShopChangeStatusEvent($orderShop, $orderStatus, $forceByAdmin),
+                OrderShopChangeStatusEvent::POST_CHANGE_STATUS
         );
     }
 
     public function addOrderProduct(
-        OrderShopInterface    $orderShop,
-        OrderProductInterface $orderProductAdd,
-        bool                  $persist = true
-    ): bool
-    {
+            OrderShopInterface $orderShop,
+            OrderProductInterface $orderProductAdd,
+            bool $persist = true
+    ): bool {
         $return = false;
 
         if ($this->orderShopSolver->isOrderProductAvailableAddCart($orderProductAdd, $orderShop)) {
                 $updated = false;
                 $this->orderProductBuilder->init($orderProductAdd);
                 $productFamily = $this->productFamilyStore->setSection($orderShop->getSection())->getOneBySlug(
-                    $orderProductAdd->getProduct()->getProductFamily()->getSlug()
+                        $orderProductAdd->getProduct()->getProductFamily()->getSlug()
                 );
 
                 if ($productFamily) {
                     if ($reductionCatalog && $reductionCatalog->getStatus()) {
                         $orderProductReductionCatalogFactory = new OrderProductReductionCatalogFactory();
                         $orderProductReductionCatalog = $orderProductReductionCatalogFactory->create(
-                            $reductionCatalog->getTitle(),
-                            $reductionCatalog->getValue(),
-                            $reductionCatalog->getUnit(),
-                            $reductionCatalog->getBehaviorTaxRate()
+                                $reductionCatalog->getTitle(),
+                                $reductionCatalog->getValue(),
+                                $reductionCatalog->getUnit(),
+                                $reductionCatalog->getBehaviorTaxRate()
                         );
 
                         $orderProductAdd->setOrderProductReductionCatalog($orderProductReductionCatalog);
 
                 foreach ($orderShop->getOrderProducts() as $orderProduct) {
                     if ($orderProduct->getProduct()->getId() == $orderProductAdd->getProduct()->getId()
-                        && $orderProduct->getRedelivery() == $orderProductAdd->getRedelivery()
-                        && (string)$this->priceSolver->getPrice($orderProduct)
-                        == (string)$this->priceSolver->getPrice($orderProductAdd)
-                        && $this->orderProductReductionCatalogSolver->compare(
-                            $orderProduct->getOrderProductReductionCatalog(),
-                            $orderProductAdd->getOrderProductReductionCatalog()
-                        )) {
+                            && $orderProduct->getRedelivery() == $orderProductAdd->getRedelivery()
+                            && (string)$this->priceSolver->getPrice($orderProduct)
+                            == (string)$this->priceSolver->getPrice($orderProductAdd)
+                            && $this->orderProductReductionCatalogSolver->compare(
+                                    $orderProduct->getOrderProductReductionCatalog(),
+                                    $orderProductAdd->getOrderProductReductionCatalog()
+                            )) {
                         $orderProduct->setQuantityOrder(
-                            $orderProduct->getQuantityOrder() + $orderProductAdd->getQuantityOrder()
+                                $orderProduct->getQuantityOrder() + $orderProductAdd->getQuantityOrder()
                         );
 
                         if ($persist) {
                         if (isset($orderProductReductionCatalog)) {
                             $this->entityManager->create($orderProductReductionCatalog);
                         }
-                        //TODO est-ce un update ou un create ???
+                        // @TODO : update ou create ?
                         $this->entityManager->persist($orderProductAdd);
                         $this->entityManager->update($orderShop);
                     }
 
                 if ($persist) {
                     $this->entityManager->flush();
+                    $this->eventDispatcher->dispatch(new CartChangeEvent($orderShop), CartChangeEvent::POST_UPDATE);
                 }
-
-                // @TODO : dispatch event cart change
-                //$this->eventCartChange($orderShop);
             }
         } else {
             // @TODO : retourner le message d'erreur et faire le addFlash dans le contrôleur
                 }
             }
             $this->utils->addFlash('error', $textError);*/
+
+            $return = false;
         }
 
         return $return;
     }
 
     public function merge(
-        OrderShopInterface $orderShop1,
-        OrderShopInterface $orderShop2,
-                           $persist = true
-    ): OrderShopInterface
-    {
+            OrderShopInterface $orderShop1,
+            OrderShopInterface $orderShop2,
+            $persist = true
+    ): OrderShopInterface {
         //TODO essayer de comprendre prk on doit faire un refresh ici ???
         $this->entityManager->refresh($orderShop1);
         $this->entityManager->refresh($orderShop2);
         if ($orderShop1 && $orderShop2) {
             foreach ($orderShop2->getOrderProducts() as $orderProduct) {
-                $orderProductAlreadyInCart = $this->orderShopSolver->hasOrderProductAlreadyInCart($orderShop1, $orderProduct);
+                $orderProductAlreadyInCart = $this->orderShopSolver->hasOrderProductAlreadyInCart(
+                        $orderShop1,
+                        $orderProduct
+                );
 
                 if ($orderProductAlreadyInCart) {
                     if ($orderProduct->getQuantityOrder() > $orderProductAlreadyInCart->getQuantityOrder()) {
         $orderShop->addOrderPayment($orderPayment);
 
         if ($meanPayment == OrderPaymentModel::MEAN_PAYMENT_CREDIT) {
-            $this->creditHistoryBuilder->create(CreditHistoryModel::TYPE_DEBIT, $this->merchantResolver->getUserMerchant(), [
-                'orderPayment' => $orderPayment
-            ]);
+            $this->creditHistoryBuilder->create(
+                    CreditHistoryModel::TYPE_DEBIT,
+                    $this->merchantResolver->getUserMerchant(),
+                    [
+                            'orderPayment' => $orderPayment
+                    ]
+            );
         }
 
         if ($this->orderShopResolver->isPaid($orderShop)) {
         $orderShop->setStatTotal($this->priceSolver->getTotal($orderShop));
         $orderShop->setStatTotalWithTax($this->priceSolver->getTotalWithTax($orderShop));
         $orderShop->setStatTotalOrderProductsWithReductions(
-            $this->priceSolver->getTotalOrderProductsWithReductions($orderShop)
+                $this->priceSolver->getTotalOrderProductsWithReductions($orderShop)
         );
         $orderShop->setStatTotalOrderProductsWithTaxAndReductions(
-            $this->priceSolver->getTotalOrderProductsWithTaxAndReductions($orderShop)
+                $this->priceSolver->getTotalOrderProductsWithTaxAndReductions($orderShop)
         );
         $orderShop->setStatMarginOrderProductsWithReductions(
-            $this->priceSolver->getMarginOrderProductsWithReductions($orderShop)
+                $this->priceSolver->getMarginOrderProductsWithReductions($orderShop)
         );
         $orderShop->setStatDeliveryPriceWithReduction($this->priceSolver->getDeliveryPriceWithReduction($orderShop));
         $orderShop->setStatDeliveryPriceWithTaxAndReduction(
-            $this->priceSolver->getDeliveryPriceWithTaxAndReduction($orderShop)
+                $this->priceSolver->getDeliveryPriceWithTaxAndReduction($orderShop)
         );
 
         $this->entityManager->persist($orderShop);
     public function initDistribution(OrderShopInterface $orderShop): void
     {
         $distribution = $this->distributionBuilder->guessDistributionByDeliveryDate(
-            $orderShop->getDeliveryDate(),
-            $orderShop->getSection()
+                $orderShop->getDeliveryDate(),
+                $orderShop->getSection()
         );
         $orderShop->setDistribution($distribution);
     }
     }
 
     public function addReductionCart(
-        OrderShopInterface     $orderShop,
-        ReductionCartInterface $reductionCart
-    ): ?OrderReductionCartInterface
-    {
+            OrderShopInterface $orderShop,
+            ReductionCartInterface $reductionCart
+    ): ?OrderReductionCartInterface {
         $orderReductionCartFactory = new OrderReductionCartFactory();
         $orderReductionCart = $orderReductionCartFactory->create($orderShop, $reductionCart);
 
         $orderShop->addOrderReductionCart($orderReductionCart);
 
         if ($this->orderShopResolver->isPositiveAmount($orderShop)
-            && $this->orderShopResolver->isPositiveAmountRemainingToBePaid($orderShop)) {
+                && $this->orderShopResolver->isPositiveAmountRemainingToBePaid($orderShop)) {
             $this->entityManager->create($orderReductionCart);
             $this->entityManager->flush();
 
 
     // createOrderReductionCredit
     public function addReductionCredit(
-        OrderShopInterface       $orderShop,
-        ReductionCreditInterface $reductionCredit
-    ): ?OrderReductionCreditInterface
-    {
+            OrderShopInterface $orderShop,
+            ReductionCreditInterface $reductionCredit
+    ): ?OrderReductionCreditInterface {
         $orderReductionCreditFactory = new OrderReductionCreditFactory();
         $orderReductionCredit = $orderReductionCreditFactory->create($orderShop, $reductionCredit);
 
         $orderShop->addOrderReductionCredit($orderReductionCredit);
 
         if ($this->orderShopResolver->isPositiveAmount($orderShop)
-            && $this->orderShopResolver->isPositiveAmountRemainingToBePaid($orderShop)) {
-
+                && $this->orderShopResolver->isPositiveAmountRemainingToBePaid($orderShop)) {
             $this->entityManager->create($orderReductionCredit);
             $this->entityManager->flush();
 
     }
 
     public function applyDeductAvailabilityProduct(
-        OrderShopInterface    $orderShop,
-        OrderProductInterface $orderProduct
-    ): void
-    {
+            OrderShopInterface $orderShop,
+            OrderProductInterface $orderProduct
+    ): void {
         switch ($orderProduct->getProduct()->getProductFamily()->getBehaviorCountStock()) {
             case ProductFamilyModel::BEHAVIOR_COUNT_STOCK_BY_MEASURE :
 
                 //Disponibilité par unité de référence
                 $oldAvailability = $this->productSolver->getAvailableQuantityInherited($orderProduct->getProduct());
-                $newAvailability = $oldAvailability - ($orderProduct->getQuantityOrder() * ($orderProduct->getQuantityProduct() / $orderProduct->getUnit()->getCoefficient()));
+                $newAvailability = $oldAvailability - ($orderProduct->getQuantityOrder(
+                                ) * ($orderProduct->getQuantityProduct() / $orderProduct->getUnit()->getCoefficient()));
 
                 $productFamily = $orderProduct->getProduct()->getProductFamily();
                 $productFamily->setAvailableQuantity($newAvailability);
 
     public function updatePriceByProductFamily(ProductFamilyInterface $productFamily)
     {
+        $debug = '';
+
         foreach ($this->merchantResolver->getCurrent()->getSections() as $section) {
             // @TODO : faire la vérification isOpenSale depuis la méthode appelante
             if (!$this->openingResolver->isOpenSale($section)) {
                 $countOrderProductUpdated = 0;
 
                 foreach ($productFamily->getProducts() as $product) {
-                    $orderProducts = $this->orderProductStore->resetContext()->setSection($section)->getInCartsByProduct($product);
+                    $orderProducts = $this->orderProductStore->resetContext()->setSection(
+                            $section
+                    )->getInCartsByProduct($product);
 
                     foreach ($orderProducts as $orderProduct) {
                         $quantityOrder = $orderProduct->getQuantityOrder();
                         $orderShop = $orderProduct->getOrderShop();
+
                         $orderShop->removeOrderProduct($orderProduct);
                         $this->entityManager->delete($orderProduct);
                         $this->entityManager->flush();
                     }
                 }
                 if ($countOrderProductUpdated) {
-                    // @TODO : faire le add flash dans le controller
                     $this->flashBagTranslator->add(
-                        'success',
-                        'orderProductUpdated',
-                        'OrderShop',
-                        array('%count%' => $countOrderProductUpdated)
+                            'success',
+                            'orderProductUpdated',
+                            'OrderShop',
+                            //array('%count%' => $countOrderProductUpdated)
+                            ['%count' => $debug]
                     );
 
                     $this->entityManager->flush();
         $orderShop->setStatTotal($this->priceSolver->getTotal($orderShop));
         $orderShop->setStatTotalWithTax($this->priceSolver->getTotalWithTax($orderShop));
         $orderShop->setStatTotalOrderProductsWithReductions(
-            $this->priceSolver->getTotalOrderProductsWithReductions($orderShop)
+                $this->priceSolver->getTotalOrderProductsWithReductions($orderShop)
         );
         $orderShop->setStatTotalOrderProductsWithTaxAndReductions(
-            $this->priceSolver->getTotalOrderProductsWithTaxAndReductions($orderShop)
+                $this->priceSolver->getTotalOrderProductsWithTaxAndReductions($orderShop)
         );
         $orderShop->setStatMarginOrderProductsWithReductions(
-            $this->priceSolver->getMarginOrderProductsWithReductions($orderShop)
+                $this->priceSolver->getMarginOrderProductsWithReductions($orderShop)
         );
         $orderShop->setStatDeliveryPriceWithReduction($this->priceSolver->getDeliveryPriceWithReduction($orderShop));
         $orderShop->setStatDeliveryPriceWithTaxAndReduction(
-            $this->priceSolver->getDeliveryPriceWithTaxAndReduction($orderShop)
+                $this->priceSolver->getDeliveryPriceWithTaxAndReduction($orderShop)
         );
 
         $this->entityManager->update($orderShop);
     public function getProductsSalesStatistic(SectionInterface $section, $entity, $nbWeek = 2)
     {
         $productsSalesStatistic = new ProductsSalesStatistic(
-            $this->entityManager,
-            $entity,
-            $nbWeek,
-            $this->productSolver
+                $this->entityManager,
+                $entity,
+                $nbWeek,
+                $this->productSolver
         );
 
         $productsSalesStatistic->init($section, $this->distributionBuilder, $this->openingResolver);

Solver/Order/OrderShopSolver.php

 use Lc\CaracoleBundle\Model\Product\ProductFamilyModel;
 use Lc\CaracoleBundle\Model\Product\ProductInterface;
 use Lc\CaracoleBundle\Model\Reduction\ReductionCreditInterface;
+use Lc\CaracoleBundle\Model\Section\SectionInterface;
 use Lc\CaracoleBundle\Solver\Product\ProductFamilySectionPropertySolver;
 use Lc\CaracoleBundle\Solver\Product\ProductSolver;
 
     protected ProductSolver $productSolver;
 
     public function __construct(
-        EntityManagerInterface $entityManager,
-        ProductSolver $productSolver
+            EntityManagerInterface $entityManager,
+            ProductSolver $productSolver
     ) {
         $this->entityManager = $entityManager;
         $this->productSolver = $productSolver;
     public static function getTypeDeliveryChoices()
     {
         return [
-            OrderShopModel::DELIVERY_TYPE_HOME,
-            OrderShopModel::DELIVERY_TYPE_POINTSALE,
+                OrderShopModel::DELIVERY_TYPE_HOME,
+                OrderShopModel::DELIVERY_TYPE_POINTSALE,
         ];
     }
 
 
     // getOrderProductsByProductFamily
     public function getOrderProductsByProductFamily(
-        OrderShopInterface $orderShop,
-        ProductFamilyInterface $productFamily
+            OrderShopInterface $orderShop,
+            ProductFamilyInterface $productFamily
     ): array {
         $arrayOrderProducts = [];
 
     }
 
     public function getQuantityOrderByProduct(
-        OrderShopInterface $orderShop,
-        ProductInterface $product,
-        $byWeight = false
+            OrderShopInterface $orderShop,
+            ProductInterface $product,
+            $byWeight = false
     ): int {
         $quantity = 0;
         $productFamily = $product->getProductFamily();
 
         foreach ($orderShop->getOrderProducts() as $orderProduct) {
             if ($orderProduct->getProduct()->getId() == $product->getId()
-                || (($behaviorCountStock == ProductFamilyModel::BEHAVIOR_COUNT_STOCK_BY_PRODUCT_FAMILY || $behaviorCountStock == ProductFamilyModel::BEHAVIOR_COUNT_STOCK_BY_MEASURE)
-                    && $orderProduct->getProduct()->getProductFamily()->getId() == $productFamily->getId())) {
+                    || (($behaviorCountStock == ProductFamilyModel::BEHAVIOR_COUNT_STOCK_BY_PRODUCT_FAMILY || $behaviorCountStock == ProductFamilyModel::BEHAVIOR_COUNT_STOCK_BY_MEASURE)
+                            && $orderProduct->getProduct()->getProductFamily()->getId() == $productFamily->getId())) {
                 if ($byWeight) {
                     $quantity += $orderProduct->getQuantityOrder() * ($orderProduct->getQuantityProduct(
-                            ) / $this->productSolver->getUnitInherited($orderProduct->getProduct())->getCoefficient());
+                                    ) / $this->productSolver->getUnitInherited(
+                                            $orderProduct->getProduct()
+                                    )->getCoefficient());
                 } else {
                     $quantity += $orderProduct->getQuantityOrder();
                 }
 
     // isProductAvailable
     public function isProductAvailable(
-        ProductInterface $product,
-        $quantityOrder = 0,
-        $checkCart = false,
-        $orderShop
+            SectionInterface $section,
+            OrderShopInterface $orderShop,
+            ProductInterface $product,
+            int $quantityOrder = 0,
+            bool $checkCart = false
     ) {
         if ($product->getStatus() != 1 || $product->getProductFamily()->getStatus(
-            ) != 1 || !$this->productSolver->isProductSaleStatusOn($product)) {
+                ) != 1 || !$this->productSolver->isProductSaleStatusOn($product)) {
             return false;
         }
 
-        if ($checkCart && !$orderShop) {
-            throw new \Exception("Attention : définir le orderShop à l'endroit où est appelé isAvailable");
-        }
-
         $productFamily = $product->getProductFamily();
         $quantityAsked = $quantityOrder;
 
             if (!$quantityOrder) {
                 $quantityAsked = $this->getQuantityOrderByProduct($orderShop, $product, true);
             } else {
-                $quantityAsked = ($this->productSolver->getQuantityInherited(
-                            $product
-                        ) / $this->productSolver->getUnitInherited($product)->getCoefficient()) * $quantityOrder;
+                $quantityAsked = ($this->productSolver->getQuantityInherited($product)
+                                / $this->productSolver->getUnitInherited($product)->getCoefficient()) * $quantityOrder;
             }
 
             if ($checkCart) {
         }
 
         if (($productFamily->getBehaviorCountStock() == ProductFamilyModel::BEHAVIOR_COUNT_STOCK_BY_PRODUCT_FAMILY
-            || $productFamily->getBehaviorCountStock() == ProductFamilyModel::BEHAVIOR_COUNT_STOCK_BY_PRODUCT)) {
+                || $productFamily->getBehaviorCountStock() == ProductFamilyModel::BEHAVIOR_COUNT_STOCK_BY_PRODUCT)) {
+
             if (!$quantityOrder) {
                 $quantityAsked = $this->getQuantityOrderByProduct($orderShop, $product);
             }
     public function isOneProductAvailableAddCart(OrderShopInterface $orderShop, $products): bool
     {
         foreach ($products as $product) {
-            if ($this->isProductAvailable($product, 1, true, $orderShop)) {
+            if ($this->isProductAvailable($orderShop->getSection(), $orderShop, $product, 1, true)) {
                 return true;
             }
         }
     public function isOrderProductAvailableAddCart(OrderProductInterface $orderProduct, OrderShopInterface $orderShop)
     {
         return $this->isProductAvailable(
-            $orderProduct->getProduct(),
-            $orderProduct->getQuantityOrder(),
-            true,
-            $orderShop
+                $orderShop->getSection(),
+                $orderShop,
+                $orderProduct->getProduct(),
+                1,
+                true
         );
     }
 
     }
 
     public function mergeComplentaryOrderShops(
-        OrderShopInterface $orderShop,
-        bool $combineProducts = true
+            OrderShopInterface $orderShop,
+            bool $combineProducts = true
     ): OrderShopInterface {
         $this->entityManager->refresh($orderShop);
 
                     $updated = false;
                     foreach ($orderShop->getOrderProducts() as $orderProduct) {
                         if ($combineProducts && $orderProduct->getProduct()->getId() == $orderProductAdd->getProduct(
-                            )->getId()
-                            && (string)$orderProduct->getPrice() == (string)$orderProductAdd->getPrice()
+                                )->getId()
+                                && (string)$orderProduct->getPrice() == (string)$orderProductAdd->getPrice()
                         ) {
                             $orderProduct->setUpdatedOnMergeComplementaryOrderShop(true);
                             $orderProduct->setQuantityOrder(
-                                $orderProduct->getQuantityOrder() + $orderProductAdd->getQuantityOrder()
+                                    $orderProduct->getQuantityOrder() + $orderProductAdd->getQuantityOrder()
                             );
 
                             $updated = true;
     }
 
     public function isReductionCreditAddedToOrder(
-        OrderShopInterface $orderShop,
-        ReductionCreditInterface $reductionCredit
+            OrderShopInterface $orderShop,
+            ReductionCreditInterface $reductionCredit
     ) {
         foreach ($orderShop->getOrderReductionCredits() as $orderReductionCredit) {
             if ($orderReductionCredit->getReductionCredit() == $reductionCredit) {
 
 
     public function hasOrderProductAlreadyInCart(
-        OrderShopInterface $orderShop,
-        OrderProductInterface $orderProductTest
+            OrderShopInterface $orderShop,
+            OrderProductInterface $orderProductTest
     ): ?OrderProductInterface {
         foreach ($orderShop->getOrderProducts() as $orderProduct) {
             if ($orderProduct->getProduct() == $orderProductTest->getProduct()) {
     public function isValid(OrderShopInterface $orderShop): bool
     {
         if ($orderShop->getOrderStatus() && in_array(
-                $orderShop->getOrderStatus()->getAlias(),
-                OrderStatusModel::$statusAliasAsValid
-            ) > 0) {
+                        $orderShop->getOrderStatus()->getAlias(),
+                        OrderStatusModel::$statusAliasAsValid
+                ) > 0) {
             return true;
         }
 
     public function isCart(OrderShopInterface $orderShop): bool
     {
         if ($orderShop->getOrderStatus() && in_array(
-                $orderShop->getOrderStatus()->getAlias(),
-                OrderStatusModel::$statusAliasAsCart
-            ) > 0) {
+                        $orderShop->getOrderStatus()->getAlias(),
+                        OrderStatusModel::$statusAliasAsCart
+                ) > 0) {
             return true;
         }
 
 
     public function isDone(OrderShopInterface $orderShop): bool
     {
-        if ($orderShop->getOrderStatus() && $orderShop->getOrderStatus()->getAlias() == OrderStatusModel::ALIAS_DONE ) {
+        if ($orderShop->getOrderStatus() && $orderShop->getOrderStatus()->getAlias() == OrderStatusModel::ALIAS_DONE) {
             return true;
         }
         return false;
         }
 
         return max(
-            $this->productSolver->getAvailableQuantityInherited($product) - $this->getQuantityOrderByProduct(
-                $orderShop,
-                $product,
-                $byWeight
-            ),
-            0
+                $this->productSolver->getAvailableQuantityInherited($product) - $this->getQuantityOrderByProduct(
+                        $orderShop,
+                        $product,
+                        $byWeight
+                ),
+                0
         );
     }