src/Controller/Api/v3/TaskExecutionController.php line 357

Open in your IDE?
  1. <?php
  3. namespace App\Controller\Api\v3;
  5. use App\Controller\Api\Service\TaskExecutionService;
  6. use App\Entity\ProjectOrderTaskFulfillment;
  7. use App\Entity\ProjectOrderTasks;
  8. use App\Enum\ReferenceEnum;
  9. use App\Enum\SeverityInterface;
  10. use App\Service\SerializeService\BranchSerialize;
  11. use App\Service\SerializeService\OrderTaskFulfillmentSerialize;
  12. use App\Service\SerializeService\ProjectOrderTaskFulfillmentMessageSerialize;
  13. use App\Service\SerializeService\ReferenceSerialize;
  14. use App\Service\SerializeService\VendorSerialize;
  15. use App\Service\StreamingService;
  16. use Sensio\Bundle\FrameworkExtraBundle\Configuration\IsGranted;
  17. use Sensio\Bundle\FrameworkExtraBundle\Configuration\ParamConverter;
  18. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  19. use Symfony\Component\HttpFoundation\BinaryFileResponse;
  20. use Symfony\Component\HttpFoundation\Request;
  21. use Symfony\Component\HttpFoundation\Response;
  22. use Symfony\Component\HttpFoundation\ResponseHeaderBag;
  23. use Symfony\Component\HttpFoundation\StreamedResponse;
  24. use Symfony\Component\Routing\Annotation\Route;
  25. use Symfony\Contracts\Translation\TranslatorInterface;
  27. /**
  28.  * TaskExecution — Order Task → [Execute] → Servise devret (ERP tarafı, oturumlu
  29.  * kullanıcı). Ağ içi (X-Internal-Token) uçlar için bkz. TaskExecutionInternalController.
  30.  * Eski Fulfillment akışına (OrderTaskFulfillmentController) DOKUNULMADI.
  31.  *
  32.  * Yanıt sözleşmesi te-frontend ile 2026-08-10'da donduruldu (bkz. FE
  33.  * `Tasks/types/task.execution.types.ts` + `hooks/useTaskExecution.tsx`):
  34.  *   - execution/upsert/publish yanıtlarında entity anahtarı **`execution`** (taskExecution DEĞİL)
  35.  *   - `open` yanıtı execution'ın YANINDA `branches`/`vendor`/`reasons`'ı da BUNDLE eder
  36.  *     (FE `needed-collections`'ı bu turda ayrıca ÇAĞIRMIYOR — open tek seferde yeterli olsun diye)
  37.  *
  38.  * @Route("/api/v3/task-execution")
  39.  */
  40. class TaskExecutionController extends AbstractController
  41. {
  42.     /**
  43.      * K4 — find-or-create draft. execution + wizard'ın ihtiyaç duyduğu master-data
  44.      * (branches/vendor/reasons) TEK yanıtta döner (FE sözleşmesi).
  45.      *
  46.      * @Route("/open/{task_id}", name="api_v3_task_execution_open", methods={"POST"})
  47.      * @ParamConverter("task", options={"mapping": {"task_id": "id"}})
  48.      * @IsGranted("SECTION:order:task:u")
  49.      */
  50.     public function open(
  51.         ProjectOrderTasks $task,
  52.         TranslatorInterface $translator,
  53.         TaskExecutionService $service,
  54.         OrderTaskFulfillmentSerialize $serialize,
  55.         BranchSerialize $branchSerialize,
  56.         VendorSerialize $vendorSerialize,
  57.         ReferenceSerialize $referenceSerialize
  58.     ): Response {
  59.         try {
  60.             $execution = $service->open($task);
  61.         } catch (\DomainException $e) {
  62.             // İş kuralı reddi (ownership) — 403 KULLANMA: FE'de HttpRequest 403'ü "oturum düştü"
  63.             // sayıp window.location.reload() yapıyor (HttpRequest.tsx:189). upsert/publish ile
  64.             // tutarlı: 409 → FE snackbar gösterir, sayfa reload OLMAZ.
  65.             return $this->json([
  66.                 'message'  => $translator->trans($e->getMessage()),
  67.                 'severity' => SeverityInterface::ERROR,
  68.             ], Response::HTTP_CONFLICT);
  69.         }
  71.         return $this->json([
  72.             'message'   => $translator->trans('Task execution ready'),
  73.             'severity'  => SeverityInterface::SUCCESS,
  74.             // serializeFullPreview — SummaryView (published/readOnly ekran) progress ring + job
  75.             // breakdown çizsin diye execution_progress (@progress) + task.task_jobs[] taşır.
  76.             'taskExecution' => $serialize->setEntity($execution)->serializeFullPreview(),
  77.             'branches'  => $this->serializeBranches($service, $branchSerialize),
  78.             'vendor'    => $vendorSerialize->setEntity($service->fetchActiveVendors())->serializeFull(),
  79.             'reasons'   => $referenceSerialize->setEntity($service->fetchAllReasons())->serializeCustomCore(ReferenceEnum::TASK_FULFILLMENT_REASON),
  80.             // Layout B "canlı brief" eklentisi — order'a şimdiye kadar yüklenen/harcanan maliyet
  81.             // (EUR). Kaynak: project_order_metrics.spent_costs, SADECE READ. Şema/hesap DEĞİŞMEDİ.
  82.             'order_spent' => $service->getOrderSpentCost($task),
  83.         ], Response::HTTP_OK);
  84.     }
  86.     /**
  87.      * @Route("/upsert/{id}", name="api_v3_task_execution_upsert", methods={"POST"})
  88.      * @ParamConverter("execution", options={"mapping": {"id": "id"}})
  89.      * @IsGranted("SECTION:order:task:u")
  90.      */
  91.     public function upsert(
  92.         ?ProjectOrderTaskFulfillment $execution,
  93.         Request $request,
  94.         TranslatorInterface $translator,
  95.         TaskExecutionService $service,
  96.         OrderTaskFulfillmentSerialize $serialize
  97.     ): Response {
  98.         if (!$execution) {
  99.             return $this->json([
  100.                 'message'  => $translator->trans('Task execution not found'),
  101.                 'severity' => SeverityInterface::ERROR,
  102.             ], Response::HTTP_NOT_FOUND);
  103.         }
  105.         // work_documents dosyalari icin AbstractControllerService protokolu ($this->files).
  106.         $service->setFiles($request->files);
  108.         try {
  109.             $execution = $service->upsert($execution, $request->request);
  110.         } catch (\DomainException $e) {
  111.             return $this->json([
  112.                 'message'  => $translator->trans($e->getMessage()),
  113.                 'severity' => SeverityInterface::ERROR,
  114.             ], Response::HTTP_CONFLICT);
  115.         }
  117.         return $this->json([
  118.             'message'   => $translator->trans('Task execution updated successfully'),
  119.             'severity'  => SeverityInterface::SUCCESS,
  120.             'taskExecution' => $serialize->setEntity($execution)->serializeFull(),
  121.         ], Response::HTTP_OK);
  122.     }
  124.     /**
  125.      * K7 — yayin SONRASI dokuman ekle/sil. task/order owner published bir execution'a bile
  126.      * is-plani dokumani ekleyebilir (K5 istisnasi — dokuman ilerleme degil). Yalniz work_documents
  127.      * islenir. Ownership ihlali → 409 (403 KULLANMA, FE reload eder).
  128.      *
  129.      * @Route("/documents/{id}", name="api_v3_task_execution_documents", methods={"POST"})
  130.      * @ParamConverter("execution", options={"mapping": {"id": "id"}})
  131.      * @IsGranted("SECTION:order:task:u")
  132.      */
  133.     public function uploadDocuments(
  134.         ?ProjectOrderTaskFulfillment $execution,
  135.         Request $request,
  136.         TranslatorInterface $translator,
  137.         TaskExecutionService $service,
  138.         OrderTaskFulfillmentSerialize $serialize
  139.     ): Response {
  140.         if (!$execution) {
  141.             return $this->json([
  142.                 'message'  => $translator->trans('Task execution not found'),
  143.                 'severity' => SeverityInterface::ERROR,
  144.             ], Response::HTTP_NOT_FOUND);
  145.         }
  147.         $service->setFiles($request->files);
  149.         try {
  150.             $execution = $service->syncExecutionDocuments($execution, $request->request);
  151.         } catch (\DomainException $e) {
  152.             return $this->json([
  153.                 'message'  => $translator->trans($e->getMessage()),
  154.                 'severity' => SeverityInterface::ERROR,
  155.             ], Response::HTTP_CONFLICT);
  156.         }
  158.         return $this->json([
  159.             'message'       => $translator->trans('Documents updated successfully'),
  160.             'severity'      => SeverityInterface::SUCCESS,
  161.             // K7 dokuman degisimi published/readOnly ekranda olur — progress ring + task_jobs
  162.             // aci kalmasin diye open ile ayni serializeFullPreview kullanilir.
  163.             'taskExecution' => $serialize->setEntity($execution)->serializeFullPreview(),
  164.         ], Response::HTTP_OK);
  165.     }
  167.     /**
  168.      * K5 — yayınla. K3/K4 zorunlu alanları eksikse 422, zaten yayınlıysa 409.
  169.      *
  170.      * @Route("/publish/{id}", name="api_v3_task_execution_publish", methods={"POST"})
  171.      * @ParamConverter("execution", options={"mapping": {"id": "id"}})
  172.      * @IsGranted("SECTION:order:task:u")
  173.      */
  174.     public function publish(
  175.         ?ProjectOrderTaskFulfillment $execution,
  176.         TranslatorInterface $translator,
  177.         TaskExecutionService $service,
  178.         OrderTaskFulfillmentSerialize $serialize
  179.     ): Response {
  180.         if (!$execution) {
  181.             return $this->json([
  182.                 'message'  => $translator->trans('Task execution not found'),
  183.                 'severity' => SeverityInterface::ERROR,
  184.             ], Response::HTTP_NOT_FOUND);
  185.         }
  187.         try {
  188.             $execution = $service->publish($execution);
  189.         } catch (\DomainException $e) {
  190.             $alreadyPublished = strpos($e->getMessage(), 'already published') !== false;
  192.             return $this->json([
  193.                 'message'  => $translator->trans($e->getMessage()),
  194.                 'severity' => SeverityInterface::ERROR,
  195.             ], $alreadyPublished ? Response::HTTP_CONFLICT : Response::HTTP_UNPROCESSABLE_ENTITY);
  196.         }
  198.         return $this->json([
  199.             'message'   => $translator->trans('Task execution published successfully'),
  200.             'severity'  => SeverityInterface::SUCCESS,
  201.             'taskExecution' => $serialize->setEntity($execution)->serializeFull(),
  202.         ], Response::HTTP_OK);
  203.     }
  205.     /**
  206.      * K9 — GERİ ÇEK (rollback) + TAM SIFIRLA. PENDING/DECLINED (yayınlanmış ama KABUL EDİLMEMİŞ)
  207.      * execution'ı kayıt + fiziksel dosyalarıyla TAMAMEN siler → "hiç execution olmamış" hale
  208.      * (taslağa döndürme DEĞİL). ACCEPTED ise 409. FE bu ucu bir confirmation dialog'unun arkasına koyar.
  209.      *
  210.      * @Route("/rollback/{id}", name="api_v3_task_execution_rollback", methods={"POST"})
  211.      * @ParamConverter("execution", options={"mapping": {"id": "id"}})
  212.      * @IsGranted("SECTION:order:task:u")
  213.      */
  214.     public function rollback(
  215.         ?ProjectOrderTaskFulfillment $execution,
  216.         TranslatorInterface $translator,
  217.         TaskExecutionService $service
  218.     ): Response {
  219.         if (!$execution) {
  220.             return $this->json([
  221.                 'message'  => $translator->trans('Task execution not found'),
  222.                 'severity' => SeverityInterface::ERROR,
  223.             ], Response::HTTP_NOT_FOUND);
  224.         }
  226.         try {
  227.             $service->rollbackAndReset($execution);
  228.         } catch (\DomainException $e) {
  229.             return $this->json([
  230.                 'message'  => $translator->trans($e->getMessage()),
  231.                 'severity' => SeverityInterface::ERROR,
  232.             ], Response::HTTP_CONFLICT);
  233.         }
  235.         return $this->json([
  236.             'message'  => $translator->trans('Task execution rolled back'),
  237.             'severity' => SeverityInterface::SUCCESS,
  238.         ], Response::HTTP_OK);
  239.     }
  241.     /**
  242.      * Chat-K1/K2 (karar 59) — OWNER mesaj LİSTESİ + iki taraflı unread sayaç. Mesaj İÇERİĞİ NS'ten
  243.      * GEÇMEZ (Chat-K1) — bu uç kimlik-doğrulamalı (session) tek kaynaktır. `serializeFullWithJobs`/
  244.      * `serializeFullPreview` payload'ına DOKUNULMADI, mesajlar execution objesine ENJEKTE EDİLMEZ.
  245.      *
  246.      * @Route("/message/list/{execution_id}", name="api_v3_task_execution_message_list", methods={"POST"})
  247.      * @ParamConverter("execution", options={"mapping": {"execution_id": "id"}})
  248.      * @IsGranted("SECTION:order:task:r")
  249.      */
  250.     public function messageList(
  251.         ?ProjectOrderTaskFulfillment $execution,
  252.         TranslatorInterface $translator,
  253.         TaskExecutionService $service
  254.     ): Response {
  255.         if (!$execution) {
  256.             return $this->json([
  257.                 'message'  => $translator->trans('Task execution not found'),
  258.                 'severity' => SeverityInterface::ERROR,
  259.             ], Response::HTTP_NOT_FOUND);
  260.         }
  262.         try {
  263.             $payload = $service->listMessages($execution);
  264.         } catch (\DomainException $e) {
  265.             return $this->json([
  266.                 'message'  => $translator->trans($e->getMessage()),
  267.                 'severity' => SeverityInterface::ERROR,
  268.             ], Response::HTTP_CONFLICT);
  269.         }
  271.         return $this->json($payload, Response::HTTP_OK);
  272.     }
  274.     /**
  275.      * Chat-K1 — OWNER mesaj GÖNDER. Body: `message` (ZORUNLU, boş → 422). sender_side=owner,
  276.      * sender_name = currentActor() (WorkerActivities→Worker) full_name. NS EMIT BURADA YAPILMAZ —
  277.      * FE emit eder (Chat-K1: içerik NS'ten geçmez, yalnız sinyal).
  278.      *
  279.      * @Route("/message/send/{execution_id}", name="api_v3_task_execution_message_send", methods={"POST"})
  280.      * @ParamConverter("execution", options={"mapping": {"execution_id": "id"}})
  281.      * @IsGranted("SECTION:order:task:u")
  282.      */
  283.     public function messageSend(
  284.         ?ProjectOrderTaskFulfillment $execution,
  285.         Request $request,
  286.         TranslatorInterface $translator,
  287.         TaskExecutionService $service,
  288.         ProjectOrderTaskFulfillmentMessageSerialize $messageSerialize
  289.     ): Response {
  290.         if (!$execution) {
  291.             return $this->json([
  292.                 'message'  => $translator->trans('Task execution not found'),
  293.                 'severity' => SeverityInterface::ERROR,
  294.             ], Response::HTTP_NOT_FOUND);
  295.         }
  297.         try {
  298.             $message = $service->sendMessage($execution, $request->request->get('message'));
  299.         } catch (\DomainException $e) {
  300.             return $this->json([
  301.                 'message'  => $translator->trans($e->getMessage()),
  302.                 'severity' => SeverityInterface::ERROR,
  303.             ], Response::HTTP_UNPROCESSABLE_ENTITY);
  304.         }
  306.         return $this->json([
  307.             'message'      => $translator->trans('Message sent'),
  308.             'severity'     => SeverityInterface::SUCCESS,
  309.             'chat_message' => $messageSerialize->setEntity($message)->serializeCore(),
  310.         ], Response::HTTP_OK);
  311.     }
  313.     /**
  314.      * Chat-K2 — OWNER "okundu" işaretle. owner_last_read_at = now.
  315.      *
  316.      * @Route("/message/read/{execution_id}", name="api_v3_task_execution_message_read", methods={"POST"})
  317.      * @ParamConverter("execution", options={"mapping": {"execution_id": "id"}})
  318.      * @IsGranted("SECTION:order:task:u")
  319.      */
  320.     public function messageRead(
  321.         ?ProjectOrderTaskFulfillment $execution,
  322.         TranslatorInterface $translator,
  323.         TaskExecutionService $service
  324.     ): Response {
  325.         if (!$execution) {
  326.             return $this->json([
  327.                 'message'  => $translator->trans('Task execution not found'),
  328.                 'severity' => SeverityInterface::ERROR,
  329.             ], Response::HTTP_NOT_FOUND);
  330.         }
  332.         try {
  333.             $service->markMessagesRead($execution);
  334.         } catch (\DomainException $e) {
  335.             return $this->json([
  336.                 'message'  => $translator->trans($e->getMessage()),
  337.                 'severity' => SeverityInterface::ERROR,
  338.             ], Response::HTTP_CONFLICT);
  339.         }
  341.         return $this->json([
  342.             'message'  => $translator->trans('Messages marked as read'),
  343.             'severity' => SeverityInterface::SUCCESS,
  344.         ], Response::HTTP_OK);
  345.     }
  347.     /**
  348.      * App-level GLOBAL mesaj bildirimi — oturumdaki order lead'in TÜM YAYINLANMIŞ execution'larını
  349.      * NS oda anahtarlarıyla (`scope` + `contact_person_id` → `te:<scope>:<contactPersonId>`, T58)
  350.      * döner. FE bu listeyle TÜM odalara abone olur, `task_execution_message` sinyalinde snackbar
  351.      * gösterir ("{task_title} için yeni mesaj"). Owner filtresi Service'te (assertOwnership'in LİSTE
  352.      * hali) — FE'de gizlemek YETMEZ.
  353.      *
  354.      * @Route("/owner/executions", name="api_v3_task_execution_owner_executions", methods={"POST"})
  355.      * @IsGranted("SECTION:order:task:r")
  356.      */
  357.     public function ownerExecutions(TaskExecutionService $service): Response
  358.     {
  359.         return $this->json($service->ownerExecutionRooms(), Response::HTTP_OK);
  360.     }
  362.     /**
  363.      * "Liste Click Preview" — ERP owner iş planı dokümanını ÖNİZLER (inline stream). Session-auth;
  364.      * ownership Service::resolveOwnedWorkDocument'te (order lead) — başka order'ın dokümanı sızmaz.
  365.      * Okuma yetkisi (task:r) yeter; salt görüntüleme.
  366.      *
  367.      * @Route("/work-document/{id}", name="api_v3_task_execution_work_document", methods={"GET"})
  368.      * @IsGranted("SECTION:order:task:r")
  369.      */
  370.     public function workDocument(
  371.         int $id,
  372.         TaskExecutionService $service,
  373.         TranslatorInterface $translator
  374.     ): Response {
  375.         try {
  376.             $resolved = $service->resolveOwnedWorkDocument($id);
  377.         } catch (\DomainException $e) {
  378.             return $this->json([
  379.                 'message'  => $translator->trans($e->getMessage()),
  380.                 'severity' => SeverityInterface::ERROR,
  381.             ], Response::HTTP_UNPROCESSABLE_ENTITY);
  382.         }
  384.         $response = new BinaryFileResponse($resolved['path']);
  385.         $response->headers->set('Content-Type', $resolved['mime']);
  386.         $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_INLINE, $resolved['name']);
  388.         return $response;
  389.     }
  391.     /**
  392.      * Wizard'in ihtiyaç duyduğu 3 koleksiyon ayrı ayrı (streamed). `open` bunları zaten
  393.      * bundle ettiği için FE bu turda bu ucu ÇAĞIRMIYOR — sözleşmede kayıtlı dursun diye var
  394.      * (ör. dialog dışı bir ekran ileride ihtiyaç duyarsa).
  395.      *
  396.      * @Route("/needed-collections", name="api_v3_task_execution_needed_collections")
  397.      * @IsGranted("SECTION:order:task:u")
  398.      */
  399.     public function neededCollections(
  400.         TaskExecutionService $service,
  401.         TranslatorInterface $translator,
  402.         BranchSerialize $branchSerialize,
  403.         VendorSerialize $vendorSerialize,
  404.         ReferenceSerialize $referenceSerialize
  405.     ): StreamedResponse {
  406.         $streamingService = new StreamingService([
  407.             'localText' => ['completed' => $translator->trans('Completed')],
  408.         ]);
  410.         $streamingService->appendStream(
  411.             'branches',
  412.             'Branches loaded',
  413.             function () use ($service, $branchSerialize) {
  414.                 return $this->serializeBranches($service, $branchSerialize);
  415.             }
  416.         );
  418.         $streamingService->appendStream(
  419.             'vendors',
  420.             'Active vendors loaded',
  421.             function () use ($service, $vendorSerialize) {
  422.                 return $vendorSerialize->setEntity($service->fetchActiveVendors())->serializeFull();
  423.             }
  424.         );
  426.         $streamingService->appendStream(
  427.             'reasons',
  428.             'Reasons loaded',
  429.             function () use ($service, $referenceSerialize) {
  430.                 return $referenceSerialize->setEntity($service->fetchAllReasons())->serializeCustomCore(ReferenceEnum::TASK_FULFILLMENT_REASON);
  431.             }
  432.         );
  434.         // Layout B "canlı brief" eklentisi — kişi başına AKTİF execution sayısı ("N aktif iş").
  435.         // {branch_contact:{[workerActivityId]:n}, vendor_contact:{[vendorContactPersonId]:n}}
  436.         $streamingService->appendStream(
  437.             'active_task_counts',
  438.             'Active task counts loaded',
  439.             function () use ($service) {
  440.                 return $service->fetchActiveTaskCounts();
  441.             }
  442.         );
  444.         return $streamingService->flush();
  445.     }
  447.     private function serializeBranches(TaskExecutionService $service, BranchSerialize $branchSerialize): ?array
  448.     {
  449.         return $branchSerialize->setEntity($service->fetchAllBranches())->setGroups([
  450.             'branch@core',
  451.             'branch@responsible',
  452.             'worker_activity@core',
  453.             'worker_activity@worker',
  454.             'worker@core',
  455.         ])->render();
  456.     }
  457. }