src/Controller/Api/Service/TimesheetService.php line 565

Open in your IDE?
  1. <?php
  3. namespace App\Controller\Api\Service;
  5. use App\Context\Metrics\MetricContextFactory;
  6. use App\Entity\AccessRoles;
  7. use App\Entity\Branches;
  8. use App\Entity\Countries;
  9. use App\Entity\ProjectOrderMetrics;
  10. use App\Entity\ProjectOrders;
  11. use App\Entity\Projects;
  12. use App\Entity\ProjectStakeholders;
  13. use App\Entity\TimesheetStatus;
  14. use App\Entity\Vendor;
  15. use App\Entity\VendorContactPersons;
  16. use App\Entity\Worker;
  17. use App\Entity\WorkerActivities;
  18. use App\Entity\WorkerInProject;
  19. use App\Entity\WorkerTimesheet;
  20. use App\Entity\WorkerTimesheetHistories;
  21. use App\Enum\SeverityInterface;
  22. use App\Repository\WorkerActivitiesRepository;
  23. use App\Repository\WorkerTimesheetRepository;
  24. use App\Service\AisDate;
  25. use App\Service\FileUploader;
  26. use App\Service\SerializeService\ReferenceSerialize;
  27. use App\Service\TimesheetInterface\TimesheetHistoryInterface;
  28. use App\Service\TimesheetInterface\TimesheetReaderInterface;
  29. use App\Service\TimesheetInterface\TimesheetWriterInterface;
  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 Symfony\Component\HttpFoundation\FileBag;
  36. use Symfony\Component\HttpFoundation\InputBag;
  37. use Symfony\Component\HttpFoundation\Response;
  38. use Symfony\Component\Security\Core\Security;
  39. use Symfony\Contracts\Translation\TranslatorInterface;
  43. class TimesheetService extends AbstractControllerService
  44. {
  45.     // TODO #88: Bir çalışanın bir gündeki toplam P (çalışma) saati bu değeri aşamaz.
  46.     // Sınır aşılınca upsert BATCH'i atomik reddedilir (aşağıdaki assertDailyHourCap).
  47.     const MAX_DAILY_WORK_HOURS = 10;
  49.     // Cumartesi ayrı ve daha düşük tavana tabidir (kullanıcı kararı 2026-07-29):
  50.     // Pzt–Cuma en fazla 10 saat, CUMARTESİ en fazla 6 saat. Pazar'a zaten yazım yapılmaz.
  51.     const MAX_SATURDAY_WORK_HOURS = 6;
  53.     private EntityHydratorValidator $entityHydratorValidator;
  54.     private TimesheetReaderInterface $timesheetReader;
  55.     private TimesheetWriterInterface $timesheetWriter;
  56.     private TimesheetHistoryInterface $timesheetHistory;
  58.     private MetricContextFactory $metricContextFactory;
  60.     /**
  61.      * Timesheet Status and Order Metrics Update
  62.      *
  63.      * Each employee can declare work for a specific day. When work is declared,
  64.      * the project and order for that day are known, allowing calculation of
  65.      * spent cost and time metrics for that order.
  66.      *
  67.      * If the timesheet entry is later changed (e.g., from "P" – Presence – to "S" – Sick),
  68.      * the previously recorded order must be updated accordingly, because the actual
  69.      * work has changed and the spent time/cost for that order may be reduced.
  70.      *
  71.      * In such cases, the employee's previous status (history) is used to locate
  72.      * the corresponding order and recalculate its metrics, ensuring that order-level
  73.      * spent cost and time values remain accurate.
  74.      *
  75.      * Additionally:
  76.      *  - When processing hours or "S" entries, the same employee and day may have
  77.      *    multiple entries for the same order.
  78.      *  - To avoid redundant database queries, the physical Order entities should
  79.      *    be stored in memory (e.g., via a Factory pattern).
  80.      *  - Each order is instantiated only once; subsequent occurrences on the same
  81.      *    day or for the same employee reuse the existing entity.
  82.      *  - This ensures that metrics calculation references a single instance of the order,
  83.      *    avoiding inconsistencies and improving performance.
  84.      *
  85.      * Status Legend:
  86.      *  P  - Presence (worked)
  87.      *  S  - Sick
  88.      *  H  - Holiday
  89.      *  FreeLeave - Unpaid / optional leave
  90.      */
  91.     private array $orderCache;
  92.     /**
  93.      * Similar Information like $orderFactory
  94.     */
  95.     private array $projectCache;
  97.     public function __construct(
  98.         EntityManagerInterface $manager,
  99.         AisDate $aisDate,
  100.         TranslatorInterface $translator,
  101.         ReferenceSerialize $referenceSerialize,
  102.         EntityHydratorValidator $entityHydratorValidator,
  103.         TimesheetReaderInterface $timesheetReader,
  104.         TimesheetWriterInterface $timesheetWriter,
  105.         Security $security,
  106.         TimesheetHistoryInterface $timesheetHistory,
  107.         MetricContextFactory $metricContextFactory
  108.     )
  109.     {
  110.         parent::__construct($manager, $aisDate, $translator, $referenceSerialize, $security);
  111.         $this->referenceSerialize = $referenceSerialize;
  112.         $this->entityHydratorValidator = $entityHydratorValidator;
  113.         $this->timesheetReader = $timesheetReader;
  114.         $this->timesheetWriter = $timesheetWriter;
  115.         $this->timesheetHistory = $timesheetHistory;
  118.         $this->metricContextFactory = $metricContextFactory;
  120.         // Initialize
  121.         $this->orderCache     = [];
  122.         $this->projectCache   = [];
  123.     }
  125.     public function fetchTimesheetEmployees(int $y): array
  126.     {
  128.         $employees = $this->manager->getRepository(WorkerTimesheet::class)->findBy(["year" => $y]);
  130.         return $employees;
  132.     }
  134.     /**
  135.      *
  136.      *
  137.      * Senaryolar:
  138.      *
  139.      * Durum    domainExistsInPrev    timeChanged    isChanged    Comment?
  140.      * İlk kez saat giriliyor    false    —    false    Hayır ✓
  141.      * Aynı domain, aynı saat    true    false    false    Hayır ✓
  142.      * Aynı domain, farklı saat    true    true    true    Evet ✓
  143.      * Farklı domain, aynı gün    false    true    false    Hayır ✓ (BUG FIX)
  144.      * @return array{m: string|int, dataset: array}
  145.      *@throws \Exception
  146.      */
  147.     public function findByPayload(?array $activityIds = null): array
  148.     {
  149.         $monthData = $this->params->get('month');
  150.         $yearData = $this->params->get('year');
  153.         $projectId = filter_var($this->params->get('project'), FILTER_VALIDATE_INT);;
  154.         $orderId = filter_var($this->params->get('order'), FILTER_VALIDATE_INT);
  155.         $branchId = filter_var($this->params->get('branch'), FILTER_VALIDATE_INT);
  157.         if(!is_null($monthData) && !is_null($yearData)){
  158.             $monthData = $this->entityHydratorValidator->createInputBag($monthData);
  159.             $yearData = $this->entityHydratorValidator->createInputBag($yearData);
  160.             $m = $monthData->get('displayId');
  161.             $y = $yearData->get('displayId');
  162.         }
  163.         else {
  164.             $today = new \DateTimeImmutable('now');
  165.             $m = $today->format('m');
  166.             $y = $today->format('Y');
  167.         }
  171.         // WICHTIG: Falls Spaltennamen keine führende Null haben (m2 statt m02)
  172.         $searchMonth = (int)$m;
  174.         /**@var $repo WorkerTimesheetRepository*/
  175.         $repo = $this->manager->getRepository(WorkerTimesheet::class);
  176.         // $collection = $repo->findByDateYearAndMonth($y, $m);
  177.         $collection = $repo->findByPeriodAndDomain($y, $m, $projectId, $activityIds);
  179.         $timesheetStatuses = new ArrayCollection($this->manager->getRepository(TimesheetStatus::class)->findAll());
  180.         $finalResults = [];
  182.         foreach ($collection as $index => $row) {
  184.             // Regex angepasst: ^m2_d... (ohne führende Null bei Bedarf)
  185.             $daysOnly = array_filter($row, function($key) use ($searchMonth) {
  186.                 return preg_match("/^m{$searchMonth}_d\d+$/", $key);
  187.             }, ARRAY_FILTER_USE_KEY);
  189.             $processedDays = [];
  190.             $totalActive = 0;
  191.             $totalInactive = 0;
  192.             $revisedDays = [];
  194.             foreach ($daysOnly as $dayKey => $dayData) {
  196.                 if(!is_null($row['timesheet_revisions']) && array_key_exists($dayKey, $row['timesheet_revisions'])){
  197.                     $revisedDays[] = $dayKey;
  198.                 }
  200.                 if(is_null($dayData)) continue;
  202.                 // Falls Doctrine kein auto-decode macht:
  203.                 if (is_string($dayData)) {
  204.                     $dayData = json_decode($dayData, true);
  205.                 }
  207.                 if (empty($dayData)) {
  208.                     // $processedDays[$dayKey] = ['absenceShortKey' => null, 'time' => 0, 'dayInfo' => []];
  209.                     continue;
  210.                 }
  212.                 $time = 0;
  213.                 $shortKey = $dayData['absenceShortKey'] ?? '';
  215.                 if ($shortKey === 'P') {
  216.                     foreach ($dayData['projects'] as $project) {
  218.                         // DÜZELTME: Sadece bir proje filtresi VARSA ve uyuşmuyorsa atla.
  219.                         // Eğer $projectId null ise bu if'e hiç girmez ve hesaplamaya devam eder.
  220.                         if ($projectId && $project['project'] !== $projectId) {
  221.                             continue;
  222.                         }
  223.                         if (!$orderId) {
  224.                             // Eğer spesifik bir sipariş (order) seçilmediyse, projenin tüm saatlerini ekle
  225.                             $time += array_sum(array_values($project['orders_total']) ?? []);
  226.                         } else {
  227.                             // Sipariş filtresi varsa kontrol et
  228.                             if (isset($project['orders_total'][$orderId])) {
  230.                                 if (!$branchId) {
  231.                                     // Şube seçilmediyse siparişin toplamını ekle
  232.                                     $time += $project['orders_total'][$orderId];
  233.                                 } else {
  234.                                     // Şube seçildiyse derinlere in
  235.                                     foreach ($project['roles'] as $role) {
  236.                                         if (isset($role['orders'][$orderId]['branches'][$branchId])) {
  237.                                             $time += $role['orders'][$orderId]['branches'][$branchId]['time'];
  238.                                         }
  239.                                     }
  240.                                 }
  241.                             }
  242.                         }
  243.                     }
  244.                     $totalActive += $time;
  245.                 } elseif (in_array($shortKey, ['S', 'H'])) {
  246.                     // Falls 'time' im JSON als String vorliegt (z.B. "8.0"), floatval nutzen
  247.                     $time = floatval($dayData['info']['time'] ?? 0);
  248.                     $totalInactive += $time;
  249.                 }
  250.                 elseif (in_array($shortKey, ['HNP'])) {
  251.                     // Falls 'time' im JSON als String vorliegt (z.B. "8.0"), floatval nutzen
  252.                     $time = floatval( 0);
  253.                 }
  255.                 $criteria = Criteria::create()->where(
  256.                     Criteria::expr()->eq("absence_short_key", $shortKey)
  257.                 )->setMaxResults(1);
  259.                 $colorsetEntity = $timesheetStatuses->matching($criteria)->first();
  260.                 $colorset = $this->referenceSerialize->setEntity($colorsetEntity)->setGroups([
  261.                     "timsheet_status@base"
  262.                 ])->render();
  264.                 // $totalActive += $time;
  266.                 $projectsLength = 0;
  267.                 if(array_key_exists('projects', $dayData)){
  268.                     $projectsLength = count($dayData['projects']);
  269.                 }
  271.                 $processedDays[$dayKey] = [
  272.                     'absenceShortKey' => $shortKey,
  273.                     'time' => $time,
  274.                     'dayInfo' => $dayData,
  275.                     'colorset' => $colorset,
  276.                     'projectsLength' => $projectsLength
  277.                 ];
  281.             }
  283.             // 2. KRİTİK NOKTA: Orijinal satırdan (row) işlediğimiz gün kolonlarını çıkartıyoruz
  284.             // Böylece row içinde sadece ID, Worker Name gibi sabit veriler kalıyor.
  285.             $cleanRow = array_diff_key($row, $daysOnly);
  288.             // 3. Sabit veriler ile senin yeni oluşturduğun 'days' ve 'totalMonthTime'ı birleştir
  289.             $finalResults[] = array_merge($cleanRow, [
  290.                 'days' => $processedDays,
  291.                 'totalActive' => $totalActive, // array_sum($totalActive),
  292.                 'totalInactive' => $totalInactive,
  293.                 'finalTotal' => abs($totalInactive) + abs($totalActive),
  294.                 'revisedDays' => $revisedDays,
  295.                 'period' => ["month" => $m, "year" => $y]
  296.             ]);
  298.         }
  300.         #dd();
  302.         #dd($m);
  303.         #dd($finalResults);
  304.         return [
  305.             "m" => $m,
  306.             "dataset" => $finalResults
  307.         ];
  308.     }
  310.     /**
  311.      * Belirtilen tarih aralığına göre timesheet kolonlarını dinamik olarak oluşturur
  312.      * ve sadece ilgili yıl/ay/gün aralığına ait verileri sorgulamak için kullanılır.
  313.      */
  314.     public function findByDateRange() {
  316.         $fromAt = $this->params->get('from_at') ? new \DateTime($this->params->get('from_at')) : null;
  317.         $toAt   = $this->params->get('to_at') ? new \DateTime($this->params->get('to_at')) : null;
  319.         $dateRange = null;
  320.         $fromYear = $toYear = $fromMonth = $toMonth = $fromDay = $toDay = null;
  322.         if ($fromAt && $toAt) {
  323.             $dateRange = [
  324.                 "from" => $fromAt->format('d.m.Y'),
  325.                 "to"   => $toAt->format('d.m.Y'),
  326.                 "diff" => $fromAt->diff($toAt)->days + 1,
  327.             ];
  329.             $fromYear  = (int) $fromAt->format('Y');
  330.             $toYear    = (int) $toAt->format('Y');
  331.             $fromMonth = (int) $fromAt->format('n');
  332.             $toMonth   = (int) $toAt->format('n');
  333.             $fromDay   = (int) $fromAt->format('j');
  334.             $toDay     = (int) $toAt->format('j');
  335.         }
  337.         $availableCols = [];
  339.         $buildAllColumns = function (): array {
  340.             $cols = [];
  341.             for ($m = 1; $m <= 12; $m++) {
  342.                 for ($d = 1; $d <= 31; $d++) {
  343.                     $cols[] = "ts.m{$m}_d{$d}";
  344.                 }
  345.             }
  346.             return $cols;
  347.         };
  349.         if ($fromYear && $toYear) {
  351.             // farklı yıl → full scan
  352.             if ($fromYear !== $toYear) {
  353.                 $availableCols = $buildAllColumns();
  354.             } else {
  355.                 // aynı yıl
  356.                 for ($m = $fromMonth; $m <= $toMonth; $m++) {
  358.                     $startDay = ($m === $fromMonth) ? $fromDay : 1;
  359.                     $endDay   = ($m === $toMonth) ? $toDay : 31;
  361.                     for ($d = $startDay; $d <= $endDay; $d++) {
  362.                         $availableCols[] = "ts.m{$m}_d{$d}";
  363.                     }
  364.                 }
  365.             }
  366.         } else {
  367.             // fallback: full scan
  368.             $availableCols = $buildAllColumns();
  369.         }
  372.         $tss = $this->manager
  373.             ->getRepository(WorkerTimesheet::class)
  374.             ->findByDateRange($fromYear, $toYear, $availableCols);
  376.         return [
  377.             "collection" => $tss,
  378.             "date_range" => $dateRange
  379.         ];
  380.     }
  382.     public function unregisteredEmployees(): array {
  384.         $periodBag = $this->entityHydratorValidator->createInputBag($this->params->get('period'));
  385.         $domainBag = $this->entityHydratorValidator->createInputBag($this->params->get('domain'));
  387.         // Senaryo 2: Domain'de proje seçiliyse o projeye bağlı olmayanları getir
  388.         $projectId = null;
  389.         if ($domainBag && !empty($domainBag->get('project')->id)) {
  390.             $projectId = (int) $domainBag->get('project')->id;
  391.         }
  393.         /**@var $repo WorkerTimesheetRepository*/
  394.         $repo = $this->manager->getRepository(WorkerTimesheet::class);
  395.         $dataset = [];
  396.         if (!empty($periodBag->get('year')->displayId)) {
  397.             $dataset = $repo->findUnregisteredEmployees($periodBag->get('year')->displayId, $projectId);
  398.         }
  399.         $m = (new \DateTimeImmutable('now'))->format('m');
  400.         if (!empty($periodBag->get('month')->displayId)) {
  401.             $m = $periodBag->get('month')->displayId;
  402.         }
  403.         return [
  404.             "m" => $m,
  405.             'dataset' => $dataset
  406.         ];
  408.     }
  410.     /**
  411.      *
  412.      * @return array{m: string, dataset: ArrayCollection<WorkerTimesheet>}
  413.     */
  414.     public function syncRegisterEmployees(): array {
  417.         $employees      = $this->params->get('employees');
  418.         $projectId      = $this->params->get('project');
  420.         $employeesBag   = $this->entityHydratorValidator->createInputBag($employees);
  421.         $periodBag      = $this->entityHydratorValidator->createInputBag($this->params->get('period'));
  422.         if (!empty($periodBag->get('year')->displayId)) {
  423.             $y              = $periodBag->get('year')->displayId;
  424.         }
  425.         if (!empty($periodBag->get('month')->displayId)) {
  426.             $m              = $periodBag->get('month')->displayId;
  427.         }
  429.         if($projectId){
  430.             $projectEntity  = $this->manager->getRepository(Projects::class)->find($projectId);
  431.             $stakeholders   = $projectEntity->getStakeholders();
  432.         }
  434.         $collection     = new ArrayCollection([]);
  436.         if(!$employeesBag->count()){
  437.             $this->setCreateException(HttpStatusInterface::UNAUTHORIZED, $this->translator->trans('No any employee'));
  438.         }
  440.         foreach ($employeesBag as $employeeBag) {
  443.             $employeeActivity = $this->manager->getRepository(WorkerActivities::class)->find($employeeBag->id);
  445.             // SECTION Timesheet exists
  446.             $criteria = Criteria::create()->where(Criteria::expr()->eq('year', $y))->setMaxResults(1);
  447.             $timesheet = $employeeActivity->getWorkerTimesheets()->matching($criteria)->first();
  448.             if(!$timesheet){
  449.                 $timesheet = new WorkerTimesheet();
  450.                 $timesheet->setYear($y)->setCreatedAt(new \DateTimeImmutable('now'));
  451.                 $employeeActivity->addWorkerTimesheet($timesheet);
  452.             }
  454.             $collection->add($employeeActivity);
  456.             if(!$projectId){
  457.                 continue;
  458.             }
  460.             $partner = $employeeActivity->getPartner();
  461.             $employeeStartAt = new \DateTimeImmutable($employeeBag->employee_beginn_to_project);
  463.             // SECTION Stakeholder exits
  464.             $criteria = Criteria::create()
  465.                 ->where(Criteria::expr()->eq('partner', $partner))
  466.                 ->andWhere(Criteria::expr()->eq('project', $projectEntity))
  467.                 ->andWhere(Criteria::expr()->eq('end_at', null))
  468.                 ->setMaxResults(1);
  470.             $stakeholder = $stakeholders->matching($criteria)->first();
  471.             #dd($employeeBag);
  472.             if(!$stakeholder){
  474.                 $partnerStartAt = new \DateTimeImmutable($employeeBag->partner_beginn_to_project);
  476.                 $stakeholder = new ProjectStakeholders();
  477.                 $stakeholder
  478.                     ->setProject($projectEntity)
  479.                     ->setCreatedAt(new \DateTimeImmutable('now'))
  480.                     ->setPartner($partner);
  481.                 $projectEntity->addStakeholder($stakeholder);
  482.                 $stakeholder->setStartAt($partnerStartAt);
  483.                 $this->manager->persist($stakeholder); // 👈 BURASI KRİTİK: Yeni nesneyi Doctrine'e tanıt
  484.             }
  486.             // SECTION Employee exits
  487.             $criteria = Criteria::create()
  488.                 ->where(Criteria::expr()->eq('worker_activity', $employeeActivity))
  489.                 ->andWhere(Criteria::expr()->eq('project', $stakeholder))
  490.                 ->andWhere(Criteria::expr()->eq('end_at', null))
  491.                 ->setMaxResults(1);
  492.             $wip = $stakeholder->getWorkerInProjects()->matching($criteria)->first();
  493.             if(!$wip){
  494.                 // Any Case Create New WIP
  495.                 $wip = new WorkerInProject();
  496.                 $wip
  497.                     ->setCreatedAt(new \DateTimeImmutable('now'))
  498.                     ->setWorkerActivity($employeeActivity)
  499.                     ->setCostPerHour($employeeActivity->getHourlyRate());
  500.                     $stakeholder->addWorkerInProject($wip);
  501.                     $wip->setStartAt($employeeStartAt);
  502.                     $this->manager->persist($wip);
  503.             }
  504.         }
  506.         try{
  507.             $this->manager->flush();
  508.         } catch (\Exception $exception){
  509.             // throw new \Exception($exception->getMessage());
  510.             $this->setCreateException($exception->getCode(), $exception->getMessage());
  511.         }
  513.         return [
  514.             "m" => $m,
  515.             'dataset' => $collection
  516.         ];
  518.     }
  521.     /**
  522.      * @return ArrayCollection
  523.      * @throws \Exception
  524.      */
  525.     /**
  526.      * TODO #88 — Gün-toplam 10 saat cap kontrolü (kod yazmadan reddet).
  527.      * Batch'teki HER (çalışan, gün) P girişi için: [o günün mevcut DİĞER domain P-toplamı]
  528.      * + [gelen saat] > 10 ise hata listesine ekler. Yalnız P; S/H/HNP/R kapsam dışı.
  529.      * Transaction'dan ÖNCE çağrılır → aşımda hiç yazım olmaz.
  530.      * @return string[] boş ise sınır aşımı yok
  531.      */
  532.     /**
  533.      * Gün alanının (m{ay}_d{gün}) ISO haftagünü: 1=Pazartesi .. 7=Pazar.
  534.      * Alan/yıl çözülemezse null döner — çağıran taraf güvenli davranışa düşer.
  535.      */
  536.     private function weekdayForField(?string $field, $year): ?int
  537.     {
  538.         if(!$field || !$year || !preg_match('/^m(\d+)_d(\d+)$/', $field, $matches)){
  539.             return null;
  540.         }
  542.         $month = (int)$matches[1];
  543.         $day   = (int)$matches[2];
  545.         if(!checkdate($month, $day, (int)$year)){
  546.             return null;
  547.         }
  549.         return (int)date('N', strtotime(sprintf('%04d-%02d-%02d', (int)$year, $month, $day)));
  550.     }
  552.     /**
  553.      * Gün alanına göre o günün çalışma tavanı: Cumartesi 6, diğer günler 10.
  554.      * Çözülemezse güvenli tarafta kalınır (genel tavan uygulanır).
  555.      * NOT: Pazar burada 10 döner ama Pazar'a yazım zaten mutlak yasaktır (assertDailyHourCap
  556.      * tavan hesabından önce reddeder) — tavan meselesi değildir.
  557.      */
  558.     private function dailyCapForField(?string $field, $year): float
  559.     {
  560.         return ($this->weekdayForField($field, $year) === 6)
  561.             ? self::MAX_SATURDAY_WORK_HOURS
  562.             : self::MAX_DAILY_WORK_HOURS;
  563.     }
  565.     private function assertDailyHourCap($attendances, ?InputBag $domain, ?InputBag $period): array
  566.     {
  567.         $errors = [];
  569.         $year = ($period && !empty($period->get('year')->displayId)) ? $period->get('year')->displayId : null;
  570.         $domainOrderId  = ($domain && !empty($domain->get('order')->id)) ? $domain->get('order')->id : null;
  571.         $domainBranchId = ($domain && !empty($domain->get('branch')->id)) ? $domain->get('branch')->id : null;
  573.         $tsCache = [];
  575.         foreach($attendances as $attendanceRaw){
  577.             $bag = $this->entityHydratorValidator->createInputBag($attendanceRaw);
  579.             // Yalnız P (çalışma) saati sınırlanır; status günleri (S/H/HNP) ve reset (R) kapsam dışı.
  580.             if($bag->get('nextAbsence') !== ABSENCE_PRESENT){
  581.                 continue;
  582.             }
  584.             $incoming   = floatval($bag->get('time'));
  585.             $employeeId = !empty($bag->get('employee')->id) ? $bag->get('employee')->id : null;
  586.             $field      = $attendanceRaw->field ?? null; // m{month}_d{day}
  587.             if(!$employeeId || !$field){
  588.                 continue;
  589.             }
  591.             // Çalışanın yıl timesheet'i (cache'li)
  592.             $cacheKey = $employeeId . '_' . $year;
  593.             if(!array_key_exists($cacheKey, $tsCache)){
  594.                 $activity = $this->manager->getRepository(WorkerActivities::class)->find($employeeId);
  595.                 $ts = $activity
  596.                     ? $this->manager->getRepository(WorkerTimesheet::class)->findOneBy(['worker_activity' => $activity, 'year' => $year])
  597.                     : null;
  598.                 $tsCache[$cacheKey] = [
  599.                     'ts'   => $ts,
  600.                     'name' => $activity ? $activity->getWorker()->getFullName() : ('#' . $employeeId)
  601.                 ];
  602.             }
  603.             $ts = $tsCache[$cacheKey]['ts'];
  605.             // PAZAR: çalışma saati yazımı MUTLAK YASAK (kullanıcı kararı 2026-07-29).
  606.             // Tavan meselesi değil — kaç saat olursa olsun reddedilir, bu yüzden saat
  607.             // hesabından ÖNCE bakılır. Yalnız P kapsamda; statü günleri (S/H/HNP) etkilenmez.
  608.             if($this->weekdayForField($field, $year) === 7){
  609.                 $dayLabel = str_replace(['m', '_d'], ['', '.'], $field); // m7_d19 → 7.19
  610.                 $errors[] = $tsCache[$cacheKey]['name'] . ' (' . $dayLabel . '): '
  611.                     . $this->translator->trans('working hours cannot be entered on Sunday');
  612.                 continue;
  613.             }
  615.             // Mevcut gün-JSON'u (varsa)
  616.             $existingDayData = [];
  617.             if($ts){
  618.                 $getter = 'get' . strtoupper(preg_replace('/_/', '', $field));
  619.                 if(method_exists($ts, $getter)){
  620.                     $existingDayData = $ts->{$getter}() ?? [];
  621.                     if(is_string($existingDayData)){
  622.                         $existingDayData = json_decode($existingDayData, true) ?? [];
  623.                     }
  624.                 }
  625.             }
  627.             // Bu domain'in eski leaf'i EZİLECEK → toplamdan düşülür, sonra gelen saat eklenir.
  628.             $existingOther = $this->sumDayPresentTime($existingDayData, $domainOrderId, $domainBranchId);
  629.             $projected     = $existingOther + $incoming;
  631.             // Tavan güne göre değişir: Cumartesi 6, diğer günler 10.
  632.             $dailyCap = $this->dailyCapForField($field, $year);
  634.             if($projected > $dailyCap){
  635.                 $dayLabel = str_replace(['m', '_d'], ['', '.'], $field); // m5_d12 → 5.12
  636.                 $errors[] = $tsCache[$cacheKey]['name'] . ' (' . $dayLabel . '): '
  637.                     . rtrim(rtrim(number_format($projected, 1, '.', ''), '0'), '.') . 'h'
  638.                     . ' / max ' . rtrim(rtrim(number_format($dailyCap, 1, '.', ''), '0'), '.') . 'h';
  639.             }
  640.         }
  642.         return $errors;
  643.     }
  645.     /**
  646.      * Bir gün-JSON'undaki toplam P (çalışma) saatini döner. $excludeOrderId+$excludeBranchId
  647.      * verilirse o domain'in leaf'i toplamdan düşülür (upsert onu ezeceği için).
  648.      */
  649.     private function sumDayPresentTime(?array $dayData, ?int $excludeOrderId, ?int $excludeBranchId): float
  650.     {
  651.         if(empty($dayData) || ($dayData['absenceShortKey'] ?? '') !== 'P' || empty($dayData['projects'])){
  652.             return 0.0;
  653.         }
  655.         $sum = 0.0;
  656.         foreach($dayData['projects'] as $project){
  657.             foreach(($project['orders_total'] ?? []) as $orderTotal){
  658.                 $sum += floatval($orderTotal);
  659.             }
  660.         }
  662.         // Ezilecek domain leaf'ini çıkar (sadece ilgili order+branch)
  663.         if($excludeOrderId && $excludeBranchId){
  664.             foreach($dayData['projects'] as $project){
  665.                 foreach(($project['roles'] ?? []) as $role){
  666.                     if(isset($role['orders'][$excludeOrderId]['branches'][$excludeBranchId]['time'])){
  667.                         $sum -= floatval($role['orders'][$excludeOrderId]['branches'][$excludeBranchId]['time']);
  668.                     }
  669.                 }
  670.             }
  671.         }
  673.         return $sum;
  674.     }
  676.     public function upsert(): ?ArrayCollection
  677.     {
  679.         /**
  680.          * Bu kisim karisik
  681.          * User role sunu deme kiyirou bu islem yapabilme seviyesi var yani
  682.          * bu oslemi yapbilenler
  683.          * System level seviyesi en dusuk
  684.          * App Users Bu orta seviye systemi ezer
  685.          * Desktop users Bu güclu seviye App I ezer
  686.          * TODO Burasi yenilanacak!!! Yani Level e cevrilecek user_access_roles table var o table adu user_levels olmali ve colonlari user_id ✅ access_role_id => access_module olmali
  687.          * !!! Important user islem yapbilmesi icin tanimlanmis olmali
  688.          * SECTION UserRole ℹ️ User User Role Level!!!
  689.          * @var $userRole AccessRoles
  690.          */
  691.         $userRole =$this->security->getUser()->getUserAccessedRoles()->filter(function(/**@var $item AccessRoles*/$item){
  692.             return $item->getAccessType()->getName() === 'Timesheet';
  693.         })->first();
  696.         if(!$userRole){
  697.             $this->setCreateException(HttpStatusInterface::UNAUTHORIZED, $this->translator->trans("Required access level for user, not defined!") );
  698.             return null;
  699.         }
  701.         // SECTION * Timesheet Status All
  702.         $timesheetStatus            = new ArrayCollection($this->manager->getRepository(TimesheetStatus::class)->findAll());
  705.         // SECTION Safety Guard!!!
  706.         if(!$this->userUpsertAccess($userRole, $timesheetStatus)){
  707.             return null;
  708.         }
  712.         $successItems               = new ArrayCollection([]);
  713.         $errorItems                 = new ArrayCollection([]);
  715.         $attendances = $this->entityHydratorValidator->createInputBag($this->params->get('collection'));
  716.         $domain = $this->entityHydratorValidator->createInputBag($this->params->get('domain'));
  717.         $period = $this->entityHydratorValidator->createInputBag($this->params->get('period'));
  719.         #dd($domain, $period, $attendances);
  721.         // SECTION 10-Stunden-Cap (TODO #88) — GERÇEK GATE.
  722.         // Batch'teki herhangi bir (çalışan, gün) için P toplamı 10'u aşıyorsa HİÇBİR ŞEY yazma.
  723.         // Transaction'dan ÖNCE çalışır → aşımda hiçbir kayıt oluşmaz, mevcut rollback'siz-return
  724.         // latent bug'ına da bulaşmaz (batch atomik reddedilir, 406 döner).
  725.         $capErrors = $this->assertDailyHourCap($attendances, $domain, $period);
  726.         if(count($capErrors)){
  727.             $this->setCreateException(
  728.                 Response::HTTP_UNPROCESSABLE_ENTITY,
  729.                 // Başlıkta sabit sayı YOK: tavan güne göre değişiyor (hafta içi 10, Cumartesi 6)
  730.                 // ve Pazar'da mutlak yasak var. Hangi satırın neden reddedildiği listede yazıyor.
  731.                 $this->translator->trans('Daily working hour limit exceeded') . ' — ' . implode(' · ', $capErrors)
  732.             );
  733.             return null;
  734.         }
  736.         $this->manager->beginTransaction();
  740.         // SECTION Period Parsed
  741.         $month  = !empty($period->get('month')->displayId) ? $period->get('month')->displayId : null;
  742.         $year   = !empty($period->get('month')->displayId) ? $period->get('month')->displayId : null;
  744.         // Revision Section
  745.         $employeeCachedHistoryEntities = [];
  748.         // SECTION Entity Resolver's
  749.         $project            = null;
  750.         $projectOrders      = new ArrayCollection([]);
  751.         $projectBranches    = new ArrayCollection([]);
  752.         if($domain && $domain->get('project')){
  753.             $projectId          = $domain->get('project')->id;
  754.             $project            = $this->manager->getRepository(Projects::class)->find($projectId);
  755.             $projectOrders      = $project->getProjectOrders();
  756.             $projectBranches    = $project->getBranches();
  757.         }
  759.         // SECTION Entities
  760.         // * Timesheet
  761.         $all_timesheet              = new ArrayCollection($this->manager->getRepository(WorkerTimesheet::class)->findAll());
  764.         // SECTION Cashed Employee Activities
  765.         $cachedWorkerActivities     = new ArrayCollection();
  767.         // SECTION Loop Attendances
  768.         foreach ($attendances as $attendanceRaw) {
  770.             $localError = false;
  772.             $attendanceBag = $this->entityHydratorValidator->createInputBag($attendanceRaw);
  774.             // SECTION Prepare Setter & Getter
  775.             $property = $attendanceRaw->field;
  776.             $property = preg_replace('/_/', '', $property);
  777.             $getterMethod = 'get' . strtoupper($property);
  778.             $setterMethod = 'set' . strtoupper($property);
  781.             // SECTION Prepare & Cache Employee Entity [R]
  782.             $employeeActivityId     = !empty($attendanceBag->get('employee')->id) ? $attendanceBag->get('employee')->id : null;
  783.             $employeeActivityEntity = $cachedWorkerActivities->filter(fn($item) => $item->getId() === $employeeActivityId )->first();
  784.             if(!$employeeActivityEntity){
  785.                 $employeeActivityEntity = $this->manager->getRepository(WorkerActivities::class)->find($employeeActivityId);
  786.                 $cachedWorkerActivities->add($employeeActivityEntity);
  787.             }
  789.             // SECTION Timesheet FILTER Query
  790.             $tsC = Criteria::create()
  791.                 ->where(Criteria::expr()->eq('year', !empty($period->get('year')->displayId) ? $period->get('year')->displayId : null ))
  792.                 ->andWhere(Criteria::expr()->eq('worker_activity', $employeeActivityEntity ))
  793.                 ->setMaxResults(1);
  795.             // SECTION [R, C] Timesheet Entity
  796.             $timesheet = $all_timesheet->matching($tsC)->first();
  797.             if(!$timesheet){
  798.                 $timesheet = new WorkerTimesheet();
  799.                 $timesheet
  800.                     ->setCreatedAt(new \DateTimeImmutable('now'))
  801.                     ->setWorkerActivity($employeeActivityEntity);
  802.                 $this->manager->persist($timesheet);
  803.             }
  805.             // Day Getter
  806.             $dayData = $timesheet->{$getterMethod}() ?? [];
  808.             // SECTION GET Attendance
  809.             $nextAbsence    = $attendanceBag->get('nextAbsence');
  811.             // WARNING If Clean not more need another process!!!
  812.             /**
  813.              * This process like reset but not more comment need, just clean this day
  814.             */
  815.             if($nextAbsence === ABSENCE_PRISTINE){
  816.                 $timesheet->{$setterMethod}([]);
  817.                 $this->manager->persist($timesheet);
  818.                 continue;
  819.             }
  821.             // SECTION WorkerInProject [R]
  822.             $wip = null;
  823.             $branch = null;
  824.             $order = null;
  825.             if( $project ){
  827.                 $wip = $employeeActivityEntity->getWorkerInProjects()->filter(function (/**@var WorkerInProject $wip*/ $wip ) use ($project){
  828.                     return $wip->getProject()->getProject()->getId()
  829.                         === $project->getId();
  830.                 })->first();
  832.                 // SECTION FILTER ORDER
  833.                 $domainOrderId  = !empty($domain->get('order')->id) ? $domain->get('order')->id : null;
  834.                 $oC             = Criteria::create()->where(Criteria::expr()->eq('id', $domainOrderId))->setMaxResults(1);
  835.                 $order          = $projectOrders->matching($oC) ? $projectOrders->matching($oC)->first() : null;
  837.                 // SECTION FILTER BRANCH
  838.                 $domainBranchId = !empty($domain->get('branch')->id) ? $domain->get('branch')->id : null;
  839.                 $bC             = Criteria::create()->where(Criteria::expr()->eq('id', $domainBranchId))->setMaxResults(1);
  840.                 $branch         = $projectBranches->matching($bC) ? $projectBranches->matching($bC)->first() : null;
  842.                 // WARNING Bu islemi neden yapiyorum ?? ( Add This worker to Order as assign if already not assigned )
  843.                 if( $nextAbsence === ABSENCE_PRESENT ) {
  844.                     // TODO ? Employee already Assigned to this order (Employee work for this order) -> Assignation (Using Target ??)
  845.                     $aOC = Criteria::create()->where(Criteria::expr()->eq('id', $order));
  846.                     $isAssigned = $employeeActivityEntity->getAssignedOrders()->matching($aOC)->first();
  847.                     if(!$isAssigned){
  848.                         $employeeActivityEntity->addAssignedOrder($order);
  849.                     }
  850.                 }
  851.             }
  853.             // SECTION TimesheetStatus
  854.             $tssC = Criteria::create()->where(Criteria::expr()->eq('absence_short_key', $nextAbsence))->setMaxResults(1);
  855.             $tss  = $timesheetStatus->matching($tssC)->first();
  857.             // SECTION Errors
  858.             if(!$employeeActivityEntity->getHourlyRate()){
  859.                 $localError = true;
  860.                 $errorItems->add($this->translator->trans("Missing hourly rate for") . " " . $employeeActivityEntity->getWorker()->getFullName());
  861.             }
  862.             if(!$employeeActivityEntity->getDailyWorkingHours()){
  863.                 $localError = true;
  864.                 $errorItems->add($this->translator->trans("Missing daily working hours for") . " " . $employeeActivityEntity->getWorker()->getFullName());
  865.             }
  866.             if($nextAbsence === ABSENCE_PRESENT && (!$project || !$wip)){
  867.                 $this->setCreateException(
  868.                     Response::HTTP_UNPROCESSABLE_ENTITY,
  869.                     $employeeActivityEntity->getWorker()->getFullName() . " " . $this->translator->trans("cannot write P: activity is not linked to a project")
  870.                 );
  871.                 return null;
  872.             }
  874.             if(!$localError){
  876.                 $this->timesheetWriter
  877.                     ->setWorkerActivity($employeeActivityEntity)
  878.                     ->setHourlyRate($employeeActivityEntity->getHourlyRate())
  879.                     ->setDailyWorkingHours($employeeActivityEntity->getDailyWorkingHours())
  880.                     ->setMonth($month)
  881.                     ->setUser( $this->security->getUser() )
  882.                     ->setManagerRole($userRole)
  883.                     ->setTimesheetStatus( $tss )
  884.                     // TODO ProjectStakeholder should replace with workerInProject project access over workerInProject
  885.                     ->writerPathManager( $wip, $branch, $order )
  886.                     ->setData( $dayData );
  888.                 $upsertDayData = null;
  889.                 // [P]
  890.                 if( $nextAbsence === ABSENCE_PRESENT ) {
  891.                     $time = $attendanceBag->get('time');
  892.                     // TODO Add Order to Cache if not exists
  893.                     $this->orderCache[$order->getId()] = $order;
  894.                     // $this->metricsOrderCollector($dayData);
  895.                     $upsertDayData = $this->timesheetWriter->addTime($time)->extendResultRolesBasic();
  896.                 }
  897.                 // [R]
  898.                 else if( $nextAbsence === ABSENCE_RESET ){
  899.                     // SECTION Order Collector
  900.                     $this->metricsOrderCollector($dayData);
  901.                     $upsertDayData = $this->timesheetWriter->reset()->extendResultRolesBasic();
  902.                 }
  903.                 // [S, H, HNP]
  904.                 else {
  905.                     // SECTION Order Collector
  906.                     $this->metricsOrderCollector($dayData);
  907.                     $upsertDayData = $this->timesheetWriter->updateStatus()->extendResultRolesBasic();
  908.                 }
  910.                 $timesheet->{$setterMethod}( $upsertDayData );
  911.                 $this->manager->persist( $timesheet );
  913.                 $successItems->add($timesheet);
  915.                 // SECTION History (Revision)
  916.                 $this->timesheetRevision(
  917.                     $attendanceBag,
  918.                     $tss,
  919.                     $employeeActivityEntity,
  920.                     $employeeCachedHistoryEntities,
  921.                     $timesheet,
  922.                     $project,
  923.                     $order,
  924.                     $branch
  925.                 );
  926.             }
  927.         }
  929.         if(count($errorItems)){
  930.             $this->setCreateException(HttpStatusInterface::UNAUTHORIZED, implode(" ", $errorItems->toArray()) );
  931.             return null;
  932.         }
  936.         // SECTION Metrics (super Step  )
  937.         /**@var ProjectOrders $order */
  938.         foreach ($this->orderCache as $order) {
  939.             $this->metricContextFactory->orderMetrics($order)->syncLaborMetrics();
  940.         }
  941.         foreach ($this->projectCache as $project ) {
  942.             $this->metricContextFactory->projectMetrics($project)->syncLaborMetrics();
  943.         }
  947.         #try{
  948.             $this->manager->commit();
  949.             $this->manager->flush();
  950.         #} catch (\Exception $exception){
  952.         #    $this->manager->rollback();
  953.         #    $this->setCreateException($exception->getCode(), $this->exception->getMessage());
  954.         #    return null;
  955.         #}
  958.         // Update Metrics
  959.         // $this->metricContextFactory->orderMetrics()
  961.         return $successItems;
  963.     }
  965.     private function metricsOrderCollector(?array $dayData) {
  967.         if(count($dayData)){
  968.             $jsonProjects = [];
  969.             if(array_key_exists('projects', $dayData)){
  970.                 $jsonProjects = $dayData['projects'];
  971.             }
  972.             foreach ($jsonProjects as $jsonProject) {
  973.                 // $minRole = min(array_column($project['roles'], 'role'));
  974.                 $roles = $jsonProject['roles'];
  975.                 $minRoleEntry = array_reduce($roles, fn($carry, $item) => ($carry === null || $item['role'] < $carry['role']) ? $item : $carry);
  976.                 $jsonOrderIds = array_keys($minRoleEntry['orders']);
  977.                 #dump($jsonOrderIds);
  978.                 foreach ($jsonOrderIds as $jsonOrderId ) {
  980.                     if(!isset($this->orderCache[$jsonOrderId])){
  981.                         /**@var ProjectOrders $_order*/
  982.                         $_order = $this->manager->getRepository(ProjectOrders::class)->find($jsonOrderId);
  983.                         $this->orderCache[$jsonOrderId] = $_order;
  984.                         // Add project
  985.                         $_project = $_order->getProject();
  986.                         if(!isset($this->projectCache[$_project->getId()])){
  987.                             $this->projectCache[$_project->getId()] = $_project;
  988.                         }
  989.                     }
  990. //                    $oc = Criteria::create()->where(Criteria::expr()->eq('id', $jsonOrderId))->setMaxResults(1);
  991. //                    $orderEntity = $this->orderFactory->matching($oc)->first();
  992. //                    if(!$orderEntity){
  993. //                        $orderReal = $this->manager->getRepository(ProjectOrders::class)->find($jsonOrderId);
  994. //                        $this->orderFactory->add($orderReal);
  995. //                    }
  996.                 }
  999.             }
  1001.         }
  1003.     }
  1005.     private function userUpsertAccess(?AccessRoles $userRole, ?ArrayCollection $timesheetStatusCollection): bool {
  1007.         if( !$this->security->getUser()->getName() && !$this->security->getUser()->getSurname() ){
  1008.             $this->setCreateException(
  1009.                 Response::HTTP_NOT_ACCEPTABLE,
  1010.                 $this->translator->trans('You cannot proceed with the transaction as your name or surname is not specified in your account.!')
  1011.             );
  1012.             return false;
  1013.         }
  1015.         if( !$userRole ){
  1016.             $this->setCreateException(
  1017.                 Response::HTTP_NOT_ACCEPTABLE,
  1018.                 $this->translator->trans('Access role required for this operation.')
  1019.             );
  1020.             return false;
  1021.         }
  1023.         if( !count($timesheetStatusCollection) ){
  1024.             $this->setCreateException(
  1025.                 Response::HTTP_NOT_ACCEPTABLE,
  1026.                 $this->translator->trans('This process cannot continue as no status has been found in the collection. Please manage the time tracking status before proceeding.')
  1027.             );
  1028.             return false;
  1029.         }
  1031.         return true;
  1032.     }
  1034.     private function timesheetRevision(
  1035.         InputBag $attendanceBag,
  1036.         TimesheetStatus $timesheetStatus,
  1037.         WorkerActivities $workerActivity,
  1038.         array &$cachedHistoryEntities,
  1039.         WorkerTimesheet $timesheet,
  1040.         ?Projects $project,
  1041.         ?ProjectOrders $projectOrder,
  1042.         ?Branches $branch
  1043.     ): void {
  1045.         $dayFiled = $attendanceBag->get('field');
  1046.         $reason = $attendanceBag->get('reason');
  1047.         $comment = $attendanceBag->get('comment');
  1048.         $prev = $attendanceBag->get('prevAbsence');
  1049.         $next = $attendanceBag->get('nextAbsence');
  1051.         // SECTION No Required History
  1052.         // "initial" = ilk kez yazılıyor, "similar" = aynı gün farklı domain (değişiklik yok) → history/comment gerekmez
  1053.         if($reason === "initial" || $reason === "similar"){
  1054.             return;
  1055.         }
  1057.         if(!$comment){
  1058.             $this->setCreateException(HttpStatusInterface::UNAUTHORIZED, "Comment required");
  1059.             return;
  1060.         }
  1062.         if( !array_key_exists($timesheet->getId(), $cachedHistoryEntities) ){
  1063.             $historyInstance = $timesheet->getWorkerTimesheetHistories();
  1064.             if(is_null($historyInstance)){
  1065.                 $historyInstance = new WorkerTimesheetHistories();
  1066.                 $historyInstance
  1067.                     ->setWorkerTimesheet($timesheet)
  1068.                     ->setCreatedAt(new \DateTimeImmutable('now'));
  1069.             }
  1070.             $cachedHistoryEntities[$timesheet->getId()] = $historyInstance;
  1071.         }
  1073.         $property = preg_replace('/_/', '', $dayFiled);
  1074.         $getterMethod = 'get' . strtoupper($property);
  1075.         $newDayLog = $attendanceBag;// $timesheet->{$getterMethod}();
  1077.         // Set History Entity into Interface
  1078.         $this->timesheetHistory->setCachedEmployeeHistoryEntity($cachedHistoryEntities[$timesheet->getId()]);
  1080.         // Init Interface with params
  1081.         $this->timesheetHistory->init( $timesheet, $timesheetStatus, $newDayLog, $dayFiled, $next, $project, $projectOrder, $branch);
  1083.         // upsert
  1084.         $this->timesheetHistory->upsert();
  1085.     }
  1087.     public function movement(): WorkerTimesheet {
  1089.         // TODO This process will create
  1090.         #$sourceEntity = $this->manager->getRepository(WorkerTimesheet::class)->find(1);
  1091.         #$targetEntity = $this->manager->getRepository(WorkerTimesheet::class)->find(1);
  1093.         #$sourceFields = ['m1_d1'];
  1094.         #$sourceFields = ['m1_d1'];
  1096.         #$property = $attendanceRaw->field;
  1097.         #$property = preg_replace('/_/', '', $property);
  1098.         #$getterMethod = 'get' . strtoupper($property);
  1099.         #$setterMethod = 'set' . strtoupper($property);
  1106.         return new WorkerTimesheet();
  1107.     }
  1109. }