src/Controller/Api/v3/ProjectOrderController.php line 45

Open in your IDE?
  1. <?php
  3. namespace App\Controller\Api\v3;
  5. use App\Controller\Api\Service\EmployeeActivityService;
  6. use App\Controller\Api\Service\ProjectOrderService;
  7. use App\Controller\Api\Service\ReferenceService;
  8. use App\Entity\ContactPersonPositions;
  9. use App\Entity\ProjectOrders;
  10. use App\Entity\ProjectOrderTaskJobs;
  11. use App\Entity\ProjectOrderUndertakings;
  12. use App\Entity\Projects;
  13. use App\Entity\WorkerTimesheet;
  14. use App\Enum\SeverityInterface;
  15. use App\Service\Calculators\ProjectOrderCalculator;
  16. use App\Service\SerializeService\EmployeeSerialize;
  17. use App\Service\SerializeService\ExpenseSerialize;
  18. use App\Service\SerializeService\ProjectOrderSerialize;
  19. use App\Service\SerializeService\ProjectSerialize;
  20. use App\Service\SerializeService\ReferenceSerialize;
  21. use App\Service\StreamingService;
  22. use App\Service\WorksPlan\WorksPlanMaterializer;
  23. use Doctrine\ORM\EntityManagerInterface;
  24. use phpDocumentor\Reflection\Types\This;
  25. use Sensio\Bundle\FrameworkExtraBundle\Configuration\ParamConverter;
  26. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  27. use Symfony\Component\HttpFoundation\Request;
  28. use Symfony\Component\HttpFoundation\Response;
  29. use Symfony\Component\HttpFoundation\StreamedResponse;
  30. use Symfony\Component\Routing\Annotation\Route;
  31. use Symfony\Component\Serializer\SerializerInterface;
  32. use Symfony\Contracts\Translation\TranslatorInterface;
  34. /**
  35.  * @Route("/api/v3/project-order")
  36.  */
  37. class ProjectOrderController extends AbstractController
  38. {
  40.     /**
  41.      * @Route("/orders/{project_id}", name="api_v3_project_order_orders", methods={"POST"}, requirements={"project_id": "\d+"} ,defaults={"project_id": null} )
  42.      * @ParamConverter("project", options={"mapping":{"project_id": "id"}})
  43.      * @throws \Exception
  44.      */
  45.     public function orders( ?Projects $project, ProjectSerialize $projectSerialize, ProjectOrderService $projectOrderService, ProjectOrderSerialize $projectOrderSerialize, TranslatorInterface $translator,
  46.             Request $request,
  47.              ?int $project_id): Response
  48.     {
  49.         if( $project_id && !$project ){
  50.             return $this->json([
  51.                 "message" => $translator->trans('Project not found'),
  52.                 "severity" => SeverityInterface::ERROR
  53.             ], Response::HTTP_NOT_FOUND);
  54.         }
  56.         // $orders = $project->getProjectOrders();
  57.         // ℹ️ℹ️ 💀💀 This is a old, By New Version success with Task/Jobs Weight!!! 💀💀 ℹ️ℹ️
  58.         // $orders = $projectOrderService->setEntity($project)->findByFeedbackStatus($request->request->get('type'), $range['from'], $range['to']);
  60.         // Project Based | All
  61.         if($project){
  62.             $projectOrderService->setProject($project);
  63.         }
  65.         $orders = $projectOrderService->setParams($request->request)->fetchAll();
  67.         // No need use the service, while project delivered by Dependency Injection
  68.         $serializedProjectOrders = $projectOrderSerialize->setEntity($orders)->serializeListNested();
  69.         $projectBase = $projectSerialize->setEntity($project)->serializeBase();
  72.         return $this->json([
  73.             "message" => $translator->trans('Loaded project orders successfully'),
  74.             "severity" => SeverityInterface::SUCCESS,
  75.             // TODO Remove Two of One
  76.             "projectOrders" => $serializedProjectOrders,
  77.             "orders" => $serializedProjectOrders,
  78.             "projectBase" => $projectBase
  79.         ], Response::HTTP_OK );
  81.     }
  83.     /**
  84.      * Serialize with minimal groups
  85.      * @Route("/smart-orders/{project_id}", name="api_v3_project_order_smart_orders", methods={"POST"}, requirements={"project_id": "\d+"} ,defaults={"project_id": null} )
  86.      * @ParamConverter("project", options={"mapping":{"project_id": "id"}})
  87.      * @throws \Exception
  88.      */
  89.     public function smartOrders( ?Projects $project, ProjectOrderService $projectOrderService, ProjectOrderSerialize $projectOrderSerialize, TranslatorInterface $translator, ?int $project_id): Response
  90.     {
  91.         if( $project_id && !$project ){
  92.             return $this->json([
  93.                 "message" => $translator->trans('Project not found'),
  94.                 "severity" => SeverityInterface::ERROR
  95.             ], Response::HTTP_NOT_FOUND);
  96.         }
  98.         // Project Based | All
  99.         if($project){
  100.             $projectOrderService->setProject($project);
  101.         }
  102.         $orders = $projectOrderService->fetchAll();
  104.         // No need use the service, while project delivered by Dependency Injection
  105.         $serializedProjectOrders = $projectOrderSerialize->setEntity($orders)->serializeForSelector();
  107.         return $this->json([
  108.             "message" => $translator->trans('Loaded project orders successfully'),
  109.             "severity" => SeverityInterface::SUCCESS,
  110.             "orders" => $serializedProjectOrders,
  111.         ], Response::HTTP_OK );
  113.     }
  116.     /**
  117.      * Streamed Order
  118.      * @Route("/streamed-fetch/{project_id}/{order_id}", name="api_v3_project_order_streamed_fetch", requirements={"project_id": "\d+", "order_id": "\d+"}, defaults={"order_id": null} )
  119.      * @ParamConverter("project", options={"mapping":{"project_id": "id"}})
  120.      * @ParamConverter("projectOrder", options={"mapping":{"order_id": "id"}})
  121.      */
  122.     public function streamedFetch( ?Projects $project, ?ProjectOrders $projectOrder,
  123.                                    ProjectOrderSerialize $projectOrderSerialize,
  124.                                    ReferenceSerialize $referenceSerialize,
  125.                                    ReferenceService $referenceService,
  126.                                    EmployeeActivityService $employeeActivityService, EmployeeSerialize $employeeSerialize, ProjectSerialize $projectSerialize,
  127.                                 TranslatorInterface $translator,
  128.                                 WorksPlanMaterializer $worksPlanMaterializer,
  129.                                 EntityManagerInterface $manager
  130.     ): StreamedResponse
  131.     {
  132.         // Plana bağlı order → AÇILIŞTA plandan SYNC (execution-preserve). Stream BAŞLAMADAN,
  133.         // normal request bağlamında yap (mid-stream flush + back-sync yan etkileri SSE'yi kırıyordu).
  134.         // Plan boşsa (task yok / kaydedilmemiş) order'ı silme → guard.
  135.         if ($projectOrder !== null) {
  136.             $boundPlan = $projectOrder->getWorksPlan();
  137.             if ($boundPlan !== null && count($boundPlan->getTasks()) > 0) {
  138.                 $worksPlanMaterializer->materialize($boundPlan);
  139.                 $manager->flush();
  140.             }
  141.         }
  143.         $streaming = new StreamingService([
  144.             "localText" => ["completed" => $translator->trans('Completed')]
  145.         ]);
  147.         $streaming->appendStream(
  148.             'employees',
  149.             $translator->trans('Loading employee...'),
  150.             fn() => $employeeSerialize->setEntity($employeeActivityService->fetchActiveEmployees())->setGroups([
  151.                 "worker_activity@base",
  152.                 "worker_activity@worker",
  153.                 "worker@base",
  154.                 "worker_activity@partner",
  155.                 "partner@base"
  156.             ])->render()
  157.         );
  159.         $streaming->appendStream(
  160.             'invoiceTypes',
  161.             $translator->trans('Loading invoice Types...'),
  162.             fn() => $referenceSerialize->setEntity($referenceService->invoiceTypes())->setGroups([
  163.                 "invoice_type@base"
  164.             ])->render()
  165.         );
  167.         $streaming->appendStream(
  168.             'project',
  169.             $translator->trans('Loading project...'),
  170.             function () use ($project, $projectSerialize) {
  172.                 if (!$project) {
  173.                     throw new \DomainException('Project not found');
  174.                 }
  176.                 return $projectSerialize->setEntity($project)->setGroups([
  177.                     "project@core",
  178.                     "project@owner",
  179.                     "project_owner@base",
  180.                     "project_owner@contact_persons",
  181.                     "contact_person@core",
  182.                     "contact_person@positions",
  183.                     "contact_person_position@base",
  184.                     "project@branches",
  185.                     "branch@core",
  186.                     "branch@departments",
  187.                     "branch_department@core",
  188.                     "project@invoice_type",
  189.                     "invoice_type@base",
  190.                     "project@settings",
  191.                     "project_setting@core"
  192.                 ])->render();
  193.             }
  194.         );
  196.         $streaming->appendStream(
  197.             'corporateHierarchy',
  198.             $translator->trans('Loading Corporate Hierarchy...'),
  199.             function () use ($referenceService, $referenceSerialize) {
  201.                 $corporate_hierarchy = $referenceService->setClassName(ContactPersonPositions::class)->fetch();
  203.                 return $referenceSerialize->setEntity($corporate_hierarchy)->setGroups([
  204.                     "contact_person_position@base"
  205.                 ])->render();
  206.             }
  207.         );
  209.         $streaming->appendStream(
  210.             'projectOrder',
  211.             $translator->trans('Loading project order...'),
  212.             function() use ($projectOrder, $projectOrderSerialize){
  213.                 if(!$projectOrder){
  214.                     return null;
  215.                 }
  216.                 // Sync yukarıda (stream öncesi) yapıldı; burada sadece serialize.
  217.                 return $projectOrderSerialize->setEntity($projectOrder)->serializeFull();
  218.             }
  219.         );
  221.         return $streaming->flush();
  223.     }
  225.     /**
  226.      * @Route("/fetch/{order_id}", name="api_v3_project_order_fetch", methods={"POST"}, defaults={"order_id": null})
  227.      * @ParamConverter("projectOrder", options={"mapping":{"order_id": "id"}})
  228.      * @throws \Exception
  229.      */
  230.     public function fetch( ?ProjectOrders $projectOrder, ProjectOrderSerialize $projectOrderSerialize, TranslatorInterface $translator, ?int $order_id = null ): Response {
  231.         if($order_id && !$projectOrder){
  232.             return $this->json([
  233.                 "message" => $translator->trans("Order not found!"),
  234.                 "severity" => SeverityInterface::WARNING
  235.             ], Response::HTTP_NOT_FOUND );
  236.         }
  237.         $orderSerialized = $projectOrderSerialize->setEntity($projectOrder)->serializeFull();
  238.         return $this->json([
  239.             "message" => $translator->trans('Order fetched successfully'),
  240.             "severity" => SeverityInterface::SUCCESS,
  241.             "projectOrder" => $orderSerialized
  242.         ]);
  243.     }
  246.     /**
  247.      * Tek job için tamamlama uygunluğu (live kontrol) — checkbox/Zeitachse öncesi.
  248.      * @Route("/job-completion-check/{job_id}", name="api_v3_project_order_job_completion_check", methods={"POST"}, requirements={"job_id": "\d+"})
  249.      * @ParamConverter("job", options={"mapping":{"job_id": "id"}})
  250.      */
  251.     public function jobCompletionCheck( ?ProjectOrderTaskJobs $job, ProjectOrderService $projectOrderService, TranslatorInterface $translator, int $job_id ): Response {
  252.         if (!$job) {
  253.             return $this->json([
  254.                 "message" => $translator->trans('Job not found'),
  255.                 "severity" => SeverityInterface::ERROR
  256.             ], Response::HTTP_NOT_FOUND);
  257.         }
  259.         $result = $projectOrderService->checkJobCompletion($job);
  261.         return $this->json([
  262.             "allowed" => $result['allowed'],
  263.             "start_at" => $result['start_at'],
  264.             "message" => $result['message'],
  265.             "severity" => $result['allowed'] ? SeverityInterface::SUCCESS : SeverityInterface::WARNING
  266.         ]);
  267.     }
  270.     /**
  271.      * @Route("/upsert/{project_id}/{order_id}", name="api_v3_project_order_handle", methods={"POST"}, requirements={"project_id": "\d+"}, defaults={"order_id": null})
  272.      * @ParamConverter("project", options={"mapping":{"project_id": "id"}})
  273.      * @ParamConverter("projectOrder", options={"mapping":{"order_id": "id"}})
  274.      * @throws \Exception
  275.      */
  276.     public function upsert( ?Projects $project, ?ProjectOrders $projectOrder, ProjectOrderService $projectOrderService, ProjectOrderSerialize $projectOrderSerialize, Request $request, TranslatorInterface $translator, ?int $order_id = null ): Response {
  278.         $projectOrder = $projectOrderService
  279.             ->setEntity($projectOrder, $order_id)
  280.             ->setParams($request->request)
  281.             ->upsert($project);
  283.         if($projectOrderService->getException()){
  284.             return $this->json([
  285.                 "message" => $projectOrderService->getException()->getMessage(),
  286.                 "severity" => SeverityInterface::WARNING
  287.             ], $projectOrderService->getException()->getCode() );
  288.         }
  290.         $projectOrderSerialized = $projectOrderSerialize->setEntity($projectOrder)->serializeFull();
  292. //        echo '<pre>';
  293. //        print_r($projectOrderSerialized);
  294. //        echo '</pre>';
  295. //        dd();
  297.         return $this->json([
  298.             "message" => $translator->trans('Order managed successfully'),
  299.             "severity" => SeverityInterface::SUCCESS,
  300.             "projectOrder" => $projectOrderSerialized
  301.         ]);
  302.     }
  305.     /**
  306.      * @Route("/fetch-order-billings/{order_id}", name="api_v3_project_order_fetch_billings", methods={"POST"}, requirements={"order_id": "\d+"}, defaults={"order_id": null} )
  307.      * @ParamConverter("project", options={"mapping":{"project_id": "id"}})
  308.      * @ParamConverter("projectOrder", options={"mapping":{"order_id": "id"}})
  309.      * @throws \Exception
  310.      */
  311.     public function fetchOrderBillings( ?ProjectOrders $projectOrder, ProjectOrderSerialize $projectOrderSerialize, ReferenceSerialize $referenceSerialize, TranslatorInterface $translator, Request $request, int $order_id ): Response
  312.     {
  313.         if ($order_id && !$projectOrder) {
  314.             return $this->json([
  315.                 "message"  => $translator->trans('Project order not found'),
  316.                 "severity" => SeverityInterface::ERROR
  317.             ], Response::HTTP_NOT_FOUND);
  318.         }
  320.         $billings = $projectOrder->getOrderBillings();
  322.         // Deep note: serializeFull() is scoped to the aggregate root (Billings),
  323.         // so only billing fields and their owned relations are included.
  324.         $serializedProjectOrderBillings = $projectOrderSerialize->setEntity($billings)->serializeFull();
  326.         $serializedPaymentStatus = $referenceSerialize->serializedInvoicePaymentStatus();
  329.         return $this->json([
  330.             "message" => $translator->trans('Loaded project orders successfully'),
  331.             "severity" => SeverityInterface::SUCCESS,
  332.             "billings" => $serializedProjectOrderBillings,
  333.             "masterData" => [
  334.                 "paymentStatuses" => $serializedPaymentStatus
  335.             ]
  336.         ], Response::HTTP_OK );
  338.     }
  340.     /**
  341.      * @deprecated @see in Billings Service
  342.      * @Route("/upsert-billings/{order_id}", name="api_v3_project_order_upsert_billings", methods={"POST"}, requirements={"order_id": "\d+"}, defaults={"voucher_id": null} )
  343.      * @ParamConverter("projectOrder", options={"mapping":{"order_id": "id"}})
  344.      * @ParamConverter("undertaking", options={"mapping":{"voucher_id": "id"}})
  345.      * @throws \Exception
  346.      */
  347.     public function upsertBillings(
  348.         ?ProjectOrders $projectOrder,
  349.         ProjectOrderService $projectOrderService,
  350.         ProjectOrderSerialize $projectOrderSerialize,
  351.         TranslatorInterface $translator,
  352.         Request $request,
  353.         int $order_id,
  354.         ?int $voucher_id ): Response
  355.     {
  357.         return $this->json([
  358.             "message" => $translator->trans('This route not more efficient, please use direct in/on Billings Service'),
  359.             "severity" => SeverityInterface::WARNING
  360.         ], Response::HTTP_UNAUTHORIZED );
  362.     }
  364.     /**
  365.      * TODO Remove Forever
  366.      * @deprecated
  367.      * @see upsertBillings in this controller
  368.      * @Route("/upsert-voucher/{order_id}/{voucher_id}", name="api_v3_project_order_upsert_voucher", methods={"POST"}, requirements={"order_id": "\d+"}, defaults={"voucher_id": null} )
  369.      * @ParamConverter("projectOrder", options={"mapping":{"order_id": "id"}})
  370.      * @ParamConverter("undertaking", options={"mapping":{"voucher_id": "id"}})
  371.      * @throws \Exception
  372.      */
  373.     public function upsertVoucher(
  374.         ?ProjectOrders $projectOrder,
  375.         ?ProjectOrderUndertakings $undertaking,
  376.         ProjectOrderService $projectOrderService,
  377.         ProjectOrderSerialize $projectOrderSerialize,
  378.         TranslatorInterface $translator,
  379.         Request $request,
  380.         int $order_id,
  381.         ?int $voucher_id ): Response
  382.     {
  384.         return $this->json([
  385.             "message" => $translator->trans('This route not more efficient, please use direct in/on Billings Service'),
  386.             "severity" => SeverityInterface::WARNING
  387.         ], Response::HTTP_UNAUTHORIZED );
  389.         if ($order_id && !$projectOrder) {
  390.             return $this->json([
  391.                 "message"  => $translator->trans('Project order not found'),
  392.                 "severity" => SeverityInterface::ERROR
  393.             ], Response::HTTP_NOT_FOUND);
  394.         }
  395.         // matched !!
  396.         if(!$undertaking && $voucher_id){
  397.             #dd($projectOrder);
  398.             $founded = $projectOrder->getProjectOrderUndertakings()->exists( fn($key, ProjectOrderUndertakings $undertaking) => $undertaking->getId() === $voucher_id );
  399.             if(!$founded){
  400.                 return $this->json([
  401.                     "message"  => $translator->trans('Voucher not matched with order!'),
  402.                     "severity" => SeverityInterface::ERROR
  403.                 ], Response::HTTP_NOT_FOUND);
  404.             }
  405.         }
  407.         $voucher = $projectOrderService->upsertVoucher($projectOrder, $undertaking, $request->request);
  409.         #dd($voucher);
  410.         if($projectOrderService->getException()){
  411.             return $this->json([
  412.                 "message" => $projectOrderService->getException()->getMessage(),
  413.                 "severity" => "warning"
  414.             ], $projectOrderService->getException()->getCode() );
  415.         }
  417.         $serializedVoucher = $projectOrderSerialize->setEntity($voucher)->serializeVoucher();
  418.         $serializedMetrics = $projectOrderSerialize->setEntity($projectOrder->getProjectOrderMetrics())->serializeFull();
  419.         // Just info
  420.         $serializedOrder = $projectOrderSerialize->setEntity($projectOrder)->serializeFull();
  421.         return $this->json([
  422.             "message" => $translator->trans('Loaded project orders successfully'),
  423.             "severity" => SeverityInterface::SUCCESS,
  424.             "voucher" => $serializedVoucher,
  425.             "metrics" => $serializedMetrics,
  426.             "hotEntity" => $serializedOrder,
  428.         ], Response::HTTP_OK );
  430.     }
  433.     /**
  434.      * TODO Remove forever
  435.      * @deprecated
  436.      * @see removeBillings in this controller
  437.      * @Route("/delete-voucher/{voucher_id}", name="api_v3_project_order_delete_voucher", methods={"POST"}, requirements={"voucher_id": "\d+"} )
  438.      * @ParamConverter("undertaking", options={"mapping":{"voucher_id": "id"}})
  439.      * @deprecated
  440.      */
  441.     public function deleteVoucher(?ProjectOrderUndertakings $undertaking, ProjectOrderService $projectOrderService, ProjectOrderSerialize $projectOrderSerialize, TranslatorInterface $translator): Response {
  443.         return $this->json([
  444.             "message" => $translator->trans('This route not more efficient, please use direct in/on Billings Service'),
  445.             "severity" => SeverityInterface::WARNING
  446.         ], Response::HTTP_UNAUTHORIZED );
  448.         if(!$undertaking){
  449.             return $this->json([
  450.                 "message" => $translator->trans("Undertaking not found!"),
  451.                 "severity" => SeverityInterface::ERROR,
  452.             ], Response::HTTP_NOT_FOUND);
  453.         }
  455.         $clonedVoucher = [
  456.             "id" => $undertaking->getId()
  457.         ];
  459.         // Store
  460.         $serializedVoucher = $projectOrderSerialize->setEntity($undertaking)->serializeVoucher();
  462.         // Delete -> Metrics has been fresh after delete
  463.         $metrics = $projectOrderService->deleteVoucher($undertaking);
  465.         if($projectOrderService->getException()){
  466.             return $this->json([
  467.                 "message" => $projectOrderService->getException()->getMessage(),
  468.                 "severity" => SeverityInterface::WARNING
  469.             ], Response::HTTP_BAD_REQUEST );
  470.         }
  472.         $serializedMetrics = $projectOrderSerialize->setEntity($metrics)->serializeFull();
  474.         return $this->json([
  475.             "message" => "Undertaking removed successfully",
  476.             "severity" => SeverityInterface::SUCCESS,
  477.             "id" => $clonedVoucher['id'],
  478.             "voucher" => $serializedVoucher,
  479.             "metrics" => $serializedMetrics,
  480.             "mode" => "delete"
  481.         ]);
  483.     }
  486.     /**
  487.      * @Route("/refresh-metrics/{order_id}", name="api_v3_project_order_refresh_metrics", methods={"POST"}, requirements={"order_id": "\d+"} )
  488.      * @ParamConverter("projectOrder", options={"mapping":{"order_id": "id"}})
  489.      * @throws \Exception
  490.      */
  491.     public function refreshMetrics(?ProjectOrders $projectOrder, ProjectOrderService $projectOrderService, ProjectOrderSerialize $projectOrderSerialize, TranslatorInterface $translator, int $order_id = null): Response {
  493.         if(!$projectOrder){
  494.             return $this->json([
  495.                 "message" => $translator->trans("Undertaking not found!"),
  496.                 "severity" => SeverityInterface::ERROR,
  497.             ], Response::HTTP_NOT_FOUND);
  498.         }
  500.         // Void in Service flushed
  501.         // $projectOrderCalculator->updateProjectOrderMetrics($projectOrder);
  502.         $projectOrderService
  503.             ->setEntity($projectOrder, $order_id)
  504.             ->recalculateMetrics();
  506.         if($projectOrderService->getException()){
  507.             return $this->json([
  508.                 "message" => $projectOrderService->getException()->getMessage(),
  509.                 "severity" => SeverityInterface::WARNING
  510.             ], Response::HTTP_BAD_REQUEST );
  511.         }
  513.         // Store
  514.         $serializedMetrics = $projectOrderSerialize->setEntity($projectOrder->getProjectOrderMetrics())->serializeMetrics();
  516.         return $this->json([
  517.             "message" => "Undertaking removed successfully",
  518.             "severity" => SeverityInterface::SUCCESS,
  519.             "project_order_metrics" => $serializedMetrics,
  520.         ], Response::HTTP_OK);
  522.     }
  524.     /**
  525.      * @Route("/expenses/{order_id}", name="api_v3_project_order_expenses")
  526.      * @ParamConverter("order", options={"mapping": {"order_id": "id"}})
  527.      * @throws \ReflectionException
  528.      * @throws \Exception
  529.      */
  530.     function expenses( ?ProjectOrders $order, ProjectOrderService $projectOrderService, ExpenseSerialize $expenseSerialize, TranslatorInterface $translator, ?int $order_id = null): Response {
  532.         if($order_id && !$order){
  533.             return $this->json([
  534.                 "message" => $translator->trans("Order not found!"),
  535.                 "severity" => SeverityInterface::ERROR,
  536.             ], Response::HTTP_NOT_FOUND);
  537.         }
  539.         $result   = $projectOrderService->setEntity($order)->orderExpenses();
  540.         $expenses = $result['classic'];
  541.         $stock    = $result['stock'];
  543.         $serializedExpenses = $expenseSerialize->setEntity($expenses)->serializeOrderExpenses();
  544.         $serializedStock    = $expenseSerialize->setEntity($stock)->serializeOrderStocks();
  546.         return $this->json([
  547.             "message" => "Successfully loaded",
  548.             "severity" => "success",
  549.             "expenses" => $serializedExpenses,
  550.             "stock"    => $serializedStock
  551.         ]);
  552.     }
  555.     /**
  556.      * @Route("/labor-details/{order_id}", name="employee_worked_navigator", methods={"POST"})
  557.      * @ParamConverter("order", options={"mapping": {"order_id": "id"}})
  558.      * @throws \Exception
  559.      */
  560.     function laborDetails(?ProjectOrders $order, ProjectOrderService $projectOrderService, Request $request): Response{
  562.         $laborDetails = $projectOrderService
  563.             ->setEntity($order)
  564.             ->setParams($request->request)
  565.             ->laborDetails();
  567.         if($projectOrderService->getException()){
  568.             return $this->json([
  569.                 "message" => $projectOrderService->getException()->getMessage(),
  570.                 "severity" => SeverityInterface::WARNING
  571.             ], Response::HTTP_BAD_REQUEST );
  572.         }
  574.         return $this->json($laborDetails, Response::HTTP_OK);
  576.     }
  578.     /**
  579.      * @Route("/labor-details-pdf/{order_id}", name="api_v3_project_order_labor_details_pdf", methods={"POST"})
  580.      * @ParamConverter("order", options={"mapping": {"order_id": "id"}})
  581.      */
  582.     public function laborDetailsPdf(
  583.         ?ProjectOrders $order,
  584.         Request $request,
  585.         ProjectOrderService $projectOrderService,
  586.         TranslatorInterface $translator
  587.     ): Response {
  588.         if (!$order) {
  589.             return $this->json([
  590.                 'message'  => $translator->trans('Order not found!'),
  591.                 'severity' => SeverityInterface::WARNING,
  592.             ], Response::HTTP_NOT_FOUND);
  593.         }
  595.         /** @var \App\Entity\User $currentUser */
  596.         $currentUser = $this->getUser();
  597.         $printedBy   = $currentUser ? $currentUser->getFullName() : '—';
  599.         $result = $projectOrderService
  600.             ->setEntity($order)
  601.             ->setParams($request->request)
  602.             ->laborDetailsPdf($printedBy);
  604.         if ($projectOrderService->getException()) {
  605.             return $this->json([
  606.                 'message'  => $projectOrderService->getException()->getMessage(),
  607.                 'severity' => SeverityInterface::ERROR,
  608.             ], Response::HTTP_BAD_REQUEST);
  609.         }
  611.         return $this->json(
  612.             array_merge($result, ['severity' => SeverityInterface::SUCCESS]),
  613.             Response::HTTP_OK
  614.         );
  615.     }
  617.     /**
  618.      * Silme/tasima oncesi deger-bazli bagimlilik ozeti (preview).
  619.      * Worktime icin tum timesheet'ler taranir -> streamed (progress).
  620.      * EventSource yalnizca GET yapar -> methods YAZILMAZ.
  621.      *
  622.      * @Route("/dependency-summary/{order_id}", name="api_v3_project_order_dependency_summary", requirements={"order_id": "\d+"} )
  623.      * @ParamConverter("order", options={"mapping":{"order_id": "id"}})
  624.      */
  625.     public function dependencySummary(?ProjectOrders $order, ProjectOrderService $projectOrderService, TranslatorInterface $translator): StreamedResponse
  626.     {
  627.         $streaming = new StreamingService([
  628.             "localText" => ["completed" => $translator->trans('Completed')]
  629.         ]);
  631.         $streaming->appendStream(
  632.             'summary',
  633.             $translator->trans('Calculating order dependencies, please wait...'),
  634.             function () use ($order, $projectOrderService, $translator) {
  635.                 if (!$order) {
  636.                     throw new \DomainException($translator->trans('Order not found'));
  637.                 }
  638.                 return $projectOrderService->setEntity($order)->dependencySummary();
  639.             }
  640.         );
  642.         return $streaming->flush();
  643.     }
  645.     /**
  646.      * Order'i ve butun bagimliliklarini cascade siler.
  647.      * Kesilmis faturaya bagli pozisyon varsa reddeder.
  648.      *
  649.      * @Route("/delete/{order_id}", name="api_v3_project_order_delete", methods={"POST"}, requirements={"order_id": "\d+"} )
  650.      * @ParamConverter("order", options={"mapping":{"order_id": "id"}})
  651.      * @throws \Exception
  652.      */
  653.     public function delete(?ProjectOrders $order, ProjectOrderService $projectOrderService, TranslatorInterface $translator, Request $request, ?int $order_id = null): Response
  654.     {
  655.         if ($order_id && !$order) {
  656.             return $this->json([
  657.                 "message" => $translator->trans("Order not found!"),
  658.                 "severity" => SeverityInterface::ERROR
  659.             ], Response::HTTP_NOT_FOUND);
  660.         }
  662.         // Faturali order'da blok'u asmak icin force + override sifresi
  663.         $force = filter_var($request->request->get('force'), FILTER_VALIDATE_BOOLEAN);
  664.         $password = $request->request->get('password');
  666.         $result = $projectOrderService->setEntity($order)->cascadeDelete($force, $password);
  668.         if ($projectOrderService->getException()) {
  669.             $exception = $projectOrderService->getException();
  670.             return $this->json([
  671.                 "message" => $exception->getMessage(),
  672.                 "severity" => SeverityInterface::WARNING
  673.             ], $exception->getCode() === Response::HTTP_UNAUTHORIZED ? Response::HTTP_UNAUTHORIZED : Response::HTTP_BAD_REQUEST);
  674.         }
  676.         return $this->json([
  677.             "message" => $translator->trans('Order and its dependencies deleted successfully'),
  678.             "severity" => SeverityInterface::SUCCESS,
  679.             "id" => $result['id'],
  680.             "mode" => "delete",
  681.             "source_project" => $result['source_project'] ?? null
  682.         ], Response::HTTP_OK);
  683.     }
  685.     /**
  686.      * Order'i + TUM bagimliliklarini streamed (adim adim) force-delete eder. GERI DONUS YOK.
  687.      * EventSource yalnizca GET -> methods YAZILMAZ. Sifre query param (fatura bagliysa zorunlu).
  688.      *
  689.      * @Route("/force-delete-streamed/{order_id}", name="api_v3_project_order_force_delete_streamed", requirements={"order_id": "\d+"} )
  690.      * @ParamConverter("order", options={"mapping":{"order_id": "id"}})
  691.      */
  692.     public function forceDeleteStreamed(?ProjectOrders $order, ProjectOrderService $projectOrderService, Request $request): StreamedResponse
  693.     {
  694.         $password = $request->query->get('password');
  695.         return $projectOrderService->setEntity($order)->forceDeleteStreamed($password);
  696.     }
  698.     /**
  699.      * Order'in butun bagimliliklarini hedef order'a tasir (ayni proje icinde).
  700.      *
  701.      * @Route("/move/{from_order_id}/{to_order_id}", name="api_v3_project_order_move", methods={"POST"}, requirements={"from_order_id": "\d+", "to_order_id": "\d+"} )
  702.      * @ParamConverter("from", options={"mapping":{"from_order_id": "id"}})
  703.      * @ParamConverter("to", options={"mapping":{"to_order_id": "id"}})
  704.      * @throws \Exception
  705.      */
  706.     public function move(?ProjectOrders $from, ?ProjectOrders $to, ProjectOrderService $projectOrderService, TranslatorInterface $translator): Response
  707.     {
  708.         if (!$from || !$to) {
  709.             return $this->json([
  710.                 "message" => $translator->trans("Order not found!"),
  711.                 "severity" => SeverityInterface::ERROR
  712.             ], Response::HTTP_NOT_FOUND);
  713.         }
  715.         $result = $projectOrderService->setEntity($from)->moveAllDependenciesTo($to);
  717.         if ($projectOrderService->getException()) {
  718.             return $this->json([
  719.                 "message" => $projectOrderService->getException()->getMessage(),
  720.                 "severity" => SeverityInterface::WARNING
  721.             ], Response::HTTP_BAD_REQUEST);
  722.         }
  724.         return $this->json([
  725.             "message" => $translator->trans('Order dependencies moved successfully'),
  726.             "severity" => SeverityInterface::SUCCESS,
  727.             "from" => $result['from'],
  728.             "to" => $result['to'],
  729.             "mode" => "move"
  730.         ], Response::HTTP_OK);
  731.     }
  733. }