src/EventSubscriber/DoctrineSubscriber.php line 71

Open in your IDE?
  1. <?php
  2. namespace App\EventSubscriber;
  3. use App\Controller\Api\DocumentManagerController;
  4. use App\Entity\Customer;
  5. use App\Entity\CustomerCertificateDocuments;
  6. use App\Entity\ProjectOrderExpensePositions;
  7. use App\Entity\ProjectOrderExpenses;
  8. use App\Entity\ProjectOrders;
  9. use App\Entity\Projects;
  10. use App\Entity\ProjectStakeholders;
  11. use App\Entity\ProjectStatus;
  12. use App\Entity\StockItems;
  13. use App\Entity\Stocks;
  14. use App\Entity\StockTransactions;
  15. use App\Entity\WorkerCertificateDocuments;
  16. use App\Entity\Worker;
  17. use App\Entity\WorkerInProject;
  18. use App\Entity\WorkerTimesheet;
  19. use App\Repository\ProjectOrdersRepository;
  20. use App\Service\TimesheetInterface\TimesheetReaderInterface;
  21. use Doctrine\Common\Collections\ArrayCollection;
  22. use Doctrine\ORM\PersistentCollection;
  23. use Doctrine\Persistence\Event\LifecycleEventArgs;
  24. use Doctrine\ORM\Events;
  25. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  26. use App\Entity\InvoiceType;
  27. use Doctrine\Persistence\ManagerRegistry;
  28. use Doctrine\ORM\UnitOfWork;
  29. /**
  30.  * Doctrine during load jobs
  31. */
  32. class DoctrineSubscriber implements EventSubscriberInterface
  33. {
  34.         private $servArgCustomerCertFetchDir;
  35.         private $servArgWorkerCertFetchDir;
  36.         private $serviceArgs;
  37.         private ManagerRegistry $managerRegistry;
  38.         # public function __construct( $servArgCustomerCertFetchDir, $servArgCustomerCertManageDir, $servArgWorkerCertFetchDir, $servArgWorkerCertManageDir, $servArgWorkerImagesFetchDir, $args )
  39.         public function __construct$argsManagerRegistry $managerRegistry )
  40.         {
  41.             $this->serviceArgs $args;
  42.             $this->managerRegistry $managerRegistry;
  43.         }
  44.     // Listen to postLoad event
  45.     public static function getSubscribedEvents()
  46.     {
  47.         return array(
  48.             // Update yaml file
  49.             Events::postLoad,
  50.             #Events::postFlush,
  51.             #Events::postUpdate,
  52.             #Events::postPersist,
  53.             Events::prePersist,
  54.             #Events::preUpdate,
  55.             #Events::preRemove,
  56.             #Events::onFlush,
  57.             #Events::postFlush
  58.         );
  59.     }
  60. //    public function postFlush(LifecycleEventArgs $args){
  61. //            dd('postFlush');
  62. //    }
  63.     // Set the services.yaml param on the entity
  64.     public function postLoadLifecycleEventArgs $args)
  65.     {
  66.         $entity $args->getObject();
  67.         // replaced to Dynamic Process via Request to app_project_order_expenses_generate_document_path
  68. //        if( $entity instanceof ProjectOrderExpenses ){
  69. //            /**
  70. //             * Burda Expense Direk cagirilirken ona ait posiotnda da tekrar cagriliyro olabilir
  71. //             * busebeble containe kullanarak islemi filtrele
  72. //            */
  73. //
  74. //            $documentPath = $entity->getFilename();
  75. //
  76. //            if (!empty($documentPath)) {
  77. //                // `expenseDocumentPath` zaten mevcut değilse ekle
  78. //                if (!str_contains($documentPath, $this->serviceArgs['dirs']['expenseDocumentPath'])) {
  79. //                    $documentPath = $this->serviceArgs['dirs']['expenseDocumentPath'] . DIRECTORY_SEPARATOR . $documentPath;
  80. //                    $entity->setFilename($documentPath);
  81. //                }
  82. //            }
  83. //            #dump($entity->getId(), $entity->getDocumentPath());
  84. //
  85. //        }
  86.         if ($entity instanceof CustomerCertificateDocuments ) {
  87.             $entity->setHydrateDocumentsData([
  88.                 "id" => $entity->getId(),
  89.                 "file_name" => $entity->getName(),
  90.                 "file_real_path" => $this->serviceArgs['dirs']['customerCertFetchDir'] . DIRECTORY_SEPARATOR $entity->getName(),
  91.                 "extension" =>  DocumentManagerController::getFileExtension$entity->getName() ),
  92.                 "type" =>  DocumentManagerController::getFileFullTypeDocumentManagerController::getFileExtension$entity->getName() ) ),
  93.                 // Access from frontend
  94.                 "remove_path" => "/api/customer/remove-customer-certificate-history-document/" $entity->getCustomerCertificateHistory()->getCustomerCertificate()->getCustomer()->getSlug() . "/" DocumentManagerController::Encrypt($entity->getId()),
  95.                 // Access just backend
  96.                 "remove_link" => $this->serviceArgs['dirs']['customerCertManageDir'] . DIRECTORY_SEPARATOR $entity->getName()
  97.             ]);
  98.         }
  99.         if ( $entity instanceof WorkerCertificateDocuments ) {
  100.             $entity->setHydrateDocumentsData([
  101.                 "id" => $entity->getId(),
  102.                 "file_name" => $entity->getName(),
  103.                 "file_real_path" => $this->serviceArgs['dirs']['workerCertFetchDir'] . DIRECTORY_SEPARATOR $entity->getName(),
  104.                 "extension" =>  DocumentManagerController::getFileExtension$entity->getName() ),
  105.                 "type" =>  DocumentManagerController::getFileFullTypeDocumentManagerController::getFileExtension$entity->getName() )),
  106.                 // Access from frontend
  107.                 "remove_path" => "/api/worker/remove-worker-certificate-history-document/" $entity->getWorkerCertificateHistory()->getWorkerCertificate()->getWorker()->getSlug() . "/" DocumentManagerController::Encrypt($entity->getId()),
  108.                 // Access just backend
  109.                 "remove_link" =>$this->serviceArgs['dirs']['workerCertManageDir'] . DIRECTORY_SEPARATOR $entity->getName()
  110.             ]);
  111.         }
  112.         if ( $entity instanceof Worker ) {
  113.             $entity->setProfileImageFullPath$this->serviceArgs['dirs']['workerImagesFetchDir'] . DIRECTORY_SEPARATOR $entity->getProfileImage() );
  114.             // Actually Activity
  115.             // Set Fully Name
  116.             $entity->setFullName$entity->getName() . ' ' $entity->getSurname() );
  117.         }
  118.         if ( $entity instanceof Customer ) {
  119.             $entity->setLogoImageFullPath$this->serviceArgs['dirs']['customerImagesFetchDir'] . DIRECTORY_SEPARATOR $entity->getCompanyLogo() );
  120.         }
  121.         if ( $entity instanceof WorkerInProject || $entity instanceof ProjectStakeholders  || $entity instanceof Projects ) {
  122.             $completed false;
  123.             $params "in process";
  124.             if( $entity instanceof WorkerInProject ){
  125.                 if( $entity->getForciblyCompleted() || ( $entity->getEndAt() && ($entity->getEndAt() < new \DateTimeImmutable('now')) ) ){
  126.                     $params "completed";
  127.                     $completed true;
  128.                 }
  129.             } else {
  130.                 if( $entity->getEndAt() && ($entity->getEndAt() < new \DateTimeImmutable('now')) ){
  131.                     $params "completed";
  132.                     $completed true;
  133.                 }
  134.             }
  135.             $project_name '';
  136.             if( $entity instanceof WorkerInProject ){
  137.                 $project_name $entity->getProject()->getProject()->getName();
  138.             } else if( $entity instanceof ProjectStakeholders ){
  139.                 $project_name $entity->getProject()->getName();
  140.             } else if( $entity instanceof Projects ){
  141.                 $project_name $entity->getName();
  142.             }
  143.             /**@var $found ProjectStatus*/
  144.             $found $args->getObjectManager()->getRepository(ProjectStatus::class)->findOneBy(["name"=>$params]);
  145.             $entity->setStatus([
  146.                 "project_name" => $project_name,
  147.                 'name'=>$found->getName(),
  148.                 'color'=>$found->getColor(),
  149.                 'completed'=>$completed
  150.             ]);
  151.         }
  152.         /**
  153.          * By Manage give an error 
  154.          * @deprecated */
  155.         if( $entity instanceof ProjectOrders ){
  156.         
  157.             return;
  158.             #dd($args->getObjectManager());
  159.             
  160.             $entityManager $args->getObjectManager();
  161.             
  162.             $unitOfWork $entityManager->getUnitOfWork();
  163.             $entityState $unitOfWork->getEntityState($entity);
  164.             
  165.             if($entityState === UnitOfWork::STATE_NEW)  {
  166.                 // return;
  167.             }
  168.             #return;
  169.             try{
  170.                 if( is_null($entity->getInvoiceType())){
  171.                 
  172.                 
  173.                     #dd(12);
  174.                     $projectOwner $entity->getProject()->getOwner();
  175.     
  176.     
  177.                     // Set Standard
  178.                     if(!$projectOwner){
  179.                         $invoiceTypes $args->getObjectManager()->getRepository(InvoiceType::class)->findOneBy(["name"=>"Standard"]);
  180.                         #dd($invoiceTypes);
  181.                         $entity->setInvoiceType($invoiceTypes);
  182.                         return;
  183.                     }
  184.     
  185.                     // Owner Defined but invoice type not selected than Set Standard 
  186.                     if(is_null($projectOwner->getInvoiceType())){
  187.                         $invoiceTypes $args->getObjectManager()->getRepository(InvoiceType::class)->findOneBy(["name"=>"Standard"]);
  188.                         #dd($invoiceTypes);
  189.                         #$entity->setInvoiceType($invoiceTypes);
  190.                         return;
  191.                     }
  192.     
  193.                     // dd($projectOwner->getInvoiceType());
  194.                     $entity->setInvoiceType($projectOwner->getInvoiceType());
  195.                 }
  196.             } catch (\Exception $exception){
  197.                 
  198.             }
  199.         
  200.         }
  201.         if( $entity instanceof Stocks ){
  202.             $em $args->getObjectManager();
  203.             $availableStockQuantity $this->finalCalculatedStockQuantityFromTransactions($entity->getStockTransactions());
  204.             $entity->setAvailableStockQuantity$availableStockQuantity );
  205.         }
  206.         if( $entity instanceof StockItems ){
  207.             $em $args->getObjectManager();
  208.             $finalQuantities $entity->getStocks()->map(function (/**@var Stocks $stock*/$stock) {
  209.                 return $this->finalCalculatedStockQuantityFromTransactions($stock->getStockTransactions());
  210.             });
  211.             $entity->setTotalAvailableQuantity(array_sum($finalQuantities->toArray()));
  212.         }
  213.     }
  214.     private function finalCalculatedStockQuantityFromTransactions(PersistentCollection $transactions): float {
  215.         $finalQuantity 0;
  216.         foreach ( $transactions as $transaction) {
  217.             $qty $transaction->getQuantity();
  218.             if ($transaction->getTransactionType() === 'in') {
  219.                 $finalQuantity += $qty;
  220.             } elseif ($transaction->getTransactionType() === 'out') {
  221.                 $finalQuantity -= $qty;
  222.             }
  223.         }
  224.         return $finalQuantity;
  225.     }
  226.     // Set the services.yaml param on the entity
  227. //    public function preRemove( LifecycleEventArgs $args)
  228. //    {
  229. //        $certDocEntity = $args->getObject();
  230. //        dd($certDocEntity);
  231. //    }
  232.     // Set the services.yaml param on the entity
  233. //    public function postFlush( LifecycleEventArgs $args)
  234. //    {
  235. //        dd('Flush');
  236. //        $certDocEntity = $args->getObject();
  237. //        if ($certDocEntity instanceof CustomerCertificateDocuments ) {
  238. //            $certDocEntity->setServiceArgumentFileFetchDir( $this->servArgCustomerCertFetchDir );
  239. //        }
  240. //
  241. //        if ( $certDocEntity instanceof WorkerCertificateDocuments ) {
  242. //            $certDocEntity->setServiceArgumentFileFetchDir( $this->servArgWorkerCertFetchDir );
  243. //        }
  244. //    }
  245.     // Set the services.yaml param on the entity
  246. //    public function postUpdate( LifecycleEventArgs $args)
  247. //    {
  248. //        dd('Update');
  249. //        $certDocEntity = $args->getObject();
  250. //        if ($certDocEntity instanceof CustomerCertificateDocuments ) {
  251. //            $certDocEntity->setServiceArgumentFileFetchDir( $this->servArgCustomerCertFetchDir );
  252. //        }
  253. //
  254. //        if ( $certDocEntity instanceof WorkerCertificateDocuments ) {
  255. //            $certDocEntity->setServiceArgumentFileFetchDir( $this->servArgWorkerCertFetchDir );
  256. //        }
  257. //    }
  258.     // Set the services.yaml param on the entity
  259. //    public function postPersist( LifecycleEventArgs $args)
  260. //    {
  261. //        dd('postPersist');
  262. //        $certDocEntity = $args->getObject();
  263. //        if ($certDocEntity instanceof CustomerCertificateDocuments ) {
  264. //            $certDocEntity->setServiceArgumentFileFetchDir( $this->servArgCustomerCertFetchDir );
  265. //        }
  266. //
  267. //        if ( $certDocEntity instanceof WorkerCertificateDocuments ) {
  268. //            $certDocEntity->setServiceArgumentFileFetchDir( $this->servArgWorkerCertFetchDir );
  269. //        }
  270. //    }
  271. //
  272. //    // Set the services.yaml param on the entity
  273. //    public function prePersist( LifecycleEventArgs $args)
  274. //    {
  275. //        dd('prePersist');
  276. //        $certDocEntity = $args->getObject();
  277. //        if ($certDocEntity instanceof CustomerCertificateDocuments ) {
  278. //            $certDocEntity->setServiceArgumentFileFetchDir( $this->servArgCustomerCertFetchDir,  );
  279. //        }
  280. //
  281. //        if ( $certDocEntity instanceof WorkerCertificateDocuments ) {
  282. //            $certDocEntity->setServiceArgumentFileFetchDir( $this->servArgWorkerCertFetchDir );
  283. //        }
  284. //    }
  285.     // Set the services.yaml param on the entity
  286. //    public function preUpdate( LifecycleEventArgs $args)
  287. //    {
  288. //        dd('preUpdate');
  289. //        $certDocEntity = $args->getObject();
  290. //        if ($certDocEntity instanceof CustomerCertificateDocuments ) {
  291. //            $certDocEntity->setServiceArgumentFileFetchDir( $this->servArgCustomerCertFetchDir );
  292. //        }
  293. //
  294. //        if ( $certDocEntity instanceof WorkerCertificateDocuments ) {
  295. //            $certDocEntity->setServiceArgumentFileFetchDir( $this->servArgWorkerCertFetchDir );
  296. //        }
  297. //    }
  298. }