src/EventSubscriber/SupplySubscriber.php line 75

Open in your IDE?
  1. <?php
  3. namespace App\EventSubscriber;
  5. use App\Event\SupplyEvent;
  6. use App\Entity\SupplyActionHistory;
  7. use DateTime;
  8. use Doctrine\Persistence\ManagerRegistry;
  9. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  11. class SupplySubscriber implements EventSubscriberInterface
  12. {
  13.     private ManagerRegistry $managerRegistry;
  15.     public function __construct(ManagerRegistry $managerRegistry)
  16.     {
  17.         $this->managerRegistry = $managerRegistry;
  18.     }
  20.     /**
  21.      * @return float|int
  22.      */
  23.     private function computeLost(int $qt, int $loss)
  24.     {
  25.         if ($loss < 0) { return $qt; }
  27.         $loss = ($qt * $loss) / 100;
  28.         $qt += $loss;
  29.         $qt = is_float($qt) ? round($qt) : $qt;
  31.         return $qt;
  32.     }
  34.     private function save($entity): void
  35.     {
  36.         $manager = $this->managerRegistry->getManager();
  37.         $manager->persist($entity);
  38.         $manager->flush();
  39.     }
  41.     public function updateSupplyQty(SupplyEvent $event): void
  42.     {
  43.         $supply                = $event->getSupply();
  44.         $supplyHistory         = $event->getSupplyHistory();
  45.         $oldQuantity           = $event->getOldQuantity();
  46.         $supplyQuantity        = $supply->getQuantityInStock();
  47.         $direction             = $supplyHistory->getDirection();
  48.         $supplyHistoryQuantity = $supplyHistory->getQuantity();
  49.         $quantityWithLost      = $this->computeLost($supplyHistoryQuantity, $supply->getLost());
  51.         if (!is_null($oldQuantity)) {                                                          # if $oldQuantity is not null, we edit an existing Supply Action History (SAH)
  52.             if (SupplyActionHistory::DIRECTION_OUT === $direction) {                           # if we remove quantity
  53.                 $oldQuantityWithLost = $this->computeLost($oldQuantity, $supply->getLost());   # to edit this entry, we set the quantity to the initial state
  54.                 $quantityBeforeEntry = $supplyQuantity + $oldQuantityWithLost;
  55.                 $quantity = $quantityBeforeEntry - $quantityWithLost;                          # so the qt to remove will be the initial qt minus the new qt with lost
  56.             } else {                                                                           # if we add quantity
  57.                 $quantityBeforeEntry = $supplyQuantity - $oldQuantity;                         # as above, we set the quantity to the initial state
  58.                 $quantity = $quantityBeforeEntry + $supplyHistoryQuantity;                     # then we simply remove the new quantity
  59.             }
  60.         } else {                                                                               # in this case, a new SAH is created
  61.             if (SupplyActionHistory::DIRECTION_OUT === $direction) {                           # if we remove quantity
  62.                 $quantity = $supplyQuantity - $quantityWithLost;                               # get supply qt and remove the quantity from the input form
  63.             } else {                                                                           # otherwise, we add a new quantity in stock
  64.                 $quantity = $supplyQuantity + $supplyHistoryQuantity;                          # so we add the quantity from the input form to the supply quantity
  65.             }
  66.         }
  68.         $supply->setQuantityInStock($quantity);
  69.         $supply->setUpdatedDate(new DateTime('now'));
  70.         $this->save($supply);
  72.         $event->stopPropagation();
  73.     }
  75.     public function updateSupplyQuantityWhenDeleteHistory(SupplyEvent $supplyEvent): void
  76.     {
  77.         $supply                      = $supplyEvent->getSupply();
  78.         $supplyHistory               = $supplyEvent->getSupplyHistory();
  79.         $supplyQuantityInStock       = $supply->getQuantityInStock();
  80.         $supplyActionHistoryQuantity = $supplyHistory->getQuantity();
  82.         switch ($supplyHistory->getDirection()) {
  83.             case SupplyActionHistory::DIRECTION_OUT:
  84.                 $withdrawnQuantityWithLost = $this->computeLost($supplyActionHistoryQuantity, $supply->getLost());
  85.                 $supply->setQuantityInStock($supplyQuantityInStock + $withdrawnQuantityWithLost);
  86.             break;
  87.             case SupplyActionHistory::DIRECTION_IN:
  88.                 $supply->setQuantityInStock($supplyQuantityInStock - $supplyActionHistoryQuantity);
  89.             break;
  90.         }
  92.         $this->save($supply);
  93.     }
  95.     public static function getSubscribedEvents(): array
  96.     {
  97.         return [
  98.             SupplyEvent::UPDATE_SUPPLY_QT => 'updateSupplyQty',
  99.             SupplyEvent::UPDATE_QT_WHEN_DELETE_SUPPLY_HISTORY => 'updateSupplyQuantityWhenDeleteHistory'
  100.         ];
  101.     }
  102. }