src/Controller/Api/Service/ProjectOrderService.php line 135

Open in your IDE?
  1. <?php
  3. namespace App\Controller\Api\Service;
  5. use App\Entity\BranchDepartments;
  6. use App\Entity\Branches;
  7. use App\Entity\InvoiceType;
  8. use App\Entity\ProjectOrderBillings;
  9. use App\Entity\ProjectOrderExpensePositions;
  10. use App\Entity\ProjectOrderMetrics;
  11. use App\Entity\ProjectOrders;
  12. use App\Entity\ProjectOrderTaskJobs;
  13. use App\Entity\ProjectOrderTasks;
  14. use App\Entity\ProjectOrderUndertakings;
  15. use App\Entity\ProjectOwner;
  16. use App\Entity\ProjectOwnerContactPersons;
  17. use App\Entity\Projects;
  18. use App\Entity\WorkerActivities;
  19. use App\Entity\WorkerTimesheet;
  20. use App\Repository\ProjectOrdersRepository;
  21. use App\Service\AisDate;
  22. use App\Service\Calculators\ProjectOrderCalculator;
  23. use App\Service\OrderLaborCostPdfService;
  24. use App\Service\OrderDependency\OrderTimesheetMutator;
  25. use App\Context\Metrics\MetricContextFactory;
  26. use App\Service\FileNumberInterface;
  27. use App\Service\SerializeService\BranchSerialize;
  28. use App\Service\SerializeService\ProjectSerialize;
  29. use App\Service\SerializeService\ReferenceSerialize;
  30. use App\Service\ValidatorService\EntityHydratorValidator;
  31. use Doctrine\Common\Collections\ArrayCollection;
  32. use Doctrine\Common\Collections\Criteria;
  33. use Doctrine\ORM\EntityManagerInterface;
  34. use phpDocumentor\Reflection\Types\This;
  35. use PHPUnit\Util\Exception;
  36. use Symfony\Component\HttpFoundation\InputBag;
  37. use Symfony\Component\HttpFoundation\StreamedResponse;
  38. use Symfony\Component\Security\Core\Security;
  39. use Symfony\Component\Security\Core\User\UserInterface;
  40. use Symfony\Contracts\Translation\TranslatorInterface;
  41. use function Symfony\Component\DependencyInjection\Loader\Configurator\param;
  43. # use App\Service\Calculators\CalculatorService;
  45. class ProjectOrderService extends AbstractControllerService
  46. {
  47.     private ?Projects $project = null;
  49.     private BranchSerialize $branchSerialize;
  51.     private ?UserInterface $user;
  53.     private EntityHydratorValidator $entityHydratorValidator;
  54.     private ProjectOrderCalculator $projectOrderCalculator;
  55.     private FileNumberInterface $fileNumber;
  57.     private MetricContextFactory $metricService;
  58.     private OrderLaborCostPdfService $laborCostPdfService;
  59.     private OrderTimesheetMutator $timesheetMutator;
  60.     private string $orderForceDeletePassword;
  61.     # private CalculatorService $calculatorService;
  63.     public function __construct(
  64.         EntityManagerInterface $manager,
  65.         AisDate $aisDate,
  66.         TranslatorInterface $translator,
  67.         ProjectSerialize $projectSerialize,
  68.         ReferenceSerialize $referenceSerialize,
  69.         BranchSerialize $branchSerialize,
  70.         Security $user,
  71.         EntityHydratorValidator $entityHydratorValidator,
  72.         ProjectOrderCalculator $projectOrderCalculator,
  73.         FileNumberInterface $fileNumber,
  74.         MetricContextFactory $metricService,
  75.         Security $security,
  76.         OrderLaborCostPdfService $laborCostPdfService,
  77.         OrderTimesheetMutator $timesheetMutator,
  78.         string $orderForceDeletePassword
  79.     ) {
  80.         parent::__construct($manager, $aisDate, $translator, $referenceSerialize, $security);
  81.         $this->branchSerialize = $branchSerialize;
  82.         $this->user = $user->getUser();
  83.         $this->entityHydratorValidator = $entityHydratorValidator;
  84.         $this->projectOrderCalculator = $projectOrderCalculator;
  85.         $this->fileNumber = $fileNumber;
  86.         $this->metricService = $metricService;
  87.         $this->laborCostPdfService = $laborCostPdfService;
  88.         $this->timesheetMutator = $timesheetMutator;
  89.         $this->orderForceDeletePassword = $orderForceDeletePassword;
  90.         # $this->calculatorService = $calculatorService;
  91.     }
  93.     public function setProject(Projects $project): self {
  94.         $this->project = $project;
  95.         return $this;
  96.     }
  98.     /**
  99.      * @throws \Exception
  100.      */
  101.     public function fetchAll(): array {
  102.         if(!is_null($this->project)){
  103.             // return $this->project->getProjectOrders()->toArray();
  104.             return $this->findByProgress();
  105.         }
  106.         // return $this->manager->getRepository(ProjectOrders::class)->findAll();
  107.         /**@var $repo ProjectOrdersRepository*/
  108.         $repo = $this->manager->getRepository(ProjectOrders::class);
  109.         return $repo->fetchOrders($this->security->getUser());
  110.     }
  112.     public function findAllNotPaymentStatus(): array {
  113.         /**@var $repo ProjectOrdersRepository*/
  114.         $repo = $this->manager->getRepository(ProjectOrders::class);
  115.         return $repo->findAllNotPaymentStatus();
  116.     }
  119.     /**
  120.      * fatiralandirma hesaplanmis olanlar
  121.     */
  122.     public function fetchCalculated(?ProjectOwner $customer): array {
  123.         /**@var $repo ProjectOrdersRepository*/
  124.         $repo = $this->manager->getRepository(ProjectOrders::class);
  125.         if($customer){
  126.             return $repo->findWithCalculated($customer);
  127.         }
  128.         return $repo->findAllWithCalculated();
  129.     }
  131.     /**
  132.      * @throws \Exception
  133.      */
  134.     // public function findByProgress(string $type, int $from = 0, int $to = 100): array {
  135.     public function findByProgress(): array {
  137.         $filterModel = $this->entityHydratorValidator->createInputBag($this->params->get('progressFilterModel'));
  138.         $from = !empty($filterModel->get('range')->from) ? $filterModel->get('range')->from : null;
  139.         $to = !empty($filterModel->get('range')->to) ? $filterModel->get('range')->to : null;
  140.         // Symbolik
  141.         // $role = $filterModel->get('role');
  143.         /**@var $projectOrdersRepository ProjectOrdersRepository*/
  144.         $projectOrdersRepository = $this->entityManager->getRepository(ProjectOrders::class);
  146.         return $projectOrdersRepository->findOrdersByProgressStatusV3( $this->security->getUser(), $this->project, $from, $to );
  147.     }
  149.     /**
  150.      * ProjectOrder işlemini gerçekleştirir.
  151.      *
  152.      * Asıl entity (ProjectOrder) service içinde setEntity() ile set edilir.
  153.      * Yardımcı entity (Project) parametre olarak verilir.
  154.      *
  155.      * @param Projects $project Yardımcı entity.
  156.      * @return ProjectOrders|null İşlem sonucu dönen ProjectOrder entity.
  157.      * @throws \Exception
  158.      */
  159.     public function upsert(Projects $project): ?ProjectOrders {
  161.         if($this->entity && !$this->entity instanceof ProjectOrders ){
  162.             throw new \LogicException('Entity should be ProjectOrders instance');
  163.         }
  165.         if(!$this->entity){
  167.             $this->entity = new ProjectOrders();
  168.             $this->entity->setProject($project);
  170.             $uniqueFileNumber = $this->fileNumber->createUniqueFileNumber(ProjectOrders::class, [
  171.                 "criteria" => ["project" => $project],
  172.                 "prefix" => [$project->getProjectId()],
  173.                 "separator" => "-"
  174.             ]);
  175.             $this->entity->setOrderNr($uniqueFileNumber);
  176.             $this->entity->setCreatedAt(new \DateTimeImmutable('now'));
  178.             // TODO Set Created At ekle
  179.         }
  181.         # $calculatorService = $this->calculatorService->orderCalculator($this->entity);
  183.         #dd($this->params);
  186.         // README Params will replace value automatically from number (id) to Entity Return either Input Bag or $params already is referenced
  188.         // Invoice Type has been replaced
  189.         $this->resolveRelation('invoice_type', $this->params, InvoiceType::class);
  191.         // order_primary_lead
  192.         $this->resolveRelation('order_primary_lead', $this->params, WorkerActivities::class);
  194.         // contact_person
  195.         $this->resolveRelation('contact_person', $this->params, ProjectOwnerContactPersons::class);
  197.         // order_branch
  198.         $this->resolveRelation('order_branch', $this->params, Branches::class);
  200.         // branch_department
  201.         $this->resolveRelation('branch_department', $this->params, BranchDepartments::class);
  203.         #dd($this->params);
  206.         // Validation project_owner_order_nr & project
  207.         /**
  208.          * Project (entity ) validation icin gerekli ve olmadigi icin
  209.          * InputBag e bunu ert ediyoruz
  210.          * $project aslinda bir entity array degil!
  211.         */
  212.         $this->params->set('project', $project );
  214.         if($this->params->get('project_owner_order_nr')){
  216.             $validation = $this->entityHydratorValidator
  217.                 ->setEntity($this->entity)
  218.                 ->setParams($this->params)
  219.                 ->validate([
  220.                     'project_owner_order_nr', 'project'
  221.                 ], 1,
  222.                 [
  223.                     "project" => "project_id"
  224.                 ]);
  226.             if(!is_null($validation)){
  227.                 $this->setCreateException(HttpStatusInterface::SERVICE_UNAVAILABLE, $validation);
  228.                 return null;
  229.             }
  230.         }
  232.         #dd($this->params->keys());
  233.         // Project given already by new Order !!!⚠️
  234.         $excludedFields = [
  235.             'order_alternate_leads',
  236.             'project_order_tasks',
  237.             'project',
  238.             'takeover',
  239.             'order_billings',
  240.             'contact_persons',
  241.             // works_plan: salt-okunur ilişki (FE'ye @ref ile gider); BindService yönetir,
  242.             // generic hydrator array/string ile setWorksPlan edemez → hidrasyona girmez.
  243.             'works_plan'
  244.         ];
  246.         $nestedFields = array_diff($this->params->keys(), $excludedFields);
  248.         $this->entityHydratorValidator
  249.             ->setParams($this->params)
  250.             ->setEntity($this->entity)
  251.             ->populateEntityFields($nestedFields);
  254.         // Alternate Leads
  255.         $this->syncOrderAlternateLeads();
  257.         // Tamamlama kuralı ihlali (today < start_at) → işlemi reddet, hiçbir şey flush etme.
  258.         try {
  259.             $this->syncOrderTasks($this->entity, $this->params);
  260.         } catch (\DomainException $domainException) {
  261.             $this->setCreateException(HttpStatusInterface::BAD_REQUEST, $domainException->getMessage());
  262.             return null;
  263.         }
  266.         // This update must after Tasks Update!!!
  267.         // While Progress with Task related!
  268.         $this->metricService->orderMetrics($this->entity)->syncProgressMetrics();
  271.         try{
  272.             $this->manager->persist($this->entity);
  273.             $this->manager->flush();
  274.             $this->manager->refresh($this->entity);
  275.         } catch (\Exception $exception){
  276.             $this->setCreateException( HttpStatusInterface::BAD_REQUEST, $exception->getMessage());
  277.         }
  278.         return $this->entity;
  279.     }
  282.     /**
  283.      * TODO Use this Never (bu kisim Mtric service üzerinden OrderCalcuator icinde yazildi!)
  284.      * @deprecated
  285.      * @see use OrderCalculator/progress instead
  286.     */
  287.     public function syncOrderProgress_deprecated_here(ProjectOrders $projectOrder): float
  288.     {
  289.         $totalProgress = 0.0;
  291.         foreach ($projectOrder->getProjectOrderTasks() ?? [] as $task) {
  293.             // Tamamlanmış job'ların ağırlık toplamı
  294.             $completedFeedbacks = 0.0;
  296.             foreach ($task->getTaskJobs() ?? [] as $job) {
  297.                 if (
  298.                     !empty($job->getStartAt()) &&
  299.                     !empty($job->getEndAt())
  300.                 ) {
  301.                     $completedFeedbacks += $job->getJobWeight() ?? 0;
  302.                 }
  303.             }
  305.             $taskWeight = $task->getProgressWeight() ?? 0;
  307.             // Task'in projeye gerçek katkısı
  308.             $taskContribution = ($completedFeedbacks * $taskWeight) / 100;
  310.             // JS Math.round(x * 100) / 100 eşdeğeri
  311.             $totalProgress += round($taskContribution, 2);
  312.         }
  314.         // Son rounding
  315.         $nextProgress = round($totalProgress, 2);
  317.         return $nextProgress; // örn: 67.79
  318.     }
  320.     // private function syncOrderAlternateLeads(ProjectOrders $projectOrder, $params): void
  322.     /**
  323.      * @throws \Exception
  324.      */
  325.     # private function syncOrderAlternateLeads(ProjectOrders $projectOrder, $params): void
  326.     private function syncOrderAlternateLeads(): void
  327.     {
  329.         // Check The Entity is Expected ad Assign
  330.         $this->entity = $this->entityHydratorValidator->assertHydratedEntity(ProjectOrders::class, $this->entity);
  332.         // 🔹 1. Get Old IDs
  333.         $oldAlternateIds = $this->entity->getOrderAlternateLeads()->map(fn($p) => $p->getId())->toArray();
  335.         // 🔹 2. Get new IDs from request And Convert to Input Bag
  336.         $newAlternateIds    = $this->entityHydratorValidator->createInputBag($this->params->get('order_alternate_leads'));
  337.         // Take only Id's
  338.         $newAlternateIds    = !is_null($newAlternateIds) ? array_map(fn($item) => $item->id, $newAlternateIds->all()) : [];
  339.         // Define Differer
  340.         $differ             = $this->syncDifferer($newAlternateIds, $oldAlternateIds);
  342.         // 🔹 Remove branches that are no longer assigned
  343.         foreach ($differ['toRemove'] as $id) {
  344.             $found = $this->entity->getOrderAlternateLeads()->filter(fn($p) => $p->getId() === $id)->first();
  345.             if ($found) {
  346.                 $this->entity->removeOrderAlternateLead($found);
  347.             }
  348.         }
  350.         // 🔹 Add new branches
  351.         foreach ($differ['toAdd'] as $id) {
  352.             $found = $this->entityManager->getRepository(WorkerActivities::class)->find($id);
  353.             if ($found) {
  354.                 $this->entity->addOrderAlternateLead($found);
  355.             }
  356.         }
  357.     }
  359.     /**
  360.      * @throws \Exception
  361.      */
  362.     private function syncOrderTasks(ProjectOrders $projectOrder, $params){
  365.         $this->entity = $this->entityHydratorValidator->assertHydratedEntity(ProjectOrders::class, $this->entity);
  367.         # $tasks = $params->get('project_order_tasks');
  370.         # if(!$tasks && !$projectOrder->getId()) return;
  372.         // This JSON String converted to Input Bag (Each item is converted to stdClass)
  373.         $tasksBags = $this->entityHydratorValidator->createInputBag($params->get('project_order_tasks'));
  374.         /**
  375.          * Clone lazim
  376.          * Foreach içi: her task kendi createInputBag ile InputBag’e dönüşüyor
  377.          * Burada her task elemanı (stdClass) InputBag’e çevriliyor
  378.          * InputBag constructor’ı şöyle davranır:
  379.          * function __construct($data) {
  380.          * $this->parameters = (array) $data; // 👉 stdClass → array cast 👈
  381.          * }
  382.          * Oyuzden clone lamak lazim
  383.         */
  384.         if(is_null($tasksBags)) return;
  385.         $originalBags = clone $tasksBags;
  387.         foreach ($tasksBags as $taskBag) {
  389.             // Each of task Convert to Input Bag fot Hydrator
  390.             // Task each props prepared for Hydrator
  391.             $taskBag = $this->entityHydratorValidator->createInputBag($taskBag);
  392.             // No validation need -> direct to populate
  393.             // 1️⃣ Task Entity
  394.             if($taskBag->get('isNew')){
  395.                 $taskEntity = new ProjectOrderTasks();
  396.             } else {
  397.                 /**
  398.                  * Doctrine Collection için PHP 7.4’te filter dışında gerçek bir find operatörü yok.
  399.                  * Criteria kullanicaz
  400.                  * filter gibi tüm koleksiyonu dolaşmaz (özellikle PersistentCollection için)
  401.                  * Doctrine tarafından desteklenen “find” oldugunu ögrendim
  402.                  * ❌ 👉$projectOrder->getProjectOrderTasks()->filter( fn(ProjectOrderTasks $taskEntity) => $taskEntity->getId() === $task->id)->first();
  403.                  */
  404.                 $criteria = Criteria::create()
  405.                     ->where(Criteria::expr()->eq('id', $taskBag->get('id')))
  406.                     ->setMaxResults(1);
  407.                 $taskEntity = $projectOrder->getProjectOrderTasks()->matching($criteria)->first();
  408.             }
  410.             // Resolve pure data responsible_person to Entity !!!
  411.             $this->resolveRelation('responsible_person', $taskBag, WorkerActivities::class);
  413.             /**
  414.              * ❌❌⚠️⚠️⚠️ TASK FULFILLMENT PROCESSING FROM OUTSIDE EXCLUDE THIS
  415.              * Resolve pure data task_fulfillment data to Entity !!!
  416.              * $this->resolveRelation('task_fulfillment', $inputBag, ProjectOrderTaskFulfillment::class);
  417.              * task_fulfillment Processing extra
  418.             */
  419.             $excludedFields = ["task_jobs", "maxValue", 'task_fulfillment', '__reorder__', 'execution_scope', 'task_job_completed_weight', 'real_days', 'details'];
  420.             $nestedFields = array_diff($taskBag->keys(), $excludedFields);
  422.             $this->entityHydratorValidator
  423.                 ->setEntity($taskEntity)
  424.                 ->setParams($taskBag)
  425.                 ->populateEntityFields($nestedFields);
  427.             // Sync Task Jobs (Convert string to Object via createInputBag)
  428.             $taskJobs = $this->entityHydratorValidator->createInputBag($taskBag->get('task_jobs'));
  429.             $taskEntity = $this->syncProjectOrderTaskJobs($taskEntity, $taskJobs);
  430.             if($taskEntity->getId() === 39){
  431.                 #$this->manager->refresh($taskEntity);
  432.                 #dd($taskEntity);
  433.             }
  435.             $projectOrder->addProjectOrderTask($taskEntity);
  437.         }
  439.         // REMOVE PROCESS
  440.         $oldTasks       = $projectOrder->getProjectOrderTasks()->map( fn (ProjectOrderTasks $task ) => $task->getId() )->toArray();
  441.         $actuallyTasks  = array_filter($originalBags->all(), fn($item) => gettype($item) === "array" ? !array_key_exists('isNew', $item) : $item);
  442.         $actuallyTasks  = array_map(fn($item) => $item->id, $actuallyTasks);
  443.         $differer       = $this->syncDifferer($actuallyTasks ?? [], $oldTasks );
  445.         // To Remove
  446.         foreach ($differer["toRemove"] as $id) {
  447.             $projectOrderTask = $this->manager->getRepository(ProjectOrderTasks::class)->find($id);
  448.             $projectOrder->removeProjectOrderTask($projectOrderTask);
  449.         }
  451.         // Update only nested metrics
  452.         $this->metricService->orderMetrics($projectOrder)->syncProgressMetrics();
  454.         $this->metricService->projectMetrics($projectOrder->getProject())->syncProgressMetrics();
  457.     }
  459.     /**
  460.      * Access from anywhere
  461.      * @param ProjectOrderTasks $taskEntity ;
  462.      * @param array|InputBag $task_jobs
  463.      * @throws \Exception
  464.      */
  465.     /**
  466.      * Tek job için tamamlama uygunluğu (live kontrol). Kalıcı (planlı) start_at'e göre
  467.      * karar verir → checkbox/Zeitachse lokal değişiklikle baypas edilemez; sunucu kalıcı
  468.      * durumu kontrol eder. start_at FE'de min-date (Zeitachse) için döner.
  469.      *
  470.      * @return array
  471.      */
  472.     public function checkJobCompletion(ProjectOrderTaskJobs $job): array
  473.     {
  474.         $block = $job->getCompletionBlock();
  475.         // Plan-bağlıda start otoritesi plan (getCompletionBlock ile tutarlı) → mesaj/tarih de plandan.
  476.         $planJob = $job->getSourcePlanJob();
  477.         $start = $planJob !== null ? $planJob->getStartAt() : $job->getStartAt();
  478.         $message = '';
  479.         if ($block !== null) {
  480.             $title = $job->getJobDescription() ?: $this->translator->trans('Job');
  481.             $message = $this->translator->trans('Job "%title%" has not started yet (starts %date%) and cannot be completed.', [
  482.                 '%title%' => $title,
  483.                 '%date%' => $start ? $start->format('d.m.Y') : ''
  484.             ]);
  485.         }
  487.         return [
  488.             'allowed' => $block === null,
  489.             'start_at' => $start ? $start->format('Y-m-d') : null,
  490.             'message' => $message
  491.         ];
  492.     }
  494.     public function syncProjectOrderTaskJobs (ProjectOrderTasks $taskEntity,InputBag $task_jobs): ProjectOrderTasks {
  496.         $jobsBags = $task_jobs;
  498.         $toAddEntities = [];
  500.         foreach ($jobsBags as  $jobBag) {
  502.             $jobBag = $this->entityHydratorValidator->createInputBag($jobBag);
  504.             // 1️⃣ Job Entity
  505.             if($jobBag->get('isNew')){
  506.                 $jobEntity = new ProjectOrderTaskJobs();
  507.             } else {
  508.                 /**
  509.                  * Doctrine Collection için PHP 7.4’te filter dışında gerçek bir find operatörü yok.
  510.                  * Criteria kullanicaz
  511.                  * filter gibi tüm koleksiyonu dolaşmaz (özellikle PersistentCollection için)
  512.                  * Doctrine tarafından desteklenen “find” oldugunu ögrendim
  513.                  * ❌ 👉$projectOrder->getProjectOrderTasks()->filter( fn(ProjectOrderTasks $taskEntity) => $taskEntity->getId() === $task->id)->first();
  514.                  */
  515.                 $criteria = Criteria::create()
  516.                     ->where(Criteria::expr()->eq('id', $jobBag->get('id')))
  517.                     ->setMaxResults(1);
  518.                 $jobEntity = $taskEntity->getTaskJobs()->matching($criteria)->first();
  519.             }
  521.             // Plan-bağlı job: SCHEDULE otoritesi PLAN. FE payload stale olabilir (plan başka bir
  522.             // yerde değiştirilmiş, order reload edilmemiş) → start_at/duration order payload'undan
  523.             // DEĞİL, source_plan_job'tan (canlı DB) alınır. Aksi halde stale start_at, tamamlama
  524.             // anında haksız "başlamadı" bloğu üretir (kullanıcı bug'ı: plan 23'e çekildi ama order
  525.             // payload 24 gönderiyordu → blok).
  526.             $sourcePlanJob = (!$jobBag->get('isNew') && $jobEntity instanceof ProjectOrderTaskJobs)
  527.                 ? $jobEntity->getSourcePlanJob()
  528.                 : null;
  530.             // ⚠️ No RelationResolve
  531.             // source_plan_job: WorksPlan materialization mapping'i (ManyToOne) — generic hydrator
  532.             // array ile set edemez; sadece Materializer/back-sync yönetir, payload'dan hidrasyona girmez.
  533.             // locked: tamamlama kilidi server-kontrollü (plan otoritesi) → FE'den gelse de hidrasyona girmez.
  534.             $excludedFields = ["maxValue", "__reorder__", 'status', 'timeline', 'task_index', 'source_plan_job', 'locked'];
  535.             // Plan-bağlı job'da schedule alanları plandan tazelenecek → stale payload hidrasyona girmesin.
  536.             if ($sourcePlanJob !== null) {
  537.                 $excludedFields[] = 'start_at';
  538.                 $excludedFields[] = 'duration_days';
  539.             }
  541.             $nestedFields = array_diff($jobBag->keys(), $excludedFields);
  543.             $this->entityHydratorValidator
  544.                 ->setEntity($jobEntity)
  545.                 ->setParams($jobBag)
  546.                 ->populateEntityFields($nestedFields);
  547.             // Not: order job 'locked' tutmaz; tamamlanınca PLAN job'u kilitlenir (OrderEndAtBackSyncListener,
  548.             // end_at → source_plan_job.locked=1). Order, plan lock'unu getLocked() ile read-through okur.
  550.             // Plan otoritesi: schedule'ı plandan tazele (stale FE payload'unu geçersiz kıl).
  551.             if ($sourcePlanJob !== null) {
  552.                 $jobEntity->setStartAt($sourcePlanJob->getStartAt());
  553.                 $jobEntity->setDurationDays($sourcePlanJob->getDurationDays());
  554.             }
  556.             // 🔒 Tamamlama kuralı (hard block): başlangıç günü gelmeden (today < start_at)
  557.             // bir job tamamlanamaz. start_at cascade ile dependency'yi içerdiğinden tarih
  558.             // kontrolü yeterli. (FE canlı job-completion-check endpoint'i ile de kontrol eder.)
  559.             $start = $jobEntity->getStartAt();
  560.             $end = $jobEntity->getEndAt();
  561.             // Tarih-string karşılaştırması: start_at saat bileşeniyle gelebilir; bugün == başlangıç
  562.             // günü ise tamamlanabilir (sadece gelecekte ise bloke).
  563.             $todayStr = (new \DateTimeImmutable('today'))->format('Y-m-d');
  564.             if ($end !== null && $start !== null && $start->format('Y-m-d') > $todayStr) {
  565.                 $title = $jobEntity->getJobDescription() ?: $this->translator->trans('Job');
  566.                 throw new \DomainException(
  567.                     $this->translator->trans('Job "%title%" has not started yet (starts %date%) and cannot be completed.', [
  568.                         '%title%' => $title,
  569.                         '%date%' => $start->format('d.m.Y')
  570.                     ])
  571.                 );
  572.             }
  574.             $toAddEntities[] = $jobEntity;
  577.         }
  580.         $oldJobs      = $taskEntity->getTaskJobs()->map(fn(ProjectOrderTaskJobs $job) => $job->getId())->toArray();
  581.         $actuallyJobs = array_map( fn($item) => $item->id, array_filter(
  582.             $task_jobs->all(),
  583.             fn($item) => is_array($item) ? empty($item['isNew']) : (!isset($item->isNew) || $item->isNew === false)
  584.         ));
  586.         $differer       = $this->syncDifferer($actuallyJobs, $oldJobs );
  588.         if($taskEntity->getId()===39){
  589.             #dd($actuallyJobs, $differer);
  590.         }
  593.         // Önce “toRemove” entity’lerini topla, sonra sil
  594.         $toRemoveEntities = [];
  596.         foreach ($differer['toRemove'] as $id) {
  597.             $criteria = Criteria::create()
  598.                 ->where(Criteria::expr()->eq('id', $id))
  599.                 ->setMaxResults(1);
  600.             $jobEntity = $taskEntity->getTaskJobs()->matching($criteria)->first();
  601.             if ($jobEntity) {
  602.                 $toRemoveEntities[] = $jobEntity;
  603.             }
  604.         }
  607.         #SORUN VAR!! Add&Remove yapildiginda sorun cikyior belkide FE de sorun var!!!
  609.         // Şimdi ayrı döngü ile remove
  610.         foreach ($toRemoveEntities as $jobEntity) {
  611.             $taskEntity->removeProjectOrderTaskJob($jobEntity);
  612.         }
  614.         // To Add
  615.         foreach ($toAddEntities as $jobEntity) {
  616.             $taskEntity->addProjectOrderTaskJob($jobEntity);
  617.         }
  619.         # sleep(1);
  623.         // $this->manager->refresh($taskEntity);
  625.         return $taskEntity;
  627.     }
  629.         /**
  630.      * @deprecated
  631.      * use 2. Level (upsertVoucher) no Subscriber
  632.      * @throws \Exception
  633.      */
  634.     public function upsertVoucherWithSubscriber(ProjectOrders $projectOrder, ?ProjectOrderUndertakings $undertaking, InputBag $params): ProjectOrderUndertakings {
  636.         #$doctrineSubscriber = "onFlush"; // prePersist|onFlush
  637.         // TODO !Important READ ME
  638.         /**
  639.          * Buradaki onFlush Secimi (Kullanimi) DoctrineSubscriber icinde onFlush Methodunu Tetikliyor
  640.          * Bu Method  Insert & Update Degisiklikllerini algiliyor
  641.         */
  642.         $doctrineSubscriber = "onFlush"; // prePersist|onFlush
  645.         if(!$undertaking){
  646.             $undertaking = new ProjectOrderUndertakings();
  647.             if($doctrineSubscriber === "prePersist"){
  648.                 $undertaking->setProjectOrder($projectOrder);
  649.             }
  650.             $undertaking->setCreatedAt(new \DateTimeImmutable('now'));
  651.         }
  653.         $this->entityHydratorValidator->setEntity($undertaking)->setParams($params)->populateEntityFields([
  654.             'sent_at',
  655.             // 'completed_at', This by Incoming Budget
  656.             'position_nr', 'price'
  657.         ]);
  659.         // Doctrine Subscriber onFlush
  660.         if($doctrineSubscriber === "onFlush"){
  661.             $projectOrder->addProjectOrderUndertaking($undertaking);
  662.         }
  665.         // Update Metrics Managed Over Subscriber
  666.         // $projectOrder->getProjectOrderMetrics()->setTotalUndertakings()
  667.         #dd(12);
  668.         try{
  669.             if($doctrineSubscriber === "onFlush"){
  670.                 $this->manager->persist($projectOrder);
  671.                 $this->manager->flush();
  672.                 $this->manager->refresh($projectOrder);
  673.             }
  674.             if($doctrineSubscriber === "prePersist"){
  675.                 $this->manager->persist($undertaking);
  676.                 $this->manager->flush();
  677.                 $this->manager->refresh($undertaking);
  678.             }
  679.         } catch (\Exception $exception){
  680.             $this->setCreateException( HttpStatusInterface::BAD_REQUEST, $exception->getMessage());
  681.         }
  682.         return $undertaking;
  683.     }
  685.     /**
  686.      * TODO Deprecated
  687.      * @deprecated
  688.     */
  689.     public function upsertVoucher(ProjectOrders $projectOrder, ?ProjectOrderUndertakings $undertaking, InputBag $params): ?ProjectOrderUndertakings {
  691.         if(!$undertaking){
  692.             $undertaking = new ProjectOrderUndertakings();
  693.             $undertaking->setCreatedAt(new \DateTimeImmutable('now'));
  694.         }
  696.         // Bu sekilide Entity de control edilebilyor
  697.         $params->set('project_order', $projectOrder );
  699.         $validation = $this->entityHydratorValidator
  700.             ->setEntity($undertaking)
  701.             ->setParams($params)
  702.             ->validate(['project_order','position_nr'], 1 );
  705.         #dd($validation);
  706.         if( !is_null($validation) ){
  707.             $this->setCreateException( HttpStatusInterface::SERVICE_UNAVAILABLE, $validation );
  708.             return null;
  709.         }
  711.         // Use validator fields
  712.         $this->entityHydratorValidator->setEntity($undertaking)->setParams($params)->populateEntityFields(['sent_at', 'price']);
  714.         $projectOrder->addProjectOrderUndertaking($undertaking);
  716.         $this->projectOrderCalculator->updateProjectOrderMetrics($projectOrder);
  718.         try{
  719.             $this->manager->persist($projectOrder);
  720.             $this->manager->flush();
  721.         } catch (\Exception $exception){
  722.             $this->setCreateException( HttpStatusInterface::BAD_REQUEST, $exception->getMessage());
  723.         }
  725.         #dd($undertaking);
  729.         return $undertaking;
  730.     }
  732.     /**
  733.      * TODO Deprecated
  734.      * @deprecated
  735.      * @throws \Exception
  736.      */
  737.     public function deleteVoucher(?ProjectOrderUndertakings $undertaking): ?ProjectOrderMetrics
  738.     {
  739.         $em = $this->manager;
  740.         try {
  741.             // Transaction Remove with Update Metrics Pretty & Clean
  742.             return $em->wrapInTransaction(function () use ($undertaking, $em) {
  744.                 $projectOrder = $undertaking->getProjectOrder();
  745.                 $projectOrder->removeProjectOrderUndetaking($undertaking);
  747. //                $calculator = $this->projectOrderCalculator
  748. //                    ->calculateOrderPayments($projectOrder);
  749.                 $this->projectOrderCalculator
  750.                     ->updateProjectOrderMetrics($projectOrder);
  752. //                $projectOrder->getProjectOrderMetrics()->setTotalUndertakings($calculator['undertakingTotal']);
  753. //                $projectOrder->getProjectOrderMetrics()->setReceivedUndertakings($calculator['undertakingReceived']);
  754. //                $projectOrder->getProjectOrderMetrics()->setOpenUndertakings($calculator['undertakingOpen']);
  756.                 $em->persist($projectOrder);
  757.                 $em->flush();
  759.                 return $projectOrder->getProjectOrderMetrics();
  761.             });
  762.         } catch (\Exception $exception) {
  763.             $this->setCreateException($exception->getCode(), $exception->getMessage());
  764.             return null;
  765.         }
  767.     }
  769.     /**
  770.      * @throws \ReflectionException
  771.      */
  772.     public function syncBillings(): ?ProjectOrders {
  774.         $billings = $this->params->get('billings');
  776.         if(!$this->entity instanceof ProjectOrders){
  777.             throw new \Exception(sprintf("Parent entity should be instance of ProjectOrders, %s given", ( new \ReflectionClass($this->entity))->name ));
  778.         }
  780.         $billingBags = $this->entityHydratorValidator->createInputBag($billings);
  782.         $previousBills = $this->entity->getOrderBillings()->map(fn(ProjectOrderBillings $item) => $item->getId())->toArray();
  784.         $onlyNews = array_filter(
  785.             $billingBags->all(),
  786.             fn($item) => is_array($item) ? empty($item['isNew']) : (!isset($item->isNew) || $item->isNew === false)
  787.         );
  791.         $actuallyBills = array_map( fn($item) => is_array($item) ? $item['id'] : $item->id, $onlyNews);
  792.         #dd($actuallyBills);
  793.         $differer = $this->syncDifferer($actuallyBills, $previousBills );
  795.         $toAddEntities = $toRemoveEntities = [];
  797.         // TO REMOVE
  798.         foreach ($differer['toRemove'] as $id) {
  799.             $criteria = Criteria::create()
  800.                 ->where(Criteria::expr()->eq('id', $id))
  801.                 ->setMaxResults(1);
  802.             $billingEntity = $this->entity->getOrderBillings()->matching($criteria)->first();
  803.             if ($billingEntity) {
  804.                 $this->entity->removeProjectOrderBilling($billingEntity);
  805.             }
  806.         }
  808.         foreach ($billingBags as $index => $billingBag ) {
  810.             $billingBag = $this->entityHydratorValidator->createInputBag($billingBag);
  812.             // 1️⃣ Job Entity
  813.             if($billingBag->get('isNew')){
  814.                 $billingEntity = new ProjectOrderBillings();
  815.                 #$billingEntity->setProjectOrder($this->entity);
  816.                 $billingEntity->setCreatedAt(new \DateTimeImmutable('now'));
  817.             } else {
  818.                 /**
  819.                  * Doctrine Collection için PHP 7.4’te filter dışında gerçek bir find operatörü yok.
  820.                  * Criteria kullanicaz
  821.                  * filter gibi tüm koleksiyonu dolaşmaz (özellikle PersistentCollection için)
  822.                  * Doctrine tarafından desteklenen “find” oldugunu ögrendim
  823.                  * ❌ 👉$projectOrder->getProjectOrderTasks()->filter( fn(ProjectOrderTasks $taskEntity) => $taskEntity->getId() === $task->id)->first();
  824.                  */
  825.                 $criteria = Criteria::create()
  826.                     ->where(Criteria::expr()->eq('id', $billingBag->get('id')))
  827.                     ->setMaxResults(1);
  828.                 $billingEntity = $this->entity->getOrderBillings()->matching($criteria)->first();
  830.             }
  833.             // ⚠️ No RelationResolve
  834.             $excludedFields = ["invoice_positions", "sent_at", 'quantity', 'created_at', 'task_index', 'id', 'paid_amount'];
  836.             $nestedFields = array_diff($billingBag->keys(), $excludedFields);
  838.             $billingBag->set('project_order', $this->entity);
  840.             // Always value is 1
  841.             $billingBag->set('quantity', 1);
  843.             $validation = $this->entityHydratorValidator
  844.                 ->setEntity($billingEntity)
  845.                 ->setParams($billingBag)
  846.                 // ->setRequired(['position_nr'])
  847.                 ->validate([
  848.                     'project_order', 'position_nr'
  849.                 ], 1, [
  850.                     "project_order" => "order_nr"
  851.                 ]);
  853.             if( !is_null($validation) ){
  854.                 $this->setCreateException( HttpStatusInterface::SERVICE_UNAVAILABLE, $validation );
  855.                 return null;
  856.             }
  858.             $billingEntity = $this->entityHydratorValidator
  859.                 ->setEntity($billingEntity)
  860.                 ->setParams($billingBag)
  861.                 ->populateEntityFields($nestedFields);
  863.             $this->entity->addProjectOrderBilling($billingEntity);
  864.         }
  866.         // Update only metrics affected by a new billing
  867.         $this->metricService->orderMetrics($this->entity)->syncBillingMetrics();
  869.         // Sync Project
  870.         $this->metricService->projectMetrics($this->entity->getProject())->syncBillingMetrics();
  872. //        // Or (Just target)
  873. //        $calculatorService = $this->calculatorService->orderCalculator($this->entity);
  874. //        $this->entity->getProjectOrderMetrics()
  875. //            ->setOpenBillings($calculatorService->billings()["Total"])
  876. //            ->setPaidBillings($calculatorService->billings()["Paid"])
  877. //            ->setOpenBillings($calculatorService->billings()["Open"]);
  879.         try{
  880.             $this->manager->persist($this->entity);
  881.             $this->manager->flush();
  882.             $this->manager->refresh($this->entity);
  883.         } catch (\Exception $exception){
  884.             $this->setCreateException( HttpStatusInterface::BAD_REQUEST, $exception->getMessage());
  885.         }
  887.         return $this->entity;
  889.     }
  891.     /**
  892.      * @throws \ReflectionException
  893.      */
  894.     public function recalculateMetrics(){
  895.         if(!$this->entity instanceof ProjectOrders){
  896.             throw new Exception("Entity for syncMetrics should be instance of ProjectOrders" . (new \ReflectionClass($this->entity))->name . ' given!');
  897.         }
  898.         $this->metricService->orderMetrics($this->entity)->syncAll();
  900.         try{
  901.             $this->manager->persist($this->entity);
  902.             $this->manager->flush();
  903.             $this->manager->refresh($this->entity);
  904.         } catch (\Exception $exception){
  905.             $this->setCreateException( HttpStatusInterface::BAD_REQUEST, $exception->getMessage());
  906.         }
  907.         return $this->entity;
  909.     }
  911.     /**
  912.      * @throws \ReflectionException
  913.      * @return array{"classic": ArrayCollection<ProjectOrderExpensePositions>, "stock": ArrayCollection}
  914.      */
  915.     public function orderExpenses(): array
  916.     {
  918.         if(!$this->entity instanceof ProjectOrders){
  919.             throw new Exception("Entity for syncMetrics should be instance of ProjectOrders" . (new \ReflectionClass($this->entity))->name . ' given!');
  920.         }
  922.         $criteria = Criteria::create()
  923.             ->orderBy(['id' => Criteria::DESC]);
  925.         return [
  926.             "classic" => $this->entity->getProjectOrderExpensePositions()->matching($criteria),
  927.             "stock" => $this->entity->getStockTransactions()->matching($criteria)
  928.         ];
  930.     }
  932.     /**
  933.      * Order silme/tasima oncesi kullaniciya gosterilecek deger-bazli ozet.
  934.      * Sadece toplamlar (harcama, stok cikisi, worktime saat, billing) doner.
  935.      *
  936.      * @throws \ReflectionException
  937.      */
  938.     public function dependencySummary(): array
  939.     {
  940.         $this->entity = $this->entityHydratorValidator->assertHydratedEntity(ProjectOrders::class, $this->entity);
  941.         /** @var ProjectOrders $order */
  942.         $order = $this->entity;
  944.         // Harcama pozisyonlari -> (amount / (pe ?? 1)) * buying_price
  945.         $expenseTotal = 0.0;
  946.         $expensePositions = $order->getProjectOrderExpensePositions();
  947.         foreach ($expensePositions as $position) {
  948.             $amount = floatval($position->getAmount());
  949.             $pe = $position->getPriceUnit();
  950.             $divisor = (!is_null($pe) && floatval($pe) != 0.0) ? floatval($pe) : 1.0;
  951.             $expenseTotal += ($amount / $divisor) * floatval($position->getBuyingPrice());
  952.         }
  954.         // Stok cikislari -> quantity * buying_price
  955.         $stockTotal = 0.0;
  956.         $stockTransactions = $order->getStockTransactions();
  957.         foreach ($stockTransactions as $transaction) {
  958.             $stockTotal += floatval($transaction->getQuantity()) * floatval($transaction->getBuyingPrice());
  959.         }
  961.         // Billing -> quantity * price
  962.         $billingTotal = 0.0;
  963.         $billings = $order->getOrderBillings();
  964.         foreach ($billings as $billing) {
  965.             $billingTotal += floatval($billing->getQuantity()) * floatval($billing->getPrice());
  966.         }
  968.         // Worktime saatleri (timesheet JSON'dan)
  969.         $worktimeHours = $this->timesheetMutator->sumOrderHours($order->getId());
  971.         // Kesilmis faturaya bagli pozisyonlar -> tutar (Banner/Balken)
  972.         $invoicePositions = $order->getInvoicePositions();
  973.         $invoicedCount = $invoicePositions->count();
  974.         $invoiceTotal = 0.0;
  975.         foreach ($invoicePositions as $invoicePosition) {
  976.             $invoiceTotal += floatval($invoicePosition->getPositionAmount());
  977.         }
  979.         // Sifre gate: worktime / billing / invoice en az biri varsa silme sifre ister.
  980.         // Admin USER_ROLE dahil herkes icin ayni — bypass yok ([[reference_destructive_op_pattern]]).
  981.         $requiresPassword = $worktimeHours > 0
  982.             || $billings->count() > 0
  983.             || $invoicedCount > 0;
  985.         // Banner verisi: proje + owner
  986.         $project = $order->getProject();
  987.         $owner = $project ? $project->getOwner() : null;
  989.         // Tasi hedefi: SISTEMDEKI TUM order'lar (proje/ownership filtresi YOK) — projeler arasi tasimaya izinli.
  990.         // Hafif: entity hydrate etmeden id + order_nr + proje nr cekilir.
  991.         $rows = $this->manager->createQuery(
  992.             'SELECT o.id AS id, o.order_nr AS order_nr, p.project_id AS project_nr, p.name AS project_name '
  993.             . 'FROM App\Entity\ProjectOrders o JOIN o.project p ORDER BY o.id DESC'
  994.         )->getArrayResult();
  996.         $selfId = $order->getId();
  997.         $moveableOrders = [];
  998.         foreach ($rows as $r) {
  999.             if ((int) $r['id'] === $selfId) {
  1000.                 continue;
  1001.             }
  1002.             $moveableOrders[] = [
  1003.                 "id" => (int) $r['id'],
  1004.                 "order_nr" => $r['order_nr'],
  1005.                 "project_nr" => $r['project_nr'],
  1006.                 "project_name" => $r['project_name']
  1007.             ];
  1008.         }
  1010.         return [
  1011.             "order" => [
  1012.                 "id" => $order->getId(),
  1013.                 "order_nr" => $order->getOrderNr(),
  1014.                 "project_owner_order_nr" => $order->getProjectOwnerOrderNr()
  1015.             ],
  1016.             "project" => [
  1017.                 "nr" => $project ? $project->getProjectId() : null,
  1018.                 "name" => $project ? $project->getName() : null
  1019.             ],
  1020.             "owner" => [
  1021.                 "company" => $owner ? $owner->getCompany() : null
  1022.             ],
  1023.             "moveable_orders" => $moveableOrders,
  1024.             "expense" => [
  1025.                 "count" => $expensePositions->count(),
  1026.                 "total" => round($expenseTotal, 2)
  1027.             ],
  1028.             "stock" => [
  1029.                 "count" => $stockTransactions->count(),
  1030.                 "total" => round($stockTotal, 2)
  1031.             ],
  1032.             "worktime" => [
  1033.                 "hours" => round($worktimeHours, 2)
  1034.             ],
  1035.             "billing" => [
  1036.                 "count" => $billings->count(),
  1037.                 "total" => round($billingTotal, 2)
  1038.             ],
  1039.             "invoice" => [
  1040.                 "count" => $invoicedCount,
  1041.                 "total" => round($invoiceTotal, 2)
  1042.             ],
  1043.             "tasks" => [
  1044.                 "count" => $order->getProjectOrderTasks()->count()
  1045.             ],
  1046.             "invoiced" => [
  1047.                 "count" => $invoicedCount,
  1048.                 "blocks_delete" => $requiresPassword
  1049.             ],
  1050.             "delete_requires_password" => $requiresPassword,
  1051.             "password_reasons" => [
  1052.                 "worktime" => $worktimeHours > 0,
  1053.                 "billing"  => $billings->count() > 0,
  1054.                 "invoiced" => $invoicedCount > 0
  1055.             ]
  1056.         ];
  1057.     }
  1059.     /**
  1060.      * Order'i ve butun bagimliliklarini cascade siler.
  1061.      * Kesilmis bir faturaya bagli pozisyonu varsa silmez (blok) -> kullanici Tasi kullanmali.
  1062.      * Stok dengesi Doctrine subscriber tarafindan ORM remove ile otomatik duzeltilir.
  1063.      *
  1064.      * @throws \ReflectionException
  1065.      */
  1066.     public function cascadeDelete(bool $force = false, ?string $password = null): array
  1067.     {
  1068.         $this->entity = $this->entityHydratorValidator->assertHydratedEntity(ProjectOrders::class, $this->entity);
  1069.         /** @var ProjectOrders $order */
  1070.         $order = $this->entity;
  1072.         $hasInvoicePositions = $order->getInvoicePositions()->count() > 0;
  1073.         $hasBillings         = $order->getOrderBillings()->count() > 0;
  1074.         $hasWorktime         = $this->timesheetMutator->sumOrderHours($order->getId()) > 0;
  1075.         $requiresPassword    = $hasInvoicePositions || $hasBillings || $hasWorktime;
  1077.         // Guard: worktime / billing / invoiced position en az biri varsa silme sifre ister.
  1078.         // Admin USER_ROLE dahil herkes icin ayni — bypass yok ([[reference_destructive_op_pattern]]).
  1079.         if ($requiresPassword) {
  1080.             if (!$force) {
  1081.                 $this->setCreateException(
  1082.                     HttpStatusInterface::BAD_REQUEST,
  1083.                     $this->translator->trans('This order has tracked time, billings or invoiced positions. Force-delete requires the override password.')
  1084.                 );
  1085.                 return [];
  1086.             }
  1087.             if ($this->orderForceDeletePassword === '' || !hash_equals($this->orderForceDeletePassword, (string) $password)) {
  1088.                 $this->setCreateException(
  1089.                     HttpStatusInterface::UNAUTHORIZED,
  1090.                     $this->translator->trans('Invalid force-delete password.')
  1091.                 );
  1092.                 return [];
  1093.             }
  1094.         }
  1096.         $orderId = $order->getId();
  1097.         $orderNr = $order->getOrderNr();
  1098.         $project = $order->getProject(); // metrik resync icin order silinmeden once yakala
  1099.         $em = $this->manager;
  1101.         try {
  1102.             return $em->wrapInTransaction(function () use ($order, $orderId, $orderNr, $em, $force, $hasInvoicePositions, $project) {
  1104.                 // 1) Timesheet JSON temizligi (FK degil, JSON key)
  1105.                 $affectedTimesheetColumns = $this->timesheetMutator->removeOrderFromTimesheets($orderId);
  1107.                 // 1.5) Force + faturali ise: kesilmis faturaya bagli invoice_positions'i da sil
  1108.                 //      (order->invoice_positions FK'sinde cascade-remove yok, elle kaldirilmali)
  1109.                 if ($force && $hasInvoicePositions) {
  1110.                     foreach ($order->getInvoicePositions()->toArray() as $invoicePosition) {
  1111.                         $em->remove($invoicePosition);
  1112.                     }
  1113.                 }
  1115.                 // 2) FK'li ve cascade-remove'u olmayan bagimlilari elle sil
  1116.                 //    (ORM remove -> subscriber'lar, ozellikle stok dengesi, tetiklenir)
  1117.                 foreach ($order->getWorkerTimesheetPayments()->toArray() as $payment) {
  1118.                     $em->remove($payment);
  1119.                 }
  1120.                 foreach ($order->getProjectOrderExtraCosts()->toArray() as $extraCost) {
  1121.                     $em->remove($extraCost);
  1122.                 }
  1123.                 foreach ($order->getProjectOrderExpensePositions()->toArray() as $position) {
  1124.                     $em->remove($position);
  1125.                 }
  1126.                 foreach ($order->getStockTransactions()->toArray() as $stockTransaction) {
  1127.                     $em->remove($stockTransaction);
  1128.                 }
  1129.                 foreach ($order->getStockIssues()->toArray() as $stockIssue) {
  1130.                     $em->remove($stockIssue);
  1131.                 }
  1132.                 foreach ($order->getProjectOrderTasks()->toArray() as $task) {
  1133.                     $em->remove($task);
  1134.                 }
  1135.                 foreach ($order->getOrderBillings()->toArray() as $billing) {
  1136.                     $em->remove($billing);
  1137.                 }
  1139.                 // 3) Order'i sil -> Feedback, ProjectOrderInvoices, Undertakings, Metrics
  1140.                 //    cascade={"remove"} oldugundan otomatik gider.
  1141.                 $em->remove($order);
  1142.                 $em->flush();
  1144.                 // Order silindi -> projenin rollup metrikleri stale kalmasin. Order'in
  1145.                 // kendi metrikleri cascade ile gitti; proje toplamlari kalan order'lar
  1146.                 // uzerinden yeniden hesaplanmali (move akimiyla simetrik).
  1147.                 $sourceProject = null;
  1148.                 if ($project) {
  1149.                     $this->metricService->projectMetrics($project)->syncAll();
  1150.                     $em->flush();
  1152.                     // Order silindikten sonra proje order'siz kaldi mi? (FE: bos projeyi sil teklif eder)
  1153.                     $remainingOrders = $this->manager->getRepository(ProjectOrders::class)->count(['project' => $project->getId()]);
  1154.                     $sourceProject = [
  1155.                         "id"    => $project->getId(),
  1156.                         "name"  => $project->getName(),
  1157.                         "empty" => $remainingOrders === 0
  1158.                     ];
  1159.                 }
  1161.                 return [
  1162.                     "id" => $orderId,
  1163.                     "order_nr" => $orderNr,
  1164.                     "affected_timesheet_columns" => $affectedTimesheetColumns,
  1165.                     "source_project" => $sourceProject
  1166.                 ];
  1167.             });
  1168.         } catch (\Exception $exception) {
  1169.             $this->setCreateException(HttpStatusInterface::BAD_REQUEST, $exception->getMessage());
  1170.             return [];
  1171.         }
  1172.     }
  1174.     /**
  1175.      * Order'i ve TUM bagimliliklarini streamed (adim adim) force-delete eder. GERI DONUS YOK.
  1176.      *
  1177.      * Tek order: sayilar silmeden ONCE okunur, mevcut cascadeDelete(force, password) ile silinir
  1178.      * (expenses/billings/invoices/stock + timesheet JSON temizligi orada, tek transaction),
  1179.      * sonra her bagimlilik tipi ayri madde olarak emit edilir (FE checklist'i isaretler).
  1180.      * Fatura bagliysa (blocks_delete) gecerli override sifresi zorunludur; degilse sifresiz silinir.
  1181.      */
  1182.     public function forceDeleteStreamed(?string $password): StreamedResponse
  1183.     {
  1184.         /** @var ProjectOrders $order */
  1185.         $order = $this->entity;
  1186.         $trans = $this->translator;
  1188.         $response = new StreamedResponse(function () use ($order, $password, $trans) {
  1190.             // SSE: tampon temizle, her echo aninda gitsin
  1191.             while (ob_get_level() > 0) { ob_end_flush(); }
  1192.             ob_implicit_flush(true);
  1194.             $emit = function (string $event, array $data) {
  1195.                 echo "event: {$event}\n";
  1196.                 echo "data: " . json_encode($data, JSON_UNESCAPED_UNICODE) . "\n\n";
  1197.                 flush();
  1198.             };
  1200.             if (!$order instanceof ProjectOrders) {
  1201.                 $emit('custom_error', ['message' => $trans->trans('Order not found'), 'severity' => 'error']);
  1202.                 return;
  1203.             }
  1205.             // Silmeden ONCE sayilari oku (cascadeDelete sonrasi gider).
  1206.             $nr            = $order->getOrderNr();
  1207.             $expCnt        = $order->getProjectOrderExpensePositions()->count();
  1208.             $billCnt       = $order->getOrderBillings()->count();
  1209.             $invCnt        = $order->getInvoicePositions()->count();
  1210.             $stockCnt      = $order->getStockTransactions()->count();
  1211.             $worktimeHours = $this->timesheetMutator->sumOrderHours($order->getId());
  1213.             // worktime / billing / invoiced position en az biri varsa override sifresi zorunlu.
  1214.             // Admin USER_ROLE dahil herkes icin ayni — bypass yok.
  1215.             $requiresPassword = $invCnt > 0 || $billCnt > 0 || $worktimeHours > 0;
  1216.             if ($requiresPassword) {
  1217.                 if ($this->orderForceDeletePassword === '' || !hash_equals($this->orderForceDeletePassword, (string) $password)) {
  1218.                     $emit('custom_error', ['message' => $trans->trans('Invalid force-delete password.'), 'severity' => 'error']);
  1219.                     return;
  1220.                 }
  1221.             }
  1223.             $totalSteps = 1; // check
  1224.             if ($expCnt > 0)        { $totalSteps++; }
  1225.             if ($billCnt > 0)       { $totalSteps++; }
  1226.             if ($invCnt > 0)        { $totalSteps++; }
  1227.             if ($stockCnt > 0)      { $totalSteps++; }
  1228.             if ($worktimeHours > 0) { $totalSteps++; }
  1229.             $totalSteps++; // order removed
  1231.             $emit('progress', ['message' => $trans->trans('Dependencies checked'), 'severity' => 'success', 'key' => 'check', 'total' => $totalSteps]);
  1233.             // Mevcut cascade silme servisi (expenses · billings · invoices · stock · worktime JSON) — tek transaction.
  1234.             $result = $this->cascadeDelete($requiresPassword, $password);
  1235.             if ($this->getException()) {
  1236.                 $emit('custom_error', ['message' => $this->getException()->getMessage(), 'severity' => 'error']);
  1237.                 return;
  1238.             }
  1240.             if ($expCnt > 0) {
  1241.                 $emit('progress', ['message' => $nr . ' — ' . $trans->trans('expenses removed') . ' (' . $expCnt . ')', 'severity' => 'success', 'key' => 'expenses', 'count' => $expCnt]);
  1242.             }
  1243.             if ($billCnt > 0) {
  1244.                 $emit('progress', ['message' => $nr . ' — ' . $trans->trans('billings removed') . ' (' . $billCnt . ')', 'severity' => 'success', 'key' => 'billings', 'count' => $billCnt]);
  1245.             }
  1246.             if ($invCnt > 0) {
  1247.                 $emit('progress', ['message' => $nr . ' — ' . $trans->trans('invoices removed') . ' (' . $invCnt . ')', 'severity' => 'success', 'key' => 'invoices', 'count' => $invCnt]);
  1248.             }
  1249.             if ($stockCnt > 0) {
  1250.                 $emit('progress', ['message' => $nr . ' — ' . $trans->trans('stock removed') . ' (' . $stockCnt . ')', 'severity' => 'success', 'key' => 'stock', 'count' => $stockCnt]);
  1251.             }
  1252.             if ($worktimeHours > 0) {
  1253.                 $emit('progress', ['message' => $nr . ' — ' . $trans->trans('worktime cleared'), 'severity' => 'success', 'key' => 'worktime']);
  1254.             }
  1255.             $emit('progress', ['message' => $nr . ' — ' . $trans->trans('order removed'), 'severity' => 'success', 'key' => 'order', 'order_id' => isset($result['id']) ? $result['id'] : null]);
  1257.             $emit('end', ['severity' => 'success', 'message' => $trans->trans('Order and all dependencies deleted'), 'source_project' => isset($result['source_project']) ? $result['source_project'] : null]);
  1258.         });
  1260.         $response->headers->set('Content-Type', 'text/event-stream');
  1261.         $response->headers->set('Cache-Control', 'no-cache');
  1262.         $response->headers->set('X-Accel-Buffering', 'no');
  1263.         $response->headers->set('Connection', 'keep-alive');
  1264.         return $response;
  1265.     }
  1267.     /**
  1268.      * Order'in butun bagimliliklarini (expense, stok, billing, fatura poz., task, timesheet JSON ...)
  1269.      * hedef order'a tasir. Iki order ayni projeye ait olmali.
  1270.      *
  1271.      * @throws \ReflectionException
  1272.      */
  1273.     public function moveAllDependenciesTo(?ProjectOrders $to): array
  1274.     {
  1275.         $this->entity = $this->entityHydratorValidator->assertHydratedEntity(ProjectOrders::class, $this->entity);
  1276.         /** @var ProjectOrders $from */
  1277.         $from = $this->entity;
  1279.         if (!$to) {
  1280.             $this->setCreateException(HttpStatusInterface::NOT_FOUND, $this->translator->trans('Target order not found'));
  1281.             return [];
  1282.         }
  1283.         if ($from->getId() === $to->getId()) {
  1284.             $this->setCreateException(HttpStatusInterface::NOT_ACCEPTABLE, $this->translator->trans('Source and target order must be different'));
  1285.             return [];
  1286.         }
  1287.         // NOT: Projeler arasi tasimaya izin verildi (kullanici karari) — ayni-proje guard'i kaldirildi.
  1288.         // Bagimliliklar (expense/stok/timesheet JSON dahil) hedef order'a, dolayisiyla hedefin projesine gecer.
  1290.         $em = $this->manager;
  1292.         try {
  1293.             return $em->wrapInTransaction(function () use ($from, $to, $em) {
  1295.                 // 1) Timesheet JSON tasima
  1296.                 $affectedTimesheetColumns = $this->timesheetMutator->moveOrderInTimesheets($from, $to);
  1298.                 // 2) FK'li bagimlilari hedef order'a yeniden bagla
  1299.                 foreach ($from->getWorkerTimesheetPayments()->toArray() as $payment) {
  1300.                     $payment->setProjectOrder($to);
  1301.                     $em->persist($payment);
  1302.                 }
  1303.                 foreach ($from->getProjectOrderExtraCosts()->toArray() as $extraCost) {
  1304.                     $extraCost->setProjectOrder($to);
  1305.                     $em->persist($extraCost);
  1306.                 }
  1307.                 foreach ($from->getProjectOrderExpensePositions()->toArray() as $position) {
  1308.                     $position->setProjectOrder($to);
  1309.                     $em->persist($position);
  1310.                 }
  1311.                 foreach ($from->getStockTransactions()->toArray() as $stockTransaction) {
  1312.                     $stockTransaction->setProjectOrder($to);
  1313.                     $em->persist($stockTransaction);
  1314.                 }
  1315.                 foreach ($from->getStockIssues()->toArray() as $stockIssue) {
  1316.                     $stockIssue->setProjectOrder($to);
  1317.                     $em->persist($stockIssue);
  1318.                 }
  1319.                 foreach ($from->getProjectOrderTasks()->toArray() as $task) {
  1320.                     $task->setProjectOrder($to);
  1321.                     $em->persist($task);
  1322.                 }
  1323.                 foreach ($from->getOrderBillings()->toArray() as $billing) {
  1324.                     $billing->setProjectOrder($to);
  1325.                     $em->persist($billing);
  1326.                 }
  1327.                 foreach ($from->getProjectOrderFeedback()->toArray() as $feedback) {
  1328.                     $feedback->setProjectOrder($to);
  1329.                     $em->persist($feedback);
  1330.                 }
  1331.                 foreach ($from->getProjectOrderUndertakings()->toArray() as $undertaking) {
  1332.                     $undertaking->setProjectOrder($to);
  1333.                     $em->persist($undertaking);
  1334.                 }
  1335.                 foreach ($from->getProjectOrderInvoices()->toArray() as $invoice) {
  1336.                     $invoice->setProjectOrder($to);
  1337.                     $em->persist($invoice);
  1338.                 }
  1339.                 foreach ($from->getInvoicePositions()->toArray() as $invoicePosition) {
  1340.                     $invoicePosition->setProjectOrder($to);
  1341.                     $em->persist($invoicePosition);
  1342.                 }
  1344.                 $em->flush();
  1346.                 // Reassign sonrasi $from/$to'nun in-memory koleksiyonlari STALE kalir:
  1347.                 // pozisyonlarin owning-side'i ($position->project_order) degisti ama
  1348.                 // $from->getProjectOrderExpensePositions() hala eski elemanlari tutar.
  1349.                 // Metrik calculator bu koleksiyonu okudugu icin DB'den tazelemezsek
  1350.                 // $from metrigi (ve dolayisiyla projesi) stale kalir.
  1351.                 $em->refresh($from);
  1352.                 $em->refresh($to);
  1354.                 // 3) Metrikleri her iki order icin yeniden hesapla
  1355.                 $this->metricService->orderMetrics($from)->syncAll();
  1356.                 $this->metricService->orderMetrics($to)->syncAll();
  1358.                 // Proje rollup metriklerini de yeniden hesapla. Cross-project move'da
  1359.                 // kaynak proje (eksilir) ve hedef proje (artar) toplamlari degisir;
  1360.                 // orderMetrics->syncAll() sadece order seviyesine dokundugu icin proje
  1361.                 // seviyesi stale kalirdi. Ayni projeyse id dedup ile tek kez sync edilir.
  1362.                 $affectedProjects = [];
  1363.                 foreach ([$from->getProject(), $to->getProject()] as $project) {
  1364.                     if ($project) {
  1365.                         $affectedProjects[$project->getId()] = $project;
  1366.                     }
  1367.                 }
  1368.                 foreach ($affectedProjects as $project) {
  1369.                     $this->metricService->projectMetrics($project)->syncAll();
  1370.                 }
  1372.                 $em->persist($from);
  1373.                 $em->persist($to);
  1374.                 $em->flush();
  1376.                 return [
  1377.                     "from" => ["id" => $from->getId(), "order_nr" => $from->getOrderNr()],
  1378.                     "to" => ["id" => $to->getId(), "order_nr" => $to->getOrderNr()],
  1379.                     "affected_timesheet_columns" => $affectedTimesheetColumns
  1380.                 ];
  1381.             });
  1382.         } catch (\Exception $exception) {
  1383.             $this->setCreateException(HttpStatusInterface::BAD_REQUEST, $exception->getMessage());
  1384.             return [];
  1385.         }
  1386.     }
  1389.     /**
  1390.      * Seçilen sipariş için tüm zamanlarda çalışılan saatleri ve maliyetleri döndürür.
  1391.      * Timesheet satırları repository SQL filtresi ile önceden daraltılır;
  1392.      * PHP'de yalnızca ilgili satırlar işlenir.
  1393.      *
  1394.      * @throws \ReflectionException
  1395.      * @throws \Exception
  1396.      */
  1397.     public function laborDetails(): array {
  1399.         $this->entity = $this->entityHydratorValidator->assertHydratedEntity(ProjectOrders::class, $this->entity);
  1401.         /** @var ProjectOrders $order */
  1402.         $order   = $this->entity;
  1403.         $orderId = $order->getId();
  1404.         $orderKey = (string) $orderId; // JSON decode sonrası key'ler string olur
  1406.         $filterBranchId = $this->params->get('branch') !== null ? (int) $this->params->get('branch') : null;
  1408.         /** @var \App\Repository\WorkerTimesheetRepository $repo */
  1409.         $repo       = $this->manager->getRepository(WorkerTimesheet::class);
  1410.         $timesheets = $repo->findTimesheetsByOrder($orderId, $order->getOrderNr() ?? '');
  1412.         $monthNamesShortGerman = ['Jan', 'Feb', 'Mär', 'Apr', 'Mai', 'Jun', 'Jul', 'Aug', 'Sep', 'Okt', 'Nov', 'Dez'];
  1413.         $collected_in_orders   = [];
  1414.         $orderName             = '';
  1416.         foreach ($timesheets as $timesheet) {
  1417.             for ($m = 1; $m <= 12; $m++) {
  1418.                 for ($d = 1; $d <= 31; $d++) {
  1420.                     $col    = "m{$m}_d{$d}";
  1421.                     $dayRaw = $timesheet[$col] ?? null;
  1423.                     if (!$dayRaw) continue;
  1425.                     $day = json_decode($dayRaw, true);
  1427.                     if (!is_array($day))                           continue;
  1428.                     if (($day['absenceShortKey'] ?? null) !== 'P') continue;
  1429.                     if (!isset($day['projects']))                  continue;
  1431.                     foreach ($day['projects'] as $project) {
  1433.                         if (!isset($project['roles'])) continue;
  1435.                         $costPerHour = (float) ($project['final']['cost_per_hour'] ?? 0);
  1437.                         // En yetkili (en düşük role numarası) ve bu order'a sahip role'u bul
  1438.                         $bestRoleEntry = null;
  1439.                         $bestRoleLevel = PHP_INT_MAX;
  1440.                         foreach ($project['roles'] as $roleEntry) {
  1441.                             if (!isset($roleEntry['orders'][$orderKey])) continue;
  1442.                             $level = (int) ($roleEntry['role'] ?? PHP_INT_MAX);
  1443.                             if ($level < $bestRoleLevel) {
  1444.                                 $bestRoleLevel = $level;
  1445.                                 $bestRoleEntry = $roleEntry;
  1446.                             }
  1447.                         }
  1448.                         if ($bestRoleEntry === null) continue;
  1450.                         $roleEntry  = $bestRoleEntry;
  1451.                         {
  1452.                             $orderValue = $roleEntry['orders'][$orderKey];
  1453.                             $orderName  = $orderValue['order'] ?? $orderName;
  1455.                             if (isset($orderValue['branches'])) {
  1456.                                 foreach ($orderValue['branches'] as $branchId => $branchValue) {
  1457.                                     if ($filterBranchId !== null && (int) $branchId !== $filterBranchId) continue;
  1458.                                     $time = (float) ($branchValue['time'] ?? 0);
  1459.                                     if ($time <= 0) continue;
  1461.                                     $collected_in_orders[] = [
  1462.                                         'id'            => implode('_', [$timesheet['activity_id'], $orderId, $m, $d, $branchId]),
  1463.                                         'worked_at'     => sprintf('%d-%02d-%02d', $timesheet['year'], $m, $d),
  1464.                                         'employee'      => trim($timesheet['name'] . ' ' . $timesheet['surname']),
  1465.                                         'branch'        => $branchValue['branch'] ?? 'Unknown',
  1466.                                         'order'         => $orderName,
  1467.                                         'order_id'      => $orderId,
  1468.                                         'year'          => (int) $timesheet['year'],
  1469.                                         'month_name'    => $monthNamesShortGerman[$m - 1],
  1470.                                         'month_numeric' => $m,
  1471.                                         'info'          => [
  1472.                                             'time'           => $time,
  1473.                                             'price_per_hour' => $costPerHour,
  1474.                                             'cost'           => round($time * $costPerHour, 2),
  1475.                                             'branch'         => $branchValue['branch'] ?? 'Unknown',
  1476.                                         ],
  1477.                                     ];
  1478.                                 }
  1479.                             } else {
  1480.                                 // Branch atanmamış — order değerinden direkt al
  1481.                                 $time = (float) ($orderValue['time'] ?? 0);
  1482.                                 if ($time <= 0) continue;
  1484.                                 $collected_in_orders[] = [
  1485.                                     'id'            => implode('_', [$timesheet['activity_id'], $orderId, $m, $d]),
  1486.                                     'worked_at'     => sprintf('%d-%02d-%02d', $timesheet['year'], $m, $d),
  1487.                                     'employee'      => trim($timesheet['name'] . ' ' . $timesheet['surname']),
  1488.                                     'branch'        => 'Not assigned',
  1489.                                     'order'         => $orderName,
  1490.                                     'order_id'      => $orderId,
  1491.                                     'year'          => (int) $timesheet['year'],
  1492.                                     'month_name'    => $monthNamesShortGerman[$m - 1],
  1493.                                     'month_numeric' => $m,
  1494.                                     'info'          => [
  1495.                                         'time'           => $time,
  1496.                                         'price_per_hour' => $costPerHour,
  1497.                                         'cost'           => round($time * $costPerHour, 2),
  1498.                                         'branch'         => 'Not assigned',
  1499.                                     ],
  1500.                                 ];
  1501.                             }
  1502.                         }
  1503.                     }
  1504.                 }
  1505.             }
  1506.         }
  1508.         // Toplam özet
  1509.         $summaryHours = array_sum(array_map(fn($r) => $r['info']['time'], $collected_in_orders));
  1510.         $summaryCost  = array_sum(array_map(fn($r) => $r['info']['cost'], $collected_in_orders));
  1512.         // Proje branch'leri (frontend'deki Branch filtresi için)
  1513.         $projectBranches = [];
  1514.         foreach ($order->getProject()->getBranches() as $branch) {
  1515.             $projectBranches[] = ['id' => $branch->getId(), 'name' => $branch->getName()];
  1516.         }
  1518.         return [
  1519.             'order_name'          => $orderName,
  1520.             'collected_in_orders' => $collected_in_orders,
  1521.             'project_branches'    => $projectBranches,
  1522.             'summary_hours'       => round($summaryHours, 2),
  1523.             'summary_cost'        => round($summaryCost, 2),
  1524.         ];
  1525.     }
  1527.     public function laborDetailsPdf(string $printedBy): ?array
  1528.     {
  1529.         $laborData = $this->laborDetails();
  1531.         if ($this->getException() !== null) {
  1532.             return null;
  1533.         }
  1535.         /** @var ProjectOrders $order */
  1536.         $order = $this->entity;
  1538.         $orderInfo = [
  1539.             'order_nr'   => $order->getProjectOwnerOrderNr() !== null ? $order->getProjectOwnerOrderNr() : (string) $order->getId(),
  1540.             'order_name' => $laborData['order_name'] ?? '',
  1541.         ];
  1543.         $chartLineB64 = $this->params->get('chart_line') !== null ? $this->params->get('chart_line') : null;
  1545.         try {
  1546.             $base64 = $this->laborCostPdfService->generate(
  1547.                 $orderInfo,
  1548.                 $laborData['collected_in_orders'] ?? [],
  1549.                 $printedBy,
  1550.                 $chartLineB64
  1551.             );
  1552.         } catch (\Exception $e) {
  1553.             $this->setCreateException(500, $e->getMessage());
  1554.             return null;
  1555.         }
  1557.         return [
  1558.             'pdf_base64' => $base64,
  1559.             'filename'   => preg_replace('/[^a-z0-9_]/i', '_', $orderInfo['order_nr']) . '_labor_cost.pdf',
  1560.         ];
  1561.     }
  1562. }