src/Listener/NonMember/ContractListener.php line 460

Open in your IDE?
  1. <?php
  3. namespace App\Listener\NonMember;
  5. use App\Controller\Ajax\TutorialController;
  6. use App\Controller\MySief\ContractController;
  7. use App\Controller\MySief\SanctionsController;
  8. use App\Controller\MySief\TransferController;
  9. use App\Entity\LeadRegistrant\Agreement;
  10. use App\Entity\LegalEntity;
  11. use App\Entity\LegalEntity\Contract\AbstractContract;
  12. use App\Entity\LegalEntity\Contract\Amendment;
  13. use App\Entity\LegalEntity\Contract\Contract;
  14. use App\Entity\LegalEntity\Contract\LicenseAgreement;
  15. use App\Entity\Notification;
  16. use App\Entity\Notification\NonMember\ContractsAddedNotification;
  17. use App\Entity\Notification\NonMember\ContractsPendingNotification;
  18. use App\Entity\StaffRequest;
  19. use App\Entity\Substance\Definition;
  20. use App\Entity\User;
  21. use App\Entity\Worker;
  22. use App\FormType\TonnageBandType;
  23. use App\Service\DossierCalculator;
  24. use App\Service\StaffTransferCreator;
  25. use App\Workers\AgreementGeneratorWorker;
  26. use App\Workers\AgreementGeneratorWorkerConfig;
  27. use App\Workers\FinishTransferWorker;
  28. use App\Workers\FinishTransferWorkerConfig;
  29. use App\Workers\LicenseAgreementAmendmentWorker;
  30. use App\Workers\LicenseAgreementAmendmentWorkerConfig;
  31. use App\Workers\NonPetroleumWorker;
  32. use App\Workers\NonPetroleumWorkerConfig;
  33. use App\Workers\ScheduleFourWorker;
  34. use App\Workers\ScheduleFourWorkerConfig;
  35. use App\Workers\ScheduleThreeWorker;
  36. use App\Workers\ScheduleThreeWorkerConfig;
  37. use App\Workers\SendAcceptedContractWorker;
  38. use App\Workers\SendAcceptedContractWorkerConfig;
  39. use App\Workers\StatusWorker;
  40. use App\Workers\StatusWorkerConfig;
  41. use App\Workers\TokenRenewalCheckWorker;
  42. use App\Workers\TokenRenewalCheckWorkerConfig;
  43. use App\Workers\TonnageBandWorker;
  44. use App\Workers\TonnageBandWorkerConfig;
  45. use App\Workers\WorkerAlreadyQueuedException;
  46. use Carbon\Carbon;
  47. use Doctrine\Bundle\DoctrineBundle\EventSubscriber\EventSubscriberInterface;
  48. use Doctrine\ORM\EntityManagerInterface;
  49. use Doctrine\ORM\Event\LifecycleEventArgs;
  50. use Doctrine\ORM\Event\OnFlushEventArgs;
  51. use Doctrine\ORM\Events;
  52. use Symfony\Component\DependencyInjection\ContainerInterface;
  53. use Symfony\Component\HttpFoundation\RedirectResponse;
  54. use Symfony\Component\HttpKernel\CacheWarmer\WarmableInterface;
  55. use Symfony\Component\HttpKernel\Controller\ErrorController;
  56. use Symfony\Component\HttpKernel\Event\ControllerEvent;
  57. use Symfony\Component\HttpKernel\Event\ResponseEvent;
  58. use Symfony\Component\Routing\RouterInterface;
  59. use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
  60. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  61. use Symfony\Component\Validator\Validator\ValidatorInterface;
  63. class ContractListener implements EventSubscriberInterface, WarmableInterface
  64. {
  65.     /**
  66.      * @var TokenStorageInterface
  67.      */
  68.     private $storage;
  69.     /**
  70.      * @var EntityManagerInterface
  71.      */
  72.     private $em;
  73.     /**
  74.      * @var RouterInterface
  75.      */
  76.     private $router;
  77.     /**
  78.      * @var ContractController
  79.      */
  80.     private $controller;
  81.     /**
  82.      * @var ValidatorInterface
  83.      */
  84.     private $validator;
  85.     /**
  86.      * @var DossierCalculator
  87.      */
  88.     private $dossierCalculator;
  90.     private StaffTransferCreator $staffTransferCreator;
  91.     /**
  92.      * @var bool
  93.      */
  94.     private static $enabled = true;
  96.     public function __construct(TokenStorageInterface $storage, EntityManagerInterface $em, RouterInterface $router, ContractController $controller, ContainerInterface $container, ValidatorInterface $validator, DossierCalculator $dossierCalculator, StaffTransferCreator $staffTransferCreator)
  97.     {
  98.         $this->storage = $storage;
  99.         $this->em = $em;
  100.         $this->router = $router;
  101.         $this->controller = $controller;
  102.         $this->controller->setContainer($container);
  103.         $this->validator = $validator;
  104.         $this->dossierCalculator = $dossierCalculator;
  105.         $this->staffTransferCreator = $staffTransferCreator;
  106.     }
  108.     private function computeChanges($entity)
  109.     {
  110.         $uow = $this->em->getUnitOfWork();
  111.         $class = $this->em->getClassMetadata(get_class($entity));
  112.         $uow->computeChangeSet($class, $entity);
  113.     }
  115.     public function getSubscribedEvents()
  116.     {
  117.         return [Events::postPersist, Events::postUpdate, Events::postRemove, Events::onFlush];
  118.     }
  120.     public function postPersist(LifecycleEventArgs $args)
  121.     {
  122.         if (!$args->getEntity() instanceof AbstractContract) {
  123.             return;
  124.         }
  125.         $this->processContract($args->getEntityManager(), $args->getEntity());
  126.     }
  128.     public function postUpdate(LifecycleEventArgs $args)
  129.     {
  130.         if (!$args->getEntity() instanceof AbstractContract) {
  131.             return;
  132.         }
  133.         $this->processContract($args->getEntityManager(), $args->getEntity());
  134.     }
  136.     public function postRemove(LifecycleEventArgs $args)
  137.     {
  138.         if (!$args->getEntity() instanceof AbstractContract) {
  139.             return;
  140.         }
  141.         $this->processContract($args->getEntityManager(), $args->getEntity(), true);
  142.     }
  144.     public function onFlush(OnFlushEventArgs $args)
  145.     {
  146.         if (!self::$enabled) {
  147.             return;
  148.         }
  149.         $em = $args->getEntityManager();
  150.         $uow = $em->getUnitOfWork();
  151.         $md = $em->getClassMetadata(Worker::class);
  153.         foreach ($uow->getScheduledEntityUpdates() as $contract) {
  154.             if (!$contract instanceof AbstractContract) {
  155.                 continue;
  156.             }
  157.             $changes = $uow->getEntityChangeSet($contract);
  158.             if (!array_key_exists('accepted', $changes)) {
  159.                 continue;
  160.             }
  161.             if ($contract instanceof LicenseAgreement) {
  162.                 $reason = $changes['accepted'][1]
  163.                     ? 'License agreement marked as accepted'
  164.                     : 'License agreement marked as not accepted';
  165.                 foreach ($contract->getLegalEntity()->getOrderLines() as $line) {
  166.                     /** @var User $user */
  167.                     $user = $this->storage->getToken()->getUser();
  168.                     // Status worker (calculate status for all order lines)
  169.                     $worker = (new Worker(StatusWorker::class, (new StatusWorkerConfig())
  170.                         ->setOrderLineId($line->getId())
  171.                         ->setReason($reason)
  172.                         ->setUserId($user->getId())
  173.                     ))->setDelay(20);
  174.                     $em->persist($worker);
  175.                     $uow->computeChangeSet($md, $worker);
  176.                     // Token renewal check worker
  177.                     try {
  178.                         $worker = $this->em->getRepository(Worker::class)->createWorker(TokenRenewalCheckWorker::class, (new TokenRenewalCheckWorkerConfig())
  179.                             ->setEcId($line->getSubstance()->getEc()->getId()))
  180.                         ->setDelay(2);
  181.                         $em->persist($worker);
  182.                         $uow->computeChangeSet($md, $worker);
  183.                     } catch (WorkerAlreadyQueuedException $e) {
  184.                     }
  185.                 }
  186.                 // Regenerate license agreement
  187.                 try {
  188.                     $worker = $this->em->getRepository(Worker::class)->createWorker(AgreementGeneratorWorker::class, (new AgreementGeneratorWorkerConfig())
  189.                         ->setType(AgreementGeneratorWorkerConfig::TYPE_NON_MEMBER)
  190.                         ->setImport(false)
  191.                         ->setReset(false)
  192.                         ->setNotify(false)
  193.                         ->setEntityId($contract->getLegalEntity()->getId())
  194.                     )->setDelay(10);
  195.                     $em->persist($worker);
  196.                     $uow->computeChangeSet($md, $worker);
  197.                 } catch (WorkerAlreadyQueuedException $e) {
  198.                 }
  199.             }
  200.             // Regenerate schedule 4 amendment
  201.             if ($contract instanceof Amendment && Amendment::TYPE_SCHEDULE_4 === $contract->getType()) {
  202.                 try {
  203.                     $worker = $this->em->getRepository(Worker::class)->createWorker(ScheduleFourWorker::class, (new ScheduleFourWorkerConfig())
  204.                         ->setId($contract->getId()))
  205.                     ->setDelay(2);
  206.                     $em->persist($worker);
  207.                     $uow->computeChangeSet($md, $worker);
  208.                 } catch (WorkerAlreadyQueuedException $e) {
  209.                 }
  210.             }
  212.             // Regenerate non-petroleum data sharing agreement
  213.             if ($contract instanceof LegalEntity\Contract\NonPetroleumAgreement) {
  214.                 try {
  215.                     $config = (new NonPetroleumWorkerConfig())
  216.                         ->setId($contract->getId());
  217.                     if ($contract->isAccepted() && $contract->getAcceptedAt()->format('d-m-Y') === carbon::today()->format('d-m-Y')) {
  218.                         $config->setAccepted(true);
  219.                     }
  220.                     $worker = $this->em->getRepository(Worker::class)->createWorker(NonPetroleumWorker::class, $config)
  221.                         ->setDelay(2);
  222.                     $em->persist($worker);
  223.                     $uow->computeChangeSet($md, $worker);
  224.                 } catch (WorkerAlreadyQueuedException $e) {
  225.                 }
  226.             }
  228.             // Regenerate License agreement amendment
  229.             if ($contract instanceof Amendment && Amendment::TYPE_LICENSE_AGREEMENT === $contract->getType()) {
  230.                 try {
  231.                     $worker = $em->getRepository(Worker::class)->createWorker(LicenseAgreementAmendmentWorker::class, (new LicenseAgreementAmendmentWorkerConfig())
  232.                         ->setId($contract->getId()))
  233.                     ->setDelay(2);
  234.                     $em->persist($worker);
  235.                     $uow->computeChangeSet($md, $worker);
  236.                 } catch (WorkerAlreadyQueuedException $e) {
  237.                 }
  238.             }
  239.             // Regenerate schedule 3 amendment
  240.             if ($contract instanceof Amendment && Amendment::TYPE_SCHEDULE_3 === $contract->getType()) {
  241.                 /** @var LegalEntity\Contract\Schedule3Amendment $contract */
  242.                 $linkedContract = $contract->getAmendment();
  243.                 if ($linkedContract->isAccepted()) {
  244.                     $request = $this->em->getRepository(StaffRequest::class)->find($contract->getTransferRequest());
  245.                     $substances = [];
  246.                     $oldSubstances = [];
  247.                     if ($request instanceof StaffRequest\TransferRequest) {
  248.                         foreach ($request->getSubstances() as $substance) {
  249.                             $substances[] = $em->getRepository(Definition::class)->find($substance);
  250.                         }
  251.                         foreach ($request->getLegalEntity()->getSubstances() as $substance) {
  252.                             $oldSubstances[] = $em->getRepository(Definition::class)->find($substance);
  253.                         }
  255.                         if ($substances === $oldSubstances) {
  256.                             if (!$request->getLegalEntity()->getRemarks()->isEmpty()) {
  257.                                 foreach ($request->getLegalEntity()->getRemarks() as $remark) {
  258.                                     $request->getNewLegalEntity()->getRemarks()->add($remark);
  259.                                 }
  260.                             }
  261.                         }
  263.                         if ($request->getMember()) {
  264.                             $md = $this->em->getClassMetadata(Worker::class);
  265.                             // Queue the transfer worker
  266.                             try {
  267.                                 $worker = $this->em->getRepository(Worker::class)->createWorker(
  268.                                     FinishTransferWorker::class,
  269.                                     (new FinishTransferWorkerConfig())
  270.                                         ->setTransferRequest($request->getId())
  271.                                 )->setDelay(2);
  272.                                 $this->em->persist($worker);
  273.                                 $uow->computeChangeSet($md, $worker);
  274.                             } catch (WorkerAlreadyQueuedException $e) {
  276.                             }
  277.                         } else {
  278.                             /**
  279.                              * @var StaffRequest\TransferRequest $request
  280.                              */
  281.                             $steps = $request->getProgress()->getSteps();
  282.                             $steps[] = 'awaiting-invoice-creation';
  283.                             $request->getProgress()
  284.                                 ->setStatus('primary')
  285.                                 ->setPercentage(66)
  286.                                 ->setStatusText('Awaiting invoice creation, ')
  287.                                 ->setWaiting('staff interaction required')
  288.                                 ->setSteps($steps);
  290.                             if (!$request->getNewLegalEntity()->getLicenseAgreement()->isAccepted()) {
  291.                                 // Queue the license agreement generator
  292.                                 try {
  293.                                     $worker = $em->getRepository(Worker::class)->createWorker(
  294.                                         AgreementGeneratorWorker::class,
  295.                                         (new AgreementGeneratorWorkerConfig())
  296.                                             ->setType(AgreementGeneratorWorkerConfig::TYPE_NON_MEMBER)
  297.                                             ->setReset(false)
  298.                                             ->setEntityId($request->getNewLegalEntity()->getId())
  299.                                     )->setDelay(2);
  300.                                     $em->persist($worker);
  301.                                     $uow->computeChangeSet($md, $worker);
  302.                                 } catch (WorkerAlreadyQueuedException $e) {
  303.                                 }
  304.                             }
  305.                             $this->em->persist($request->getNewLegalEntity());
  306.                         }
  308.                     }
  309.                 }
  310.                 try {
  311.                     $config = (new ScheduleThreeWorkerConfig())
  312.                         ->setId($contract->getId());
  313.                     if ($contract->isAccepted()) {
  314.                         $config->setAccepted(true);
  315.                     }
  316.                     $worker = $this->em->getRepository(Worker::class)->createWorker(ScheduleThreeWorker::class, $config)->setDelay(2);
  317.                     $em->persist($worker);
  318.                     $uow->computeChangeSet($md, $worker);
  319.                 } catch (WorkerAlreadyQueuedException $e) {
  320.                 }
  321.                 try {
  322.                     $linkedWorker = $this->em->getRepository(Worker::class)->createWorker(ScheduleThreeWorker::class, (new ScheduleThreeWorkerConfig())
  323.                         ->setId($linkedContract->getId()))->setDelay(2);
  324.                     $em->persist($linkedWorker);
  325.                     $uow->computeChangeSet($md, $linkedWorker);
  326.                 } catch (WorkerAlreadyQueuedException $e) {
  327.                 }
  328.             }
  330.             // Regenerate tonnageBandAmendment
  331.             if ($contract instanceof Amendment && Amendment::TYPE_TONNAGEBAND === $contract->getType()) {
  332.                 if ($changes['accepted'][1]) {
  333.                     $substancemd = $em->getClassMetadata(Definition::class);
  334.                     $remarkmd = $em->getClassMetadata(LegalEntity\Remark::class);
  335.                     $amendment = $contract;
  336.                     $data = $amendment->getData();
  337.                     foreach ($data['substances'] as $substanceId) {
  338.                         $substance = $this->em->getRepository(Definition::class)->find($substanceId);
  339.                         /** @var LegalEntity $entity */
  340.                         $entity = $substance->getLegalEntity();
  341.                         $bands = TonnageBandType::getTonnageBands(true);
  342.                         $remark = new LegalEntity\Remark();
  343.                         $user = $this->em->getRepository(User::class)->find(3);
  344.                         $contents = sprintf('Tonnage band change for EC %s from [%s] to [%s]', $substance->getEc()->getEc(), $bands[$substance->getPreviousTonnageBand()], $bands[$substance->getNewTonnageBand()]);
  345.                         $remark->setContents($contents)
  346.                             ->setDate(carbon::now())
  347.                             ->setLegalEntity($entity)
  348.                             ->setAuthor($user);
  349.                         $entity->getRemarks()->add($remark);
  350.                         $this->em->persist($remark);
  351.                         $uow->computeChangeSet($remarkmd, $remark);
  352.                         $substance->setTonnageChanged(false);
  353.                         $substance->setTonnageBand($substance->getNewTonnageBand());
  354.                         $substance->setNewTonnageBand(null);
  355.                         $substance->setPreviousTonnageBand(null);
  356.                         $substance->getTonnageBandProof()->setAmendmentId(null);
  357.                         $substance->getTonnageBandProof()->setTonnageInvoiceId(null);
  358.                         $this->em->persist($substance);
  359.                         $uow->computeChangeSet($substancemd, $substance);
  360.                     }
  361.                 }
  362.                 try {
  363.                     $worker = $this->em->getRepository(Worker::class)->createWorker(TonnageBandWorker::class, (new TonnageBandWorkerConfig())
  364.                         ->setAmendment($contract->getId()))
  365.                     ->setDelay(10);
  366.                     $em->persist($worker);
  367.                     $uow->computeChangeSet($md, $worker);
  368.                 } catch (WorkerAlreadyQueuedException $e) {
  369.                 }
  370.             }
  371.             // Send copy of contract to authorized representative
  372.             try {
  373.                 /** @var User $user */
  374.                 $user = $this->storage->getToken()->getUser();
  375.                 $worker = ($this->em->getRepository(Worker::class)->createWorker(SendAcceptedContractWorker::class, (new SendAcceptedContractWorkerConfig())
  376.                     ->setUserId($user->getId())
  377.                     ->setContractId($contract->getId())
  378.                     ->setLicenseAgreement($contract instanceof LicenseAgreement)
  379.                 ))->setDelay(300);
  380.                 $em->persist($worker);
  381.                 $uow->computeChangeSet($md, $worker);
  382.             } catch (WorkerAlreadyQueuedException $e) {
  383.             }
  384.         }
  385.     }
  387.     /**
  388.      * @param AbstractContract|Contract|LicenseAgreement $contract
  389.      */
  390.     private function processContract(EntityManagerInterface $em, AbstractContract $contract, bool $removed = false)
  391.     {
  392.         if (!self::$enabled) {
  393.             return;
  394.         }
  395.         $repository = $em->getRepository(Notification::class);
  396.         if ($contract instanceof Agreement) {
  397.             return;
  398.         }
  399.         if ($contract instanceof LegalEntity\Contract\ModifiedLicenseAgreement) {
  400.             /** @var LegalEntity\Contract\ModifiedLicenseAgreement $contract */
  401.             $user = $contract->getCompany()->getUser();
  402.         } else {
  403.             /** @var Amendment $contract */
  404.             $user = $contract->getLegalEntity()->getUser();
  405.         }
  407.         if ($contract instanceof Amendment && Amendment::TYPE_SCHEDULE_3 === $contract->getType()) {
  408.             if ($contract instanceof LegalEntity\Contract\Schedule3Amendment) {
  409.                 $linkedContract = $contract->getAmendment();
  410.                 if ($contract->isAccepted() && $linkedContract->isAccepted()) {
  411.                     $request = $this->em->getRepository(StaffRequest::class)->find($contract->getTransferRequest());
  412.                     $repository = $this->em->getRepository(Notification::class);
  413.                     /** @var StaffRequest\TransferRequest $request */
  414.                     if (!$request->isCompleted()) {
  415.                         if ($request->isTransferStaffRequest()) {
  416.                             if (!$request->getMember()) {
  417.                                 $notification = (new Notification\Staff\StaffTransferAcceptedNotification())
  418.                                     ->setup($request->getLegalEntity()->getUser(), $request);
  419.                                 $repository->removeByInternalCode($notification);
  420.                                 if (!$removed) {
  421.                                     $repository->notifyStaff($notification);
  422.                                 }
  423.                             }
  424.                         } else {
  425.                             $notification = (new Notification\NonMember\TransferAcceptedNotification())
  426.                                 ->setup($request->getLegalEntity()->getUser(), $request);
  427.                             $repository->removeByInternalCode($notification);
  428.                             if (!$removed) {
  429.                                 $repository->notifyStaff($notification);
  430.                             }
  431.                         }
  432.                         $request->setContractAccepted(true);
  433.                         $request->setAccepted(true);
  434.                     }
  435.                 }
  436.             }
  437.         }
  439.         if ($contract->isAcceptanceRequired()) {
  440.             $notification = (new ContractsPendingNotification())->setup($em, $user);
  441.             // Remove the existing notification (if there is one)
  442.             $repository->removeByInternalCode($notification);
  443.             // Create a new one if one or more contracts require acceptance
  444.             /** @var ContractsPendingNotification $notification */
  445.             if (!$removed && $notification->getPending() > 0) {
  446.                 $repository->notifyUser($notification);
  447.             }
  448.         } else {
  449.             $notification = (new ContractsAddedNotification())->setup($em, $user);
  450.             // Remove the existing notification (if there is one)
  451.             $repository->removeByInternalCode($notification);
  452.             // Create a new one if one or more contracts require acceptance
  453.             /** @var ContractsAddedNotification $notification */
  454.             if (!$removed && $notification->getNew() > 0) {
  455.                 $repository->notifyUser($notification);
  456.             }
  457.         }
  458.     }
  460.     public function onKernelController(ControllerEvent $event)
  461.     {
  462.         if (!self::$enabled) {
  463.             return;
  464.         }
  465.         $token = $this->storage->getToken();
  466.         if (!$token instanceof TokenInterface) {
  467.             return;
  468.         }
  469.         $user = $token->getUser();
  470.         if (!$user instanceof User) {
  471.             return;
  472.         }
  474.         $entities = $this->em->getRepository(LegalEntity::class)->findBy(['user' => $user]);
  475.         if (count($entities) > 0) {
  476.             foreach ($entities as $entity) {
  477.                 $violations = $this->validator->validate($entity);
  478.                 if ($violations->count() > 0) {
  479.                     return;
  480.                 }
  481.             }
  482.         }
  483.         // Count the number of pending contracts
  484.         $pending = (int) $this->em->createQueryBuilder()
  485.             ->from(Contract::class, 'contract')
  486.             ->select('COUNT(contract)')
  487.             ->join('contract.legalEntity', 'e')
  488.             ->where('e.user = :user')
  489.             ->setParameter('user', $user)
  490.             ->andWhere('contract.accepted = :false')
  491.             ->setParameter('false', false)
  492.             ->andWhere('contract.file.path IS NOT NULL')
  493.             ->andWhere('contract.forceAcceptance = TRUE')
  494.             ->andWhere('e.status = :status')
  495.             ->setParameter('status', LegalEntity::STATUS_APPROVED)
  496.             ->getQuery()->useQueryCache(true)->getSingleScalarResult();
  497.         if (0 === $pending) {
  498.             return;
  499.         }
  500.         $controller = $event->getController();
  501.         if (!is_array($controller)) {
  502.             return;
  503.         }
  504.         if ($controller[0] instanceof TutorialController) {
  505.             return;
  506.         }
  507.         if ($controller[0] instanceof SanctionsController) {
  508.             return;
  509.         }
  510.         if (!isset($entity)) {
  511.             throw new \Exception('entity is not set');
  512.         }
  513.         if (!$entity->isInactive()) {
  514.             if ($controller[0] instanceof ErrorController) {
  515.                 // We always need to show error pages
  516.                 $event->getRequest()->attributes->remove('contract_enforcement');
  517.             } elseif ($controller[0] instanceof ContractController || $controller[0] instanceof TransferController) {
  518.                 // Notice needs to be shown, but no redirect required
  519.                 $event->getRequest()->attributes->set('contract_enforcement', false);
  520.             } else {
  521.                 $redirectUrl = $this->router->generate('my-sief-page.contracts.index');
  522.                 $event->setController(function () use ($redirectUrl) {
  523.                     return new RedirectResponse($redirectUrl);
  524.                 });
  525.             }
  526.         }
  527.     }
  529.     public function onKernelResponse(ResponseEvent $event)
  530.     {
  531.     }
  533.     public static function disable()
  534.     {
  535.         self::$enabled = false;
  536.     }
  538.     public static function enable()
  539.     {
  540.         self::$enabled = true;
  541.     }
  543.     public function warmUp($cacheDir): array
  544.     {
  545.         return [TokenStorageInterface::class, EntityManagerInterface::class, RouterInterface::class, ContractController::class, ContainerInterface::class, ValidatorInterface::class, DossierCalculator::class];
  546.     }
  547. }