src/Controller/Admin/Dashboard/DashboardController.php line 1451

Open in your IDE?
  1. <?php
  3. namespace App\Controller\Admin\Dashboard;
  5. use App\Dto\SellerDetailRequestDto;
  6. use App\Entity\Product;
  7. use App\Enum\ProductTypeEnum;
  8. use App\Entity\ProductsSold;
  9. use App\Entity\Sales;
  10. use App\Entity\StockInfo;
  11. use App\Entity\User;
  12. use App\Entity\Warehouse;
  13. use App\Repository\ProductRepository;
  14. use App\Repository\StockRepository;
  15. use App\Repository\ProductMonthlyStatsRepository;
  16. use App\Service\Analysis\FinancialForecastingService;
  17. use App\Services\Product\Impl\ProductServiceImpl;
  18. use App\Services\Sales\Impl\SalesProductsServiceImpl;
  19. use App\Services\Sales\Impl\SalesServiceImpl;
  20. use App\Services\Sales\SalesService;
  21. use App\Services\Stock\StockService;
  22. use App\Services\Stock\StockTransferService;
  23. use App\Services\User\UserService;
  24. use App\Services\Warehouse\Impl\WarehouseServiceImpl;
  25. use App\Utils\CurrencyHelper;
  26. use App\Utils\DateUtil;
  27. use App\Utils\Enums\DateZoneEnums;
  28. use App\Utils\Referer;
  29. use DateInterval;
  30. use DatePeriod;
  31. use Doctrine\Common\Collections\ArrayCollection;
  32. use Doctrine\ORM\EntityManagerInterface;
  33. use Knp\Bundle\PaginatorBundle\Pagination\SlidingPagination;
  34. use Knp\Component\Pager\PaginatorInterface;
  35. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  36. use Symfony\Component\HttpFoundation\JsonResponse;
  37. use Symfony\Component\HttpFoundation\Request;
  38. use Symfony\Component\HttpFoundation\Response;
  39. use Symfony\Component\Routing\Annotation\Route;
  40. use Symfony\Component\Routing\RouterInterface;
  41. use Symfony\Component\Validator\Constraints\DateTime;
  42. use function Doctrine\ORM\QueryBuilder;
  44. class DashboardController extends AbstractController
  45. {
  46.     use Referer;
  47.     private UserService $userService;
  48.     private StockService $stockService;
  49.     private SalesService $salesService;
  50.     private StockTransferService $stockTransferService;
  51.     private EntityManagerInterface $entityManager;
  52.     private StockRepository $stockRepository;
  53.     private SalesServiceImpl $salesServiceImpl;
  54.     private ProductServiceImpl $productServiceImpl;
  55.     private PaginatorInterface $paginator;
  56.     private WarehouseServiceImpl $warehouseService;
  57.     private SalesProductsServiceImpl $salesProductsServiceImpl;
  59.     /**
  60.      * @param UserService $userService
  61.      * @param StockService $stockService
  62.      * @param SalesService $salesService
  63.      * @param StockTransferService $stockTransferService
  64.      * @param EntityManagerInterface $entityManager
  65.      * @param StockRepository $stockRepository
  66.      * @param SalesServiceImpl $salesServiceImpl
  67.      * @param ProductServiceImpl $productServiceImpl
  68.      * @param PaginatorInterface $paginator
  69.      * @param WarehouseServiceImpl $warehouseService
  70.      * @param SalesProductsServiceImpl $salesProductsServiceImpl
  71.      */
  72.     public function __construct(UserService $userService, StockService $stockService, SalesService $salesService, StockTransferService $stockTransferService, EntityManagerInterface $entityManager, StockRepository $stockRepository, SalesServiceImpl $salesServiceImpl, ProductServiceImpl $productServiceImpl, PaginatorInterface $paginator, WarehouseServiceImpl $warehouseService, SalesProductsServiceImpl $salesProductsServiceImpl)
  73.     {
  75.         $this->userService = $userService;
  76.         $this->stockService = $stockService;
  77.         $this->salesService = $salesService;
  78.         $this->stockTransferService = $stockTransferService;
  79.         $this->entityManager = $entityManager;
  80.         $this->stockRepository = $stockRepository;
  81.         $this->salesServiceImpl = $salesServiceImpl;
  82.         $this->productServiceImpl = $productServiceImpl;
  83.         $this->paginator = $paginator;
  84.         $this->warehouseService = $warehouseService;
  85.         $this->salesProductsServiceImpl = $salesProductsServiceImpl;
  86.     }
  89.     public function getProfitByPeriots(DateZoneEnums $dateZoneEnums, $year = null)
  90.     {
  91.         if ($year == null) {
  92.             $year = date('Y');
  93.         }
  94.         $salesRepo = $this->entityManager->getRepository(Sales::class);
  95.         if ($dateZoneEnums->value == 'monthly') {
  96.             $time = new \DateTimeImmutable('1 month ago');
  97.             $endTime = new \DateTimeImmutable('now');
  98.         }
  99.         if ($dateZoneEnums->value == 'weekly') {
  100.             $time = new \DateTimeImmutable('1 week ago');
  101.             $endTime = new \DateTimeImmutable('now');
  102.         }
  103.         if ($dateZoneEnums->value == 'yearly') {
  104.             $time = new \DateTimeImmutable('first day of January ' . $year);
  105.             $endTime = new \DateTimeImmutable('last day of December ' . $year . ' 23:59:59');
  106.         }
  108.         $qb = $salesRepo->createQueryBuilder('s')
  109.             ->leftJoin('s.productsSolds', 'productsSolds')
  110.             ->where('s.salesDate >= :time')
  111.             ->andWhere('s.salesDate <= :endTime')
  112.             ->setParameter('time', $time)
  113.             ->setParameter('endTime', $endTime);
  115.         if (!$this->canCurrentUserSeeHiddenSales()) {
  116.             $qb->andWhere('s.visible = :visible')
  117.                 ->setParameter('visible', true);
  118.         }
  120.         $sales = $qb->getQuery()->getResult();
  122.         $totalProfit = 0.00;
  123.         foreach ($sales as $sale) {
  124.             foreach ($sale->getProductsSolds() as $productsSold) {
  125.                 $totalProfit += $this->salesProductsServiceImpl->calculateProfitByProductSold($productsSold);
  126.             }
  127.         }
  128.         return CurrencyHelper::convertToCurrency($totalProfit);
  129.     }
  132.     #[Route('/get-products-summary', name: 'get_products_summary')]
  133.     public function getProductsSummary(Request $request, ProductRepository $productRepository)
  134.     {
  136.         $s = isset($request->get('search')['value']) ? $request->get('search')['value'] : null;
  137.         $startDate = $request->get('startDate') != null ? $request->get('startDate') : (new \DateTimeImmutable('now'))->modify('-1 month')->format('Y-m-d');
  138.         $endDate = $request->get('endDate') != null ? $request->get('endDate') : (new \DateTimeImmutable('now'))->format('Y-m-d');
  139.         $id = $request->get('id');
  140.         $column = $request->get('order') != null ? $request->get('order')[0]['column'] : '0';
  141.         $seller = $request->get('sellerId') == 0 ? null : $request->get('sellerId');
  142.         $dir = $request->get('order') != null ? $request->get('order')[0]['dir'] : 'asc';
  143.         $limit = $request->get('length');
  144.         if ($request->get('start'))
  145.             $page = 1 + ($request->get('start') / $limit);
  146.         else
  147.             $page = 1;
  149.         $startDate = \DateTimeImmutable::createFromFormat('Y-m-d', $startDate);
  150.         $endDate = \DateTimeImmutable::createFromFormat('Y-m-d', $endDate);
  153.         $query = $this->entityManager->getRepository(Product::class)->createQueryBuilder('p')
  154.             ->leftJoin('p.productsSolds', 'productsSolds')
  155.             ->leftJoin('productsSolds.sales', 'sales')
  156.             ->leftJoin('sales.seller', 'seller')
  157.             ->leftJoin('p.measurement', 'w')
  158.             ->where('p.salePrice LIKE :s OR p.warehousePrice LIKE :s OR p.purchasePrice LIKE :s OR p.name LIKE :s OR p.description LIKE :s OR p.code LIKE :s')
  159.             ->setParameter('s', "%$s%")
  160.             ->orWhere('w.measurement LIKE :s')
  161.             ->setParameter('s', "%$s%");
  163.         if ($seller != null) {
  164.             $query->andWhere('seller.id = :sellerId')
  165.                 ->setParameter('sellerId', $seller);
  166.         }
  168.         $query = $query->getQuery();
  170.         $products = $query->getResult();
  172.         //        switch ($column){
  173. //            case 0:
  174. //                $column = 'id';
  175. //                break;
  176. //            case 1:
  177. //                $column = 'productName';
  178. //                break;
  179. //            case 2:
  180. //                $column = 'code';
  181. //                break;
  182. //            case 3:
  183. //                $column = 'soldPrice';
  184. //                break;
  185. //            case 4:
  186. //                $column = 'totalEarn';
  187. //                break;
  188. //            case 5:
  189. //                $column = 'totalProfit';
  190. //                break;
  191. //        }
  192.         $datas = $this->createArrayForProductsDatatable(
  193.             $products,
  194.             $startDate,
  195.             $endDate,
  196.             $column,
  197.             $dir,
  198.             $page,
  199.             $limit
  200.         );
  201.         //        dd($datas);
  202. //
  203. //        dd($column);
  208.         return $this->json($datas, 200);
  210.         dd($products->getItems());
  212.         return $this->json(['data' => 'ss'], 200);
  214.         $products = $this->entityManager->getRepository(Product::class);
  216.     }
  219.     public function createArrayForProductsDatatable($products, \DateTimeImmutable $startDate, \DateTimeImmutable $endDate, $column, $dir, $page, $limit)
  220.     {
  221.         $records = [];
  222.         $records["data"] = [];
  224.         /**
  225.          * @var Product $entity
  226.          */
  227.         foreach ($products as $entity) {
  228.             $records["data"][] = array(
  229.                 $entity->getId(),
  230.                 $entity->getName(),
  231.                 $entity->getCode() . " - " . ($entity->getMeasurement() != null ? $entity->getMeasurement()->getMeasurement() : ''),
  232.                 $this->salesServiceImpl->getTotalSoldQuantityByDateSellerAndProduct($startDate, $endDate, null, $entity->getId()),
  233.                 $this->salesServiceImpl->getTotalSalesPriceByDateSellerAndProduct($startDate, $endDate, null, $entity->getId()),
  234.                 $this->salesServiceImpl->getTotalProfitPriceByDateSellerAndProduct($startDate, $endDate, null, $entity->getId()),
  235.                 "<button class='btn btn-primary product-details-btn' data-enddate='" . $endDate->format('Y-m-d') . "' data-startdate='" . $startDate->format('Y-m-d') . "' data-pid='" . $entity->getId() . "'>Detay</button>"
  236.             );
  237.         }
  239.         $this->sortArrayByKey($records["data"], $column, false, $dir == 'asc');
  240.         $pagination = $this->paginator->paginate(
  241.             $records["data"],
  242.             $page,
  243.             $limit
  244.         );
  247.         $records['recordsTotal'] = $pagination->getTotalItemCount();
  248.         $records['recordsFiltered'] = $pagination->getTotalItemCount();
  249.         $records["data"] = $pagination->getItems();
  252.         return $records;
  253.     }
  255.     #[Route('/sales-prices-and-profits-by-year-range-month', name: 'sales_prices_and_profits_by_year_range_month')]
  256.     public function getSalesPricesAndProfitsByYearRangeMonth(Request $request)
  257.     {
  258.         $year = $request->get('year') != null ? $request->get('year') : date('Y');
  260.         $months = [];
  261.         $format = 'Y-m-d';
  263.         for ($month = 1; $month <= 12; $month++) {
  264.             //            if($month > date('m'))
  265. //                break;
  266.             $startOfMonth = \DateTimeImmutable::createFromFormat($format, "$year-$month-01");
  268.             $endOfMonth = (\DateTimeImmutable::createFromFormat($format, "$year-$month-01"))->modify('last day of this month');
  269.             $months[$month - 1]['start'] = $startOfMonth;
  270.             $months[$month - 1]['end'] = $endOfMonth;
  272.         }
  273.         $data = [];
  275.         foreach ($months as $month) {
  276.             $data['profit'][] = $this->salesServiceImpl->getTotalSalesProfitBetweenTwoDate($month['start'], $month['end']);
  277.             $data['sales'][] = $this->salesServiceImpl->getTotalSalesPriceBetweenTwoDate($month['start'], $month['end']);
  278.         }
  282.         //        $qb = $this->entityManager->getRepository(Sales::class)->createQueryBuilder('s')
  283. //                    ->select('MONTH(s.salesDate) as month, SUM(s.totalPurchasePrice) as total')
  284. //                    ->where('YEAR(s.salesDate) = :year')
  285. //                    ->setParameter('year', $year)
  286. //                    ->groupBy('month')
  287. //                    ->orderBy('month', 'ASC')
  288. //                    ->getQuery();
  290.         //        dd($qb->getResult());
  291.         return $this->json($data, 200);
  292.     }
  295.     function sortArrayByKey(&$array, $key, $string = false, $asc = true)
  296.     {
  297.         if ($string) {
  298.             usort($array, function ($a, $b) use (&$key, &$asc) {
  299.                 if ($asc)
  300.                     return strcmp(strtolower($a[$key]), strtolower($b[$key]));
  301.                 else
  302.                     return strcmp(strtolower($b[$key]), strtolower($a[$key]));
  303.             });
  304.         } else {
  305.             usort($array, function ($a, $b) use (&$key, &$asc) {
  306.                 if ($a[$key] == $b[$key]) {
  307.                     return 0;
  308.                 }
  309.                 if ($asc)
  310.                     return ($a[$key] < $b[$key]) ? -1 : 1;
  311.                 else
  312.                     return ($a[$key] > $b[$key]) ? -1 : 1;
  314.             });
  315.         }
  316.     }
  319.     #[Route('/admin', name: 'app_panel_dashboard')]
  320.     public function index(Request $request, SellerDetailRequestDto $sellerDetailRequestDto, \App\Repository\ProductMonthlyStatsRepository $statsRepository, FinancialForecastingService $financialService, \App\Service\Analysis\StrategicForecastingService $forecastingService): Response
  321.     {
  323.         if ($request->get('year') != null) {
  324.             $date = new \DateTimeImmutable('first day of January ' . $request->get('year'));
  325.             $year = $request->get('year');
  326.         } else {
  327.             $date = new \DateTimeImmutable('first day of January this year');
  328.             $year = date('Y');
  329.         }
  330.         $mountly = $this->salesService->getEarningsByPeriot(DateZoneEnums::MONTHLY);
  331.         $weekly = $this->salesService->getEarningsByPeriot(DateZoneEnums::WEEKLY);
  332.         $yearly = $this->salesService->getEarningsByPeriot(DateZoneEnums::YEARLY);
  333.         $profitMothly = $this->getProfitByPeriots(DateZoneEnums::MONTHLY, $year);
  334.         $profitWeekly = $this->getProfitByPeriots(DateZoneEnums::WEEKLY, $year);
  335.         $months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
  336.         $monthsTr = ['Ocak', 'Şubat', 'Mart', 'Nisan', 'Mayıs', 'Haziran', 'Temmuz', 'Ağustos', 'Eylül', 'Ekim', 'Kasım', 'Aralık'];
  338.         $array = [];
  339.         foreach ($months as $key => $month) {
  340.             $thisMonth = (int) date('m');
  341.             if ($month != $months[$thisMonth - 1]) {
  342.                 $startDate = new \DateTimeImmutable('first day of ' . $months[$key] . ' ' . $year);
  343.                 $endDate = new \DateTimeImmutable('last day of ' . $months[$key] . ' ' . $year);
  344.                 $earn = $this->salesService->getEarningsBetwenTwoDate($startDate, $endDate);
  345.                 $array[] = [
  346.                     $monthsTr[$key],
  347.                     $earn ? $earn : 0.00,
  348.                 ];
  349.             } else {
  350.                 $startDate = new \DateTimeImmutable('first day of ' . $months[$thisMonth - 1] . ' ' . $year);
  351.                 $endDate = new \DateTimeImmutable('now');
  352.                 $array[] = [
  353.                     $monthsTr[$thisMonth - 1],
  354.                     $this->salesService->getEarningsBetwenTwoDate($startDate, $endDate),
  355.                 ];
  356.                 break;
  357.             }
  358.         }
  360.         $inTransitTransferNumber = $this->stockTransferService->getNumberOfInTransitTransfers();
  362.         $allSallers = $this->entityManager->getRepository(User::class)->findAll();
  363.         $allWarehouses = $this->entityManager->getRepository(Warehouse::class)->findAll();
  364.         $allProducts = $this->entityManager->getRepository(Product::class)->findAll();
  366.         $uniqueProductCodes = [];
  367.         foreach ($allProducts as $p) {
  368.             $c = $p->getCode();
  369.             if ($c) {
  370.                 $uniqueProductCodes[] = $c;
  371.             }
  372.         }
  373.         $uniqueProductCodes = array_unique($uniqueProductCodes);
  374.         sort($uniqueProductCodes);
  376.         $requestedProducts = $request->get('pproductId');
  377.         $products = [];
  378.         if (is_array($requestedProducts)) {
  379.             $products = array_values(array_filter($requestedProducts));
  380.         } elseif (!empty($requestedProducts)) {
  381.             $products = [(int) $requestedProducts];
  382.         }
  383.         if (empty($products)) {
  384.             $ps = $this->entityManager->getRepository(Product::class)
  385.                 ->createQueryBuilder('c')
  386.                 ->select('c.id')
  387.                 ->setMaxResults(5)
  388.                 ->getQuery()
  389.                 ->getResult();
  390.             foreach ($ps as $p) {
  391.                 $products[] = (int) $p['id'];
  392.             }
  393.         }
  394.         $startDate = $request->get('pstartDate') ? new \DateTimeImmutable($request->get('pstartDate')) : new \DateTimeImmutable("30 days ago");
  395.         $finishDate = $request->get('pfinishDate') ? new \DateTimeImmutable($request->get('pfinishDate')) : new \DateTimeImmutable('now');
  396.         if (isset($this->entityManager->getRepository(Warehouse::class)->createQueryBuilder('c')->leftJoin('c.sales', 'sales')->where('sales.id is not null')->setMaxResults(1)->getQuery()->getResult()[0])) {
  397.             $warehouseId = $request->get('pwarehouseId') ? $request->get('pwarehouseId') : $this->entityManager->getRepository(Warehouse::class)->createQueryBuilder('c')->leftJoin('c.sales', 'sales')->where('sales.id is not null')->setMaxResults(1)->getQuery()->getResult()[0]->getId();
  398.         } else {
  399.             try {
  400.                 $warehouseId = $request->get('pwarehouseId') ? $request->get('pwarehouseId') : $this->entityManager->getRepository(Warehouse::class)->createQueryBuilder('c')->leftJoin('c.sales', 'sales')->setMaxResults(1)->getQuery()->getResult()[0]->getId();
  401.             } catch (\Exception $e) {
  402.                 $warehouseId = 0;
  403.             }
  404.         }
  405.         $sellerId = $request->get('psellerId');
  406.         $periyot = 0;
  407.         if ($request->get('periyot') !== null) {
  408.             if ($request->get('periyot') == 'weekly') {
  409.                 $periyot = 7;
  410.                 $periyotAdi = 'Hafta';
  411.             }
  412.             if ($request->get('periyot') == 'mothly') {
  413.                 $periyot = 30;
  414.                 $periyotAdi = 'Ay';
  415.             }
  416.             if ($request->get('periyot') == 'daily') {
  417.                 $periyot = 1;
  418.                 $periyotAdi = 'Gün';
  419.             }
  420.         } else {
  421.             $periyot = 7;
  422.             $periyotAdi = 'Hafta';
  423.         }
  426.         $fark = $startDate->diff($finishDate);
  427.         if ($fark->m != 0) {
  428.             $fark = $fark->m * 30 + $fark->d;
  429.         } else {
  430.             $fark = $fark->d;
  431.         }
  433.         $periyotSayisi = (int) ceil($fark / $periyot);
  434.         $arrays = [];
  437.         $baslangicTarihi = $startDate->format('Y-m-d');
  438.         $bitisTarihi = $startDate->modify('+' . $periyot . 'days')->format('Y-m-d');
  440.         for ($i = 0; $i < $periyotSayisi; $i++) {
  441.             if ($finishDate < $bitisTarihi) {
  442.                 $bitisTarihi = $finishDate;
  443.             }
  444.             foreach ($products as $productId) {
  445.                 $product = $this->entityManager->getRepository(Product::class)->find($productId);
  446.                 if (!$product) {
  447.                     continue;
  448.                 }
  449.                 $periotData = $this->getProductsByPeriot($baslangicTarihi, $bitisTarihi, $productId, $warehouseId, $sellerId);
  450.                 $totalAmount = 0.00;
  451.                 if (!empty($periotData) && isset($periotData[0]['totalAmount'])) {
  452.                     $totalAmount = (float) $periotData[0]['totalAmount'];
  453.                 }
  454.                 $arrays[$i + 1 . '.' . $periyotAdi][$product->getName()] = $totalAmount;
  455.             }
  456.             $baslangicTarihi = $bitisTarihi;
  457.             $yeniBaglangicTarihi = new \DateTimeImmutable($baslangicTarihi);
  458.             $bitisTarihi = $yeniBaglangicTarihi->modify('+' . $periyot . 'days')->format('Y-m-d');
  459.         }
  460.         $sellers = $this->entityManager->getRepository(User::class)->findAll();
  462.         $urun = [];
  463.         $periyotlar = [];
  464.         foreach ($arrays as $key => $arrayy) {
  465.             $periyotlar[] = $key;
  466.             foreach ($arrayy as $key => $arr) {
  467.                 $urun[$key][] = $arr;
  468.             }
  469.         }
  471.         $lowStockProducts = $this->getLowStockProducts();
  474.         $sellersDetail = $this->getSalesBySeller(
  475.             $sellerDetailRequestDto->getSellerStartDate(),
  476.             $sellerDetailRequestDto->getSellerFinishDate(),
  477.             $sellerDetailRequestDto->getSellerProducts(),
  478.             $sellerDetailRequestDto->getSellerId(),
  479.             $sellerDetailRequestDto->getSelectWarehouseForSellersTable(),
  481.         );
  483.         // --- NEW: 2025 Strategic Data Calculation ---
  484.         $stats2025 = $statsRepository->findBy(['year' => 2025]);
  485.         $totalRevenue2025 = 0;
  486.         $totalProfit2025 = 0;
  488.         foreach ($stats2025 as $stat) {
  489.             $totalRevenue2025 += $stat->getTotalSalesQty() * $stat->getAvgSalesPrice();
  490.             // Net Profit field might be string or float, ensure float
  491.             $cost = (float) $stat->getAvgCostPrice();
  492.             $price = (float) $stat->getAvgSalesPrice();
  493.             $qty = (float) $stat->getTotalSalesQty();
  494.             $totalProfit2025 += ($price - $cost) * $qty;
  495.         }
  497.         $selectedMonth = $request->query->getInt('analysis_month', (int) date('m'));
  498.         $statsMonth = $statsRepository->findBy(['year' => 2025, 'month' => $selectedMonth]);
  499.         $monthRevenue2025 = 0;
  500.         $monthProfit2025 = 0;
  502.         foreach ($statsMonth as $stat) {
  503.             $monthRevenue2025 += $stat->getTotalSalesQty() * $stat->getAvgSalesPrice();
  504.             $cost = (float) $stat->getAvgCostPrice();
  505.             $price = (float) $stat->getAvgSalesPrice();
  506.             $qty = (float) $stat->getTotalSalesQty();
  507.             $monthProfit2025 += ($price - $cost) * $qty;
  508.         }
  510.         // --- 2026 Projeksiyon (Aylık Gelir Özeti) Hesaplaması (2025 Bazlı) ---
  511.         $strategicRevenue2026Breakdown = [];
  512.         $strategicRevenue2026Total = 0;
  514.         // 2025 yılının tüm verilerini çekiyoruz
  515.         $allStats2025 = $statsRepository->findBy(['year' => 2025]);
  517.         // 12 aylık boş bir dizi oluştur (1-12)
  518.         $monthlyRevenues = array_fill(1, 12, 0.0);
  520.         foreach ($allStats2025 as $stat) {
  521.             $m = $stat->getMonth();
  522.             if ($m >= 1 && $m <= 12) {
  523.                 $rev = (float) $stat->getTotalSalesQty() * (float) $stat->getAvgSalesPrice();
  524.                 $monthlyRevenues[$m] += $rev;
  525.             }
  526.         }
  528.         foreach ($monthlyRevenues as $m => $val) {
  529.             $strategicRevenue2026Breakdown[$m] = $val;
  530.             $strategicRevenue2026Total += $val;
  531.         }
  532.         // ---------------------------------------------------------------------
  533.         // --- 2026 Projeksiyon (Aylık Kâr Özeti) Hesaplaması (2025 Bazlı) ---
  534.         $strategicProfit2026Breakdown = [];
  535.         $strategicProfit2026Total = 0;
  536.         $monthlyProfits = array_fill(1, 12, 0.0);
  537.         foreach ($allStats2025 as $stat) {
  538.             $m = $stat->getMonth();
  539.             if ($m >= 1 && $m <= 12) {
  540.                 $cost = (float) $stat->getAvgCostPrice();
  541.                 $price = (float) $stat->getAvgSalesPrice();
  542.                 $qty = (float) $stat->getTotalSalesQty();
  543.                 $monthlyProfits[$m] += ($price - $cost) * $qty;
  544.             }
  545.         }
  546.         foreach ($monthlyProfits as $m => $val) {
  547.             $strategicProfit2026Breakdown[$m] = $val;
  548.             $strategicProfit2026Total += $val;
  549.         }
  551.         // --- 2026 Gerçekleşen Veriler (Actuals) ---
  552.         $allStats2026 = $statsRepository->findBy(['year' => 2026]);
  553.         $actualRevenue2026Breakdown = array_fill(1, 12, 0.0);
  554.         $actualProfit2026Breakdown = array_fill(1, 12, 0.0);
  555.         $actualRevenue2026Total = 0;
  556.         $actualProfit2026Total = 0;
  558.         foreach ($allStats2026 as $stat) {
  559.             $m = $stat->getMonth();
  560.             if ($m >= 1 && $m <= 12) {
  561.                 $rev = (float) $stat->getTotalSalesQty() * (float) $stat->getAvgSalesPrice();
  563.                 $cost = (float) $stat->getAvgCostPrice();
  564.                 $price = (float) $stat->getAvgSalesPrice();
  565.                 $qty = (float) $stat->getTotalSalesQty();
  566.                 $prof = ($price - $cost) * $qty;
  568.                 $actualRevenue2026Breakdown[$m] += $rev;
  569.                 $actualProfit2026Breakdown[$m] += $prof;
  570.             }
  571.         }
  572.         // Toplamları hesapla
  573.         $actualRevenue2026Total = array_sum($actualRevenue2026Breakdown);
  574.         $actualProfit2026Total = array_sum($actualProfit2026Breakdown);
  576.         // --- 2025 Ürün Bazlı Aylık Satış Raporu ---
  577.         // Veri Kaynakları:
  578.         // - Satış Miktarları: product_monthly_stats.total_sales_qty
  579.         // - Mevcut Stok: StockInfo tablosu
  580.         // - Birim Maliyet: product_monthly_stats.avg_cost_price (ağırlıklı ortalama)
  581.         $productSales2025 = [];
  583.         foreach ($allStats2025 as $stat) {
  584.             $product = $stat->getProduct();
  585.             if ($product === null) {
  586.                 continue;
  587.             }
  589.             $pId = $product->getId();
  591.             if (!isset($productSales2025[$pId])) {
  592.                 $productSales2025[$pId] = [
  593.                     'name' => $product->getName(),
  594.                     'code' => $product->getCode(),
  595.                     'months' => array_fill(1, 12, 0),
  596.                     'total' => 0,
  597.                     // Mevcut Stok: StockInfo tablosundan
  598.                     'currentStock' => array_reduce($product->getStockInfos()->toArray(), function ($sum, $item) {
  599.                         return $sum + $item->getTotalQuantity();
  600.                     }, 0),
  601.                     // Maliyet hesaplaması için ara değerler
  602.                     'totalCostSum' => 0,  // Toplam maliyet (qty * cost)
  603.                     'totalQtyForCost' => 0, // Toplam miktar (ağırlıklı ortalama için)
  604.                     'unitPrice' => 0  // Sonradan hesaplanacak
  605.                 ];
  606.             }
  608.             $m = $stat->getMonth();
  609.             if ($m >= 1 && $m <= 12) {
  610.                 $qty = (float) $stat->getTotalSalesQty();
  611.                 $avgCostPrice = (float) $stat->getAvgCostPrice();
  613.                 $productSales2025[$pId]['months'][$m] += $qty;
  614.                 $productSales2025[$pId]['total'] += $qty;
  616.                 // Ağırlıklı ortalama maliyet hesabı için: (qty * cost) toplamı
  617.                 if ($qty > 0 && $avgCostPrice > 0) {
  618.                     $productSales2025[$pId]['totalCostSum'] += ($qty * $avgCostPrice);
  619.                     $productSales2025[$pId]['totalQtyForCost'] += $qty;
  620.                 }
  621.             }
  622.         }
  624.         // Post-process: Ağırlıklı ortalama maliyeti hesapla ve derived values'ları oluştur
  625.         foreach ($productSales2025 as $pId => &$data) {
  626.             $currentStock = $data['currentStock'];
  627.             $yearlySales = $data['total'];
  629.             // Birim Fiyat: Ağırlıklı ortalama maliyet (product_monthly_stats'tan)
  630.             $unitPrice = 0;
  631.             if ($data['totalQtyForCost'] > 0) {
  632.                 $unitPrice = $data['totalCostSum'] / $data['totalQtyForCost'];
  633.             }
  634.             $data['unitPrice'] = $unitPrice;
  636.             // --- Yearly Plan Calculations ---
  637.             // Yıllık Satılan: $yearlySales (product_monthly_stats'tan toplam)
  638.             // Mevcut Stok: $currentStock (StockInfo'dan)
  639.             // Satılan - Stok: $yearlySales - $currentStock
  640.             // Sipariş Miktarı: Satılan - Stok (negatifse 0)
  641.             // Toplam Maliyet: Sipariş Miktarı * Birim Fiyat
  643.             $salesMinusStock = $yearlySales - $currentStock;
  644.             $orderQty = max(0, ceil($salesMinusStock)); // Negatif siparişi engelle
  645.             $yearlyTotalCost = $orderQty * $unitPrice;
  647.             $data['yearly'] = [
  648.                 'sales' => ceil($yearlySales),         // Yıllık Satılan
  649.                 'remaining' => ceil($salesMinusStock), // Satılan - Stok
  650.                 'order' => $orderQty,                  // Sipariş Miktarı
  651.                 'totalCost' => $yearlyTotalCost        // Toplam
  652.             ];
  654.             // --- Monthly Projection Calculations (Stok - Satılan) ---
  655.             $monthlyCalculations = [];
  656.             for ($m = 1; $m <= 12; $m++) {
  657.                 $monthlySales = $data['months'][$m];
  658.                 $monthlyRemaining = ceil($currentStock - $monthlySales);
  659.                 $monthlyOrder = $monthlyRemaining;
  660.                 $monthlyTotalCost = $monthlyOrder * $unitPrice;
  662.                 $monthlyCalculations[$m] = [
  663.                     'sales' => $monthlySales,
  664.                     'remaining' => $monthlyRemaining,
  665.                     'order' => $monthlyOrder,
  666.                     'totalCost' => $monthlyTotalCost
  667.                 ];
  668.             }
  669.             $data['monthly_derived'] = $monthlyCalculations;
  671.             // Temizlik: Ara hesaplama alanlarını kaldır
  672.             unset($data['totalCostSum'], $data['totalQtyForCost']);
  673.         }
  674.         unset($data); // Break reference
  676.         // Çok satandan aza doğru sırala - uasort ile anahtarları koru (frontend için gerekli)
  677.         uasort($productSales2025, function ($a, $b) {
  678.             return $b['total'] <=> $a['total'];
  679.         });
  681.         // Sort allProducts based on 2025 sales totals (Added for Product Projection Table)
  682.         usort($allProducts, function ($a, $b) use ($productSales2025) {
  683.             $totalA = $productSales2025[$a->getId()]['total'] ?? 0;
  684.             $totalB = $productSales2025[$b->getId()]['total'] ?? 0;
  685.             return $totalB <=> $totalA; // DESC
  686.         });
  687.         // --- 2025-2026 Inventory Turn & Sleeping Stock Analysis (Rolling 12 Months) ---
  688.         $inventoryAnalysis = [];
  690.         // 1. Fetch Lifecycle Stats (First Seen, All-time Sales/Purchases) for ALL products
  691.         $lifecycleStats = $statsRepository->getProductLifecycleStats();
  693.         // Dinamik olarak son 12 ayı belirle
  694.         $rollingMonths = [];
  695.         $currentMonthObj = new \DateTimeImmutable('first day of this month');
  696.         for ($i = 0; $i < 12; $i++) {
  697.             $date = $currentMonthObj->modify("-$i month");
  698.             $rollingMonths[] = [
  699.                 'year' => (int) $date->format('Y'),
  700.                 'month' => (int) $date->format('m')
  701.             ];
  702.         }
  704.         // Son 12 ayın verilerini toplu çek (Performans için)
  705.         $yearsToFetch = array_unique(array_column($rollingMonths, 'year'));
  706.         $allRecentStats = $statsRepository->findBy(['year' => $yearsToFetch]);
  708.         // Ürün bazlı grupla
  709.         $statsByProduct = [];
  710.         foreach ($allRecentStats as $s) {
  711.             if ($s->getProduct()) {
  712.                 $pId = $s->getProduct()->getId();
  713.                 $statsByProduct[$pId][$s->getYear()][$s->getMonth()] = $s;
  714.             }
  715.         }
  717.         foreach ($allProducts as $product) {
  718.             // Sadece Tekil Ürün ve Paket Ürün olanları dahil et (Transport, Servis vb. hariç)
  719.             $type = $product->getProductTypeEnum();
  720.             if ($type !== ProductTypeEnum::SINGLE_ITEM && $type !== ProductTypeEnum::BUNDLE) {
  721.                 continue;
  722.             }
  724.             $pId = $product->getId();
  726.             // Mevcut Stok (Tüm depolardan)
  727.             $currentStock = array_reduce($product->getStockInfos()->toArray(), function ($sum, $item) {
  728.                 return $sum + $item->getTotalQuantity();
  729.             }, 0);
  731.             $totalSalesLast12Months = 0;
  732.             $totalSales3Months = 0;
  733.             $totalSales6Months = 0;
  734.             $inactiveMonthsCount = 0; // Last 8 months
  735.             $revenueLast12Months = 0;
  736.             $costLast12Months = 0;
  738.             // Rolling months dizisi tersten (en eskiden en yeniye) değil, en yeniden en eskiye doğru
  739.             foreach ($rollingMonths as $index => $period) {
  740.                 $s = $statsByProduct[$pId][$period['year']][$period['month']] ?? null;
  741.                 $qty = $s ? (float) $s->getTotalSalesQty() : 0;
  743.                 $totalSalesLast12Months += $qty;
  745.                 // Ek kolonlar için (3 Ay, 6 Ay)
  746.                 if ($index < 3) {
  747.                     $totalSales3Months += $qty;
  748.                 }
  749.                 if ($index < 6) {
  750.                     $totalSales6Months += $qty;
  751.                 }
  753.                 // Hareketsizlik kontrolü (Son 8 ay için)
  754.                 if ($index < 8) {
  755.                     if ($qty <= 0) {
  756.                         $inactiveMonthsCount++;
  757.                     }
  758.                 }
  760.                 if ($s) {
  761.                     $revenueLast12Months += $qty * (float) $s->getAvgSalesPrice();
  762.                     $costLast12Months += $qty * (float) $s->getAvgCostPrice();
  763.                 }
  764.             }
  766.             // Eğer verilerde maliyet/fiyat yoksa ürün kartından al
  767.             $avgCostLast12 = $totalSalesLast12Months > 0 ? $costLast12Months / $totalSalesLast12Months : (float) ($product->getPurchasePrice() ?? 0);
  768.             $avgPriceLast12 = $totalSalesLast12Months > 0 ? $revenueLast12Months / $totalSalesLast12Months : (float) ($product->getSalePrice() ?? 0);
  770.             // 1. Satış Hızı (Velocity) - Aylık Ortalama
  771.             $velocity = $totalSalesLast12Months / 12;
  773.             // Lifecycle Verileri
  774.             $lStats = $lifecycleStats[$pId] ?? null;
  775.             $isNewProduct = false;
  776.             $allTimeSellThrough = 0;
  778.             if ($lStats) {
  779.                 // Yeni Ürün Kontrolü: < 3 Ay (First Seen Date)
  780.                 $firstSeenDate = new \DateTime($lStats['firstSeen'] . '-01'); // YYYY-MM-01
  781.                 $threeMonthsAgo = (new \DateTime())->modify('-3 months');
  783.                 if ($firstSeenDate > $threeMonthsAgo) {
  784.                     $isNewProduct = true;
  785.                 }
  787.                 // Sell-Through Rate (All Time)
  788.                 if ($lStats['totalPurchases'] > 0) {
  789.                     $allTimeSellThrough = $lStats['totalSales'] / $lStats['totalPurchases'];
  790.                 }
  791.             } else {
  792.                 // İstatistik tablosunda hiç kaydı yoksa (veya eski değilse) Yeni Ürün kabul edebiliriz
  793.                 $isNewProduct = true;
  794.             }
  796.             // 2. Sleeping Stock & Status Logic (Advanced)
  797.             $sleepingStock = 0;
  798.             $status = 'Normal';
  800.             if ($isNewProduct) {
  801.                 $status = 'Yeni Ürün';
  802.             } else {
  803.                 // Atıl Stok Kontrolü: 8 aydır satış yok
  804.                 if ($inactiveMonthsCount >= 8 && $currentStock > 0) {
  805.                     $status = 'Atıl Stok (8 Ay Hareketsiz)';
  806.                     $sleepingStock = $currentStock; // Hepsi uyuyan kabul edilir
  807.                 } else {
  808.                     // Uyuyan Stok (Coverage & Turnover Logic)
  809.                     // Stok bizi kaç ay idare eder? (Stock Coverage)
  810.                     $stockCoverageMonths = $velocity > 0 ? ($currentStock / $velocity) : 999;
  812.                     // Kural 1: 12 Aydan fazla yetecek stok varsa -> Fazlası uyuyandır
  813.                     if ($stockCoverageMonths > 12) {
  814.                         $neededStock = $velocity * 12; // 1 senelik stok makul
  815.                         $sleepingStock = max(0, $currentStock - $neededStock);
  816.                         if ($sleepingStock > 0) {
  817.                             $status = 'Uyuyan Stok';
  818.                         }
  819.                     }
  820.                     // Kural 2: 6 Aydan fazla yetecek stok var VE Satış Performansı (Sell-Through) %20'nin altındaysa
  821.                     elseif ($stockCoverageMonths > 6 && $allTimeSellThrough < 0.20) {
  822.                         $neededStock = $velocity * 6; // 6 aylık stok makul
  823.                         $sleepingStock = max(0, $currentStock - $neededStock);
  824.                         if ($sleepingStock > 0) {
  825.                             $status = 'Uyuyan Stok (Düşük Performans)';
  826.                         }
  827.                     } elseif ($currentStock <= ($velocity * 1.5) && $velocity > 0) {
  828.                         $status = 'Hızlı Dönüş (Kritik)';
  829.                     }
  830.                 }
  831.             }
  834.             // 4. Yatırım Verimliliği (ROI)
  835.             // Bağlı Sermaye: Mevcut Stok * Maliyet
  836.             $tiedCapital = $currentStock * $avgCostLast12;
  837.             // Verimlilik: Son 12 aylık ciro / Bağlı sermaye (veya benzeri bir oran)
  838.             $efficiency = $tiedCapital > 0 ? ($revenueLast12Months / $tiedCapital) : ($totalSalesLast12Months > 0 ? 99 : 0);
  840.             if ($currentStock > 0 || $totalSalesLast12Months > 0) {
  841.                 $inventoryAnalysis[] = [
  842.                     'name' => $product->getName(),
  843.                     'code' => $product->getCode(),
  844.                     'endStock' => $currentStock,
  845.                     'totalSales' => $totalSalesLast12Months,
  846.                     'totalSales3Months' => $totalSales3Months,
  847.                     'totalSales6Months' => $totalSales6Months,
  848.                     'velocity' => $velocity,
  849.                     'sleepingStock' => $sleepingStock,
  850.                     'status' => $status,
  851.                     'avgCost' => $avgCostLast12,
  852.                     'avgPrice' => $avgPriceLast12,
  853.                     'sleepingStockCost' => $sleepingStock * $avgCostLast12,
  854.                     'sleepingStockRevenue' => $sleepingStock * $avgPriceLast12,
  855.                     'efficiency' => $efficiency,
  856.                     'inactiveMonths' => $inactiveMonthsCount
  857.                 ];
  858.             }
  859.         }
  861.         // Uyuyan stok miktarına göre azalan sırala
  862.         usort($inventoryAnalysis, function ($a, $b) {
  863.             return $b['sleepingStock'] <=> $a['sleepingStock'];
  864.         });
  866.         // --- Budget Planning Data (Aylık Bütçe Detayı) ---
  867.         $budgetPlanningData = $financialService->generateFinancialForecast(2025, 2026, true);
  869.         // --------------------------------------------
  871.         return $this->render('admin/dashboard/index.html.twig', [
  872.             'controller_name' => 'DashboardController',
  873.             'mountly' => CurrencyHelper::convertToCurrency($mountly),
  874.             'weekly' => CurrencyHelper::convertToCurrency($weekly),
  875.             'profitMonthly' => $profitMothly,
  876.             'profitWeekly' => $profitWeekly,
  877.             'yearly' => $yearly,
  878.             'inTransits' => $inTransitTransferNumber,
  879.             'earningInPeriots' => $array,
  880.             'sallers' => $this->userService->getTotalUsersEarns(),
  881.             'allSallers' => $allSallers,
  882.             'allWarehouses' => $allWarehouses,
  883.             'allProducts' => $allProducts,
  884.             'periyotlar' => $periyotlar,
  885.             'urunler' => $urun,
  886.             'monthsTr' => $monthsTr,
  887.             'sellers' => $sellers,
  888.             'sellersDetail' => $sellersDetail,
  889.             'warehouses' => $this->warehouseService->getAll(),
  890.             'lowStockProducts' => $lowStockProducts,
  891.             // New Variables (Strategic)
  892.             'strategic_2025_revenue' => $totalRevenue2025,
  893.             'strategic_2025_profit' => $totalProfit2025,
  894.             'strategic_month_revenue' => $monthRevenue2025,
  895.             'strategic_month_profit' => $monthProfit2025,
  896.             'selected_analysis_month' => $selectedMonth,
  897.             'strategic_revenue_2026_breakdown' => $strategicRevenue2026Breakdown,
  898.             'strategic_revenue_2026_total' => $strategicRevenue2026Total,
  899.             // New Variables (Actuals & Profit Projection)
  900.             'strategic_profit_2026_breakdown' => $strategicProfit2026Breakdown,
  901.             'strategic_profit_2026_total' => $strategicProfit2026Total,
  902.             'actual_revenue_2026_breakdown' => $actualRevenue2026Breakdown,
  903.             'actual_revenue_2026_total' => $actualRevenue2026Total,
  904.             'actual_profit_2026_breakdown' => $actualProfit2026Breakdown,
  905.             'actual_profit_2026_total' => $actualProfit2026Total,
  906.             'product_sales_2025' => $productSales2025,
  907.             'inventory_analysis' => $inventoryAnalysis,
  908.             // Budget Planning Data (Aylık Bütçe Detayı)
  909.             'budget_planning' => $budgetPlanningData,
  910.             'allMeasurementUnits' => $this->entityManager->getRepository(\App\Entity\MeasurementUnits::class)->findAll(),
  911.             'allMeasurements' => $this->entityManager->getRepository(\App\Entity\Measurements::class)->findAll(),
  912.             'uniqueProductCodes' => $uniqueProductCodes,
  913.         ]);
  915.     }
  917.     public function getLowStockProducts()
  918.     {
  920.         $qb = $this->entityManager->getRepository(StockInfo::class)->createQueryBuilder('si');
  922.         $qb
  923.             ->leftJoin('si.product', 'p')
  924.             ->leftJoin('si.warehouse', 'w')
  925.             ->leftJoin('p.measurementUnit', 'mu')
  926.             ->leftJoin('p.measurement', 'm')
  927.             ->where(
  928.                 $qb->expr()->orX(
  929.                     // Eğer symbol 'SET' ise totalQuantity 200 altı olanları getir
  930.                     $qb->expr()->andX(
  931.                         $qb->expr()->eq('mu.symbol', ':setSymbol'),
  932.                         $qb->expr()->lt('si.totalQuantity', ':setThreshold')
  933.                     ),
  934.                     // Aksi durumda totalQuantity 300 altı olanları getir
  935.                     $qb->expr()->andX(
  936.                         $qb->expr()->neq('mu.symbol', ':setSymbol'),
  937.                         $qb->expr()->lt('si.totalQuantity', ':defaultThreshold')
  938.                     )
  939.                 )
  940.             )
  941.             ->setParameter('setSymbol', 'SET')
  942.             ->setParameter('setThreshold', 200)
  943.             ->setParameter('defaultThreshold', 300)
  944.             ->select(
  945.                 'p.id as productId',
  946.                 'p.name as name',
  947.                 'p.code as productCode',
  948.                 'm.name as measurement',
  949.                 'si.totalQuantity as totalQuantity',
  950.                 'si.id as siId',
  951.                 'w.name as warehouseName',
  952.                 'mu.name as measurementUnit',
  953.                 'w.id as warehouseId',
  954.             )
  955.             ->orderBy('si.totalQuantity', 'desc');
  957.         $result = $qb->getQuery()->getResult();
  959.         $dates = $this->getDatesFromOneYear();
  960.         for ($i = 0; $i < count($result); $i++) {
  961.             foreach ($dates as $date) {
  962.                 $product = $this->productServiceImpl->getEntityId($result[$i]['productId']);
  963.                 $price = $this->salesProductsServiceImpl->getQuantityOfProductSoldBy($date['start'], $date['end'], $product, $result[$i]['warehouseId']);
  964.                 $result[$i]['quantities'][] = $price;
  965.                 $result[$i]['uuid'] = str_replace(".", "", uniqid('', true));
  966.             }
  967.         }
  968.         //        dd($result);
  969. //        dd($this->getDatesFromOneYear());
  970.         return $result;
  971.     }
  973.     #[Route('/admin/dashboard/product/sold/details/{productId}/{warehouseId}', name: 'admin_dashboard_product_sold_details')]
  974.     public function getQuantityOfSoldProductDetails(Request $request, $productId, $warehouseId)
  975.     {
  976.         $dates = $this->getDatesFromOneYear();
  977.         $product = $this->productServiceImpl->getEntityId($productId);
  978.         $warehouse = null;
  979.         if ($warehouseId != null && $warehouseId != 0) {
  980.             $warehouse = $this->warehouseService->getEntityById($warehouseId);
  981.         }
  982.         $result = [];
  983.         for ($i = 0; $i < count($dates); $i++) {
  984.             $month = DateUtil::getMonthOfTurkish((int) (new \DateTimeImmutable($dates[$i]['start']))->format('m'));
  985.             $quantity = $this->salesProductsServiceImpl->getQuantityOfProductSoldBy(
  986.                 $dates[$i]['start'],
  987.                 $dates[$i]['end'],
  988.                 $product,
  989.                 $warehouse
  990.             );
  992.             if ($quantity == null)
  993.                 $quantity = 0.00;
  994.             else
  995.                 $quantity = CurrencyHelper::roundUp($quantity);
  996.             $result[$month] = [
  997.                 'quantity' => $quantity,
  998.                 'measurement' => $product->getMeasurementUnit()->getSymbol(),
  999.                 'startDate' => $dates[$i]['start'],
  1000.                 'endDate' => $dates[$i]['end']
  1001.             ];
  1002.         }
  1005.         return new JsonResponse($result);
  1007.     }
  1009.     public function getDatesFromOneYear()
  1010.     {
  1011.         $dates = [];
  1012.         $today = new \DateTimeImmutable();
  1014.         // Son bir yıl boyunca her ay için başlangıç ve bitiş tarihi
  1015.         for ($i = 0; $i < 12; $i++) {
  1016.             // Geçmişe doğru git
  1017.             $monthStart = $today->modify("-$i month")->modify('first day of this month');
  1018.             $monthEnd = $monthStart->modify('last day of this month');
  1020.             $dates[] = [
  1021.                 'month' => 12 - $i,
  1022.                 'start' => $monthStart->format('Y-m-d'), // Başlangıç tarihi
  1023.                 'end' => $monthEnd->format('Y-m-d')     // Bitiş tarihi
  1024.             ];
  1025.         }
  1026.         return $dates;
  1028.     }
  1032.     public function getSalesBySeller($startDate = null, $finishDate = null, $products = null, $sellerIds = null, $warehouseId = null)
  1033.     {
  1035.         $year = date('Y');
  1036.         if ($startDate == null)
  1037.             $startDate = new \DateTimeImmutable('first day of january ' . $year);
  1038.         else {
  1039.             $startDate = \DateTimeImmutable::createFromFormat('Y-m-d', $startDate);
  1040.         }
  1041.         if ($finishDate == null)
  1042.             $finishDate = new \DateTimeImmutable('last day of december ' . $year);
  1043.         else {
  1044.             $finishDate = \DateTimeImmutable::createFromFormat('Y-m-d', $finishDate);
  1045.         }
  1047.         $userRepo = $this->entityManager->getRepository(User::class);
  1048.         $canSeeHidden = $this->canCurrentUserSeeHiddenSales();
  1050.         $qb = $userRepo->createQueryBuilder('u')
  1051.             ->leftJoin('u.sales', 's')
  1052.             ->leftJoin('s.warehouse', 'w')
  1053.             ->leftJoin('s.productsSolds', 'ps')
  1054.             ->leftJoin('ps.product', 'p')
  1055.             ->where('s.salesDate >= :startDate')
  1056.             ->andWhere('s.salesDate <= :finishDate')
  1057.             ->setParameter('startDate', $startDate)
  1058.             ->setParameter('finishDate', $finishDate);
  1060.         if (!$canSeeHidden) {
  1061.             $qb->andWhere('s.visible = :visible')
  1062.                 ->setParameter('visible', true);
  1063.         }
  1065.         if ($sellerIds != null) {
  1066.             $qb->andWhere(
  1067.                 $qb->expr()->in('u.id', $sellerIds)
  1068.             );
  1069.         }
  1070.         if ($products != null) {
  1071.             $qb->andWhere(
  1072.                 $qb->expr()->in('product.id', $products)
  1073.             );
  1074.         }
  1076.         if ($warehouseId != null && $warehouseId != 0) {
  1077.             $qb->andWhere(
  1078.                 $qb->expr()->eq('w.id', $warehouseId)
  1079.             );
  1080.         }
  1082.         $result = $qb->getQuery()->getResult();
  1083.         $array = [];
  1085.         /**
  1086.          * @var User $user
  1087.          */
  1088.         foreach ($result as $user) {
  1089.             $totalPurchasePrice = 0.00;
  1090.             $totalProfit = 0.00;
  1091.             foreach ($user->getSales() as $sale) {
  1092.                 if (!$canSeeHidden && !$sale->isVisible()) {
  1093.                     continue;
  1094.                 }
  1095.                 if ($sale->getSalesDate() >= $startDate && $sale->getSalesDate() <= $finishDate) {
  1096.                     foreach ($sale->getProductsSolds() as $productsSold) {
  1097.                         $totalProfit += $this->salesProductsServiceImpl->calculateProfitByProductSold($productsSold);
  1098.                         $totalPurchasePrice += $productsSold->getTotalPuchasePrice();
  1099.                     }
  1100.                 }
  1101.             }
  1102.             $array[] = [
  1103.                 'userId' => $user->getId(),
  1104.                 'startDate' => $startDate->format('d-m-Y'),
  1105.                 'finishDate' => $finishDate->format('d-m-Y'),
  1106.                 'username' => $user->getUsername(),
  1107.                 'email' => $user->getEmail(),
  1108.                 'totalPurchasePrice' => $totalPurchasePrice,
  1109.                 'totalProfit' => $this->salesServiceImpl->getTotalSalesProfitBetweenTwoDate(
  1110.                     $startDate,
  1111.                     $finishDate,
  1112.                     $warehouseId,
  1113.                     $user->getId()
  1114.                 )
  1115.             ];
  1116.         }
  1118.         return $array;
  1119.     }
  1121.     #[Route('/get-product-by-productname', name: 'get_product_by_product_name')]
  1122.     public function getProductByProductName(Request $request)
  1123.     {
  1124.         $search = $request->get('search');
  1125.         $qb = $this->entityManager->getRepository(Product::class)
  1126.             ->createQueryBuilder('p')
  1127.             ->where('p.name LIKE :s')
  1128.             ->setParameter('s', '%' . $search . '%')
  1129.             ->getQuery()
  1130.             ->getResult();
  1131.         return $this->json($qb);
  1132.     }
  1134.     #[Route('/dashboard/weeaks-earning/{warehouseId}', name: 'dashboard_week_earning')]
  1135.     public function getWeekEarningByWeek(Request $request, EntityManagerInterface $entityManager, $warehouseId)
  1136.     {
  1137.         $firstDayOfWeek = trim(explode('*', $request->get('week'))[0]);
  1138.         $lastDayOfWeek = trim(explode('*', $request->get('week'))[1]);
  1140.         $firstDayOfWeek = \DateTimeImmutable::createFromFormat('Y-m-d', $firstDayOfWeek);
  1141.         $lastDayOfWeek = \DateTimeImmutable::createFromFormat('Y-m-d', $lastDayOfWeek);
  1143.         $productsSoldRepo = $entityManager->getRepository(ProductsSold::class);
  1144.         $canSeeHidden = $this->canCurrentUserSeeHiddenSales();
  1145.         $qb = $productsSoldRepo->createQueryBuilder('c')
  1146.             ->leftJoin('c.sales', 'sales')
  1147.             ->leftJoin('c.product', 'product')
  1148.             ->where('sales.salesDate >= :firstDayOfWeek')
  1149.             ->andWhere('sales.salesDate <= :lastDayOfWeek')
  1150.             ->setParameters(
  1151.                 [
  1152.                     'firstDayOfWeek' => $firstDayOfWeek,
  1153.                     'lastDayOfWeek' => $lastDayOfWeek
  1154.                 ]
  1155.             );
  1157.         if (!$canSeeHidden) {
  1158.             $qb->andWhere('sales.visible = :visible')
  1159.                 ->setParameter('visible', true);
  1160.         }
  1162.         $qb = $qb->getQuery()->getResult();
  1164.         $period = new DatePeriod(
  1165.             date_create_from_format('Y-m-d', $firstDayOfWeek->format('Y-m-d')),
  1166.             new DateInterval('P1D'),
  1167.             date_create_from_format('Y-m-d', $lastDayOfWeek->format('Y-m-d'))->add(new DateInterval('P1D'))
  1168.         );
  1170.         $days = [];
  1171.         foreach ($period as $key => $value) {
  1172.             $days[] = $value->format('Y-m-d');
  1173.         }
  1175.         if ($warehouseId == 0)
  1176.             $warehouseId = null;
  1179.         return new JsonResponse(
  1180.             [
  1181.                 'totalEarning' => $this->salesServiceImpl->getTotalSalesPriceBetweenTwoDate(
  1182.                     $firstDayOfWeek,
  1183.                     $lastDayOfWeek,
  1184.                     $warehouseId,
  1185.                 ),
  1186.                 'totalProfit' => $this->salesServiceImpl->getTotalSalesProfitBetweenTwoDate(
  1187.                     $firstDayOfWeek,
  1188.                     $lastDayOfWeek,
  1189.                     $warehouseId,
  1190.                 ),
  1191.                 'days' => $days,
  1192.             ]
  1193.         );
  1194.     }
  1196.     #[Route('/dashboard/day-earning/{warehouseId}', name: 'dashboard_day_earning', methods: ['GET', 'POST'])]
  1197.     public function getEarningByDay(Request $request, EntityManagerInterface $entityManager, $warehouseId)
  1198.     {
  1199.         $day = $request->get('day');
  1200.         $day = \DateTimeImmutable::createFromFormat('Y-m-d', $day);
  1201.         $productsSoldRepo = $entityManager->getRepository(ProductsSold::class);
  1202.         $canSeeHidden = $this->canCurrentUserSeeHiddenSales();
  1203.         $qb = $productsSoldRepo->createQueryBuilder('c')
  1204.             ->leftJoin('c.sales', 'sales')
  1205.             ->leftJoin('c.product', 'product')
  1206.             ->where('sales.salesDate = :day')
  1207.             ->setParameter('day', $day->format('Y-m-d'));
  1209.         if (!$canSeeHidden) {
  1210.             $qb->andWhere('sales.visible = :visible')
  1211.                 ->setParameter('visible', true);
  1212.         }
  1214.         $qb = $qb->getQuery()->getResult();
  1216.         if ($warehouseId == 0)
  1217.             $warehouseId = null;
  1220.         return new JsonResponse(
  1221.             [
  1222.                 'totalEarning' => $this->salesServiceImpl->getTotalSalesPriceBetweenTwoDate(
  1223.                     $day,
  1224.                     $day,
  1225.                     $warehouseId
  1226.                 ),
  1227.                 'totalProfit' => $this->salesServiceImpl->getTotalSalesProfitBetweenTwoDate(
  1228.                     $day,
  1229.                     $day,
  1230.                     $warehouseId
  1231.                 ),
  1232.             ]
  1233.         );
  1234.     }
  1236.     #[Route('/dashboard/year-earning/{warehouseId}', name: 'dashboard_year_earning')]
  1237.     public function getEarningByYear(Request $request, EntityManagerInterface $entityManager, $warehouseId)
  1238.     {
  1239.         $year = $request->get('year');
  1241.         $firstDayOfYear = new \DateTimeImmutable('first day of january ' . $year);
  1242.         $lastDayOfYear = new \DateTimeImmutable('last day of december ' . $year . ' 23:59:59');
  1245.         //        $productsSoldRepo = $entityManager->getRepository(ProductsSold::class);
  1246. //        $qb = $productsSoldRepo->createQueryBuilder('c')
  1247. //            ->leftJoin('c.sales', 'sales')
  1248. //            ->leftJoin('c.product', 'product')
  1249. //            ->where('sales.salesDate >= :firstDayOfYear')
  1250. //            ->setParameter('firstDayOfYear',$firstDayOfYear)
  1251. //            ->andWhere('sales.salesDate <= :lastDayOfYear')
  1252. //            ->setParameter('lastDayOfYear', $lastDayOfYear);
  1253. //
  1254. //        if($request->get('all-warehouses') == null){
  1255. //
  1256. //            $qb->andWhere('sales.warehouse = :warehouse')
  1257. //                ->setParameter('warehouse',$this->warehouseService->getMainWarehouse());
  1258. //        }
  1259. //
  1260. //        $qb = $qb->getQuery()->getResult();
  1261. //
  1262. //        $totalEarningsArr = array_map(function ($val){
  1263. //            return $val->getTotalPuchasePrice();
  1264. //        }, $qb);
  1265. //
  1266. //        $totalEarning = 0.00;
  1267. //        foreach ($totalEarningsArr as $totalEarn){
  1268. //            $totalEarning += $totalEarn;
  1269. //        }
  1270. //
  1271. //        $profits = array_map(function ($val){
  1272. //            return $val->getTotalPuchasePrice() - $val->getTotalPrice();
  1273. //        },$qb);
  1274. //
  1275. //
  1276. //        $totalProfit = 0.00;
  1277. //
  1278. //        foreach ($profits as $profit){
  1279. //            $totalProfit += $profit;
  1280. //        }
  1284.         return new JsonResponse(
  1285.             [
  1286.                 'totalEarning' => $this->salesServiceImpl->getTotalSalesPriceBetweenTwoDateAndByWarehouse(
  1287.                     $firstDayOfYear,
  1288.                     $lastDayOfYear,
  1289.                     $warehouseId == 0 ? null : $warehouseId,
  1290.                 ),
  1291.                 'totalProfit' => $this->salesServiceImpl->getTotalSalesProfitBetweenTwoDate(
  1292.                     $firstDayOfYear,
  1293.                     $lastDayOfYear,
  1294.                     $warehouseId == 0 ? null : $warehouseId,
  1295.                 ),
  1296.             ]
  1297.         );
  1298.     }
  1300.     #[Route('/dashboard/month-earning/{warehouseId}', name: 'dashboard_month_earning')]
  1301.     public function getEarningByMonth(Request $request, EntityManagerInterface $entityManager, $warehouseId)
  1302.     {
  1303.         if ($request->get('year') != null) {
  1304.             $year = $request->get('year');
  1305.         } else {
  1306.             $year = date('Y');
  1307.         }
  1308.         $months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
  1309.         $month = $request->get('month');
  1311.         $firstDayOfMounth = (new \DateTimeImmutable('first day of ' . $months[$month - 1] . ' ' . $year))->format('Y-m-d');
  1312.         $lastDayOfMount = (new \DateTimeImmutable('last day of ' . $months[$month - 1] . ' ' . $year))->format('Y-m-d');
  1315.         $firstWeekStartDay = $firstDayOfMounth;
  1316.         $firstWeekFinishDay = (new \DateTime('+6 days ' . $firstDayOfMounth . ' ' . $year))->format('Y-m-d');
  1318.         $secondWeekStartDay = (new \DateTime('+1 days ' . $firstWeekFinishDay . ' ' . $year))->format('Y-m-d');
  1319.         $secondWeekFinishDay = (new \DateTime('+6 days ' . $secondWeekStartDay . ' ' . $year))->format('Y-m-d');
  1321.         $thirdWeekStartDay = (new \DateTime('+1 days ' . $secondWeekFinishDay . ' ' . $year))->format('Y-m-d');
  1322.         $thirdWeekFinishDay = (new \DateTime('+6 days ' . $thirdWeekStartDay . ' ' . $year))->format('Y-m-d');
  1324.         $fourthWeekStartDate = (new \DateTime('+1 days ' . $thirdWeekFinishDay . ' ' . $year))->format('Y-m-d');
  1325.         $fourthWeekFinishDate = $lastDayOfMount;
  1328.         $firstWeek = $firstWeekStartDay . " * " . $firstWeekFinishDay;
  1329.         $secondWeek = $secondWeekStartDay . " * " . $secondWeekFinishDay;
  1330.         $thirdWeek = $thirdWeekStartDay . " * " . $thirdWeekFinishDay;
  1331.         $fourthWeek = $fourthWeekStartDate . " * " . $fourthWeekFinishDate;
  1334.         $productsSoldRepo = $entityManager->getRepository(ProductsSold::class);
  1335.         $canSeeHidden = $this->canCurrentUserSeeHiddenSales();
  1336.         $qb = $productsSoldRepo->createQueryBuilder('c')
  1337.             ->leftJoin('c.sales', 'sales')
  1338.             ->leftJoin('c.product', 'product')
  1339.             ->where('sales.salesDate >= :firstDayOfMonth')
  1340.             ->andWhere('sales.salesDate <= :lastDayOfMonth')
  1341.             ->setParameters(
  1342.                 [
  1343.                     'firstDayOfMonth' => $firstDayOfMounth,
  1344.                     'lastDayOfMonth' => $lastDayOfMount
  1345.                 ]
  1346.             )
  1347.             ->orderBy('sales.salesDate', 'DESC');
  1349.         if (!$canSeeHidden) {
  1350.             $qb->andWhere('sales.visible = :visible')
  1351.                 ->setParameter('visible', true);
  1352.         }
  1354.         $qb = $qb->getQuery()->getResult();
  1356.         $data = [];
  1358.         foreach ($qb as $val) {
  1359.             $data[] = [
  1360.                 $val->getProduct()->getCode(),
  1361.                 $val->getProductName(),
  1362.                 $val->getQuantity(),
  1363.                 $val->getUnitPriceFob(),
  1364.                 $val->getUnitPriceNavlun(),
  1365.                 $val->getTotalUnitPrice(),
  1366.                 $val->getTotalPrice(),
  1367.                 $val->getTotalPuchasePrice()
  1368.             ];
  1369.         }
  1372.         $startDate = (new \DateTimeImmutable('first day of ' . $months[$month - 1] . ' ' . $year));
  1373.         $finishDate = (new \DateTimeImmutable('last day of ' . $months[$month - 1] . ' ' . $year));
  1375.         if ($warehouseId == 0)
  1376.             $warehouseId = null;
  1378.         return new JsonResponse(
  1379.             [
  1380.                 'profit' => $this->salesServiceImpl->getTotalSalesProfitBetweenTwoDate($startDate, $finishDate, $warehouseId),
  1381.                 'totalPrices' => $this->salesServiceImpl->getTotalSalesPriceBetweenTwoDate($startDate, $finishDate, $warehouseId),
  1382.                 'data' => $data,
  1383.                 'firstWeek' => $firstWeek,
  1384.                 'secondWeek' => $secondWeek,
  1385.                 'thirdWeek' => $thirdWeek,
  1386.                 'fourthWeek' => $fourthWeek
  1387.             ]
  1388.         );
  1389.     }
  1391.     private function getProductsByPeriot($startdate, $finishDate, $product, $warehouse, $seller)
  1392.     {
  1393.         $repo = $this->entityManager->getRepository(Sales::class);
  1394.         $canSeeHidden = $this->canCurrentUserSeeHiddenSales();
  1395.         $result = $repo->createQueryBuilder('c')
  1396.             ->leftJoin('c.productsSolds', 'productsSolds')
  1397.             ->leftJoin('productsSolds.product', 'product')
  1398.             ->leftJoin('c.warehouse', 'warehouse');
  1399.         if ($startdate != null) {
  1400.             $result->where('c.salesDate >= :startDate')
  1401.                 ->setParameter('startDate', $startdate);
  1402.         }
  1403.         if ($finishDate != null) {
  1404.             $result->andWhere('c.salesDate <= :finishDate')
  1405.                 ->setParameter('finishDate', $finishDate);
  1406.         }
  1407.         if ($product != 0) {
  1408.             $result->andWhere('product.id = :product')
  1409.                 ->setParameter('product', $product);
  1410.         }
  1411.         if ($warehouse != null) {
  1412.             $result->andWhere('warehouse.id = :warehouseId')
  1413.                 ->setParameter('warehouseId', $warehouse);
  1414.         }
  1415.         if ($seller != 0) {
  1416.             $result->andWhere('c.seller = :seller')
  1417.                 ->setParameter('seller', $seller);
  1418.         }
  1419.         if (!$canSeeHidden) {
  1420.             $result->andWhere('c.visible = :visible')
  1421.                 ->setParameter('visible', true);
  1422.         }
  1423.         $result
  1424.             ->select(['product.name as productName', 'sum(c.totalPurchasePrice) totalAmount']);
  1425.         return $result->getQuery()->getResult();
  1426.     }
  1428.     private function canCurrentUserSeeHiddenSales(): bool
  1429.     {
  1430.         $user = $this->getUser();
  1432.         if (!$user) {
  1433.             return false;
  1434.         }
  1436.         $identifier = null;
  1437.         if (method_exists($user, 'getUserIdentifier')) {
  1438.             $identifier = $user->getUserIdentifier();
  1439.         } elseif (method_exists($user, 'getUsername')) {
  1440.             $identifier = $user->getUsername();
  1441.         }
  1443.         if ($identifier === null) {
  1444.             return false;
  1445.         }
  1447.         return in_array(strtolower((string) $identifier), ['gizli@kullanici.com', 'azad@azad.com']);
  1448.     }
  1450.     #[Route('/{locale}', name: 'app_change_locale', priority: -10)]
  1451.     public function changeLocale(Request $request, $locale, RouterInterface $router)
  1452.     {
  1453.         $params = $this->getRefererParams($request, $router);
  1455.         $locales = $this->getParameter('kernel.enabled_locales');
  1456.         if (in_array($locale, $locales)) {
  1457.             if ($this->getUser())
  1458.                 $this->userService->changeLocale($this->getUser(), $locale);
  1459.             $request->getSession()->set('_locale', $locale);
  1460.             return $this->redirect($params);
  1461.         }
  1462.         $this->createNotFoundException(printf('%s locale is not avaible', $locale));
  1463.         return $this->redirectToRoute('app_panel_dashboard');
  1464.     }
  1470.     #[Route('/dashboard/product-sales-2025-ajax', name: 'get_product_sales_2025_ajax')]
  1471.     public function getProductSales2025Ajax(Request $request, ProductRepository $productRepository, ProductMonthlyStatsRepository $statsRepo, \App\Service\Analysis\SalesSeasonalityService $seasonalityService, \App\Repository\SettingsRepository $settingsRepository, \App\Service\Analysis\StrategicForecastingService $forecastingService): JsonResponse
  1472.     {
  1473.         // Client-side DataTable - tüm veriyi döndürüyoruz (pagination yok)
  1474.         $searchParams = $_GET['search'] ?? [];
  1475.         $searchValue = $searchParams['value'] ?? null;
  1477.         $qb = $productRepository->createQueryBuilder('p')
  1478.             ->leftJoin(\App\Entity\ProductMonthlyStats::class, 's', \Doctrine\ORM\Query\Expr\Join::WITH, 's.product = p.id AND s.year = 2025')
  1479.             ->leftJoin('p.measurementUnit', 'mu')
  1480.             ->groupBy('p.id')
  1481.             ->select('p.id', 'p.name', 'p.code', 'mu.symbol as unitSymbol')
  1482.             ->addSelect('SUM(CASE WHEN s.month = 1 THEN s.totalSalesQty ELSE 0 END) as m1')
  1483.             ->addSelect('SUM(CASE WHEN s.month = 2 THEN s.totalSalesQty ELSE 0 END) as m2')
  1484.             ->addSelect('SUM(CASE WHEN s.month = 3 THEN s.totalSalesQty ELSE 0 END) as m3')
  1485.             ->addSelect('SUM(CASE WHEN s.month = 4 THEN s.totalSalesQty ELSE 0 END) as m4')
  1486.             ->addSelect('SUM(CASE WHEN s.month = 5 THEN s.totalSalesQty ELSE 0 END) as m5')
  1487.             ->addSelect('SUM(CASE WHEN s.month = 6 THEN s.totalSalesQty ELSE 0 END) as m6')
  1488.             ->addSelect('SUM(CASE WHEN s.month = 7 THEN s.totalSalesQty ELSE 0 END) as m7')
  1489.             ->addSelect('SUM(CASE WHEN s.month = 8 THEN s.totalSalesQty ELSE 0 END) as m8')
  1490.             ->addSelect('SUM(CASE WHEN s.month = 9 THEN s.totalSalesQty ELSE 0 END) as m9')
  1491.             ->addSelect('SUM(CASE WHEN s.month = 10 THEN s.totalSalesQty ELSE 0 END) as m10')
  1492.             ->addSelect('SUM(CASE WHEN s.month = 11 THEN s.totalSalesQty ELSE 0 END) as m11')
  1493.             ->addSelect('SUM(CASE WHEN s.month = 12 THEN s.totalSalesQty ELSE 0 END) as m12')
  1494.             ->addSelect('SUM(s.totalSalesQty) as total');
  1496.         // Arama Filtresi (opsiyonel - client-side yapıyor ama server-side de filtre olabilir)
  1497.         if ($searchValue) {
  1498.             $qb->where('p.name LIKE :search OR p.code LIKE :search')
  1499.                 ->setParameter('search', '%' . $searchValue . '%');
  1500.         }
  1502.         // Varsayılan sıralama
  1503.         $qb->orderBy('total', 'DESC');
  1505.         // TÜM VERİYİ ÇEK (Client-side için pagination yok)
  1506.         $dbResults = $qb->getQuery()->getResult();
  1508.         // --- STOK VERİSİNİ OPTİMİZE EDEREK ÇEKME (Bulk Fetch) ---
  1509.         $productIds = [];
  1510.         foreach ($dbResults as $r) {
  1511.             $productIds[] = $r['id'];
  1512.         }
  1514.         $stockMap = [];
  1515.         if (!empty($productIds)) {
  1516.             $stockResults = $this->entityManager->getRepository(\App\Entity\StockInfo::class)->createQueryBuilder('si')
  1517.                 ->select('IDENTITY(si.product) as pid, SUM(si.totalQuantity) as totalStock')
  1518.                 ->where('si.product IN (:pids)')
  1519.                 ->setParameter('pids', $productIds)
  1520.                 ->groupBy('si.product')
  1521.                 ->getQuery()
  1522.                 ->getResult();
  1524.             foreach ($stockResults as $sr) {
  1525.                 $stockMap[$sr['pid']] = (float) $sr['totalStock'];
  1526.             }
  1527.         }
  1528.         // --------------------------------------------------------
  1530.         // Para Birimi Ayarlarını Çek
  1531.         $settings = $settingsRepository->findOneBy([]);
  1532.         $currencyCode = $settings ? $settings->getCurrency() : 'EUR';
  1533.         $currencySymbol = match ($currencyCode) {
  1534.             'EUR' => '€',
  1535.             'USD' => '$',
  1536.             'TRY', 'TL' => '₺',
  1537.             'GBP' => '£',
  1538.             default => $currencyCode
  1539.         };
  1541.         // Verileri İşle ve Ham Haliyle Hazırla
  1542.         $processedRows = [];
  1543.         $stockRepo = $this->entityManager->getRepository(\App\Entity\Stock::class);
  1545.         foreach ($dbResults as $row) {
  1546.             $currentStock = $stockMap[$row['id']] ?? 0;
  1548.             // --- UNIT PRICE HESAPLAMA (Son 6 Girişin Ortalaması) ---
  1549.             // N+1 olacak ama şimdilik en güvenilir yöntem.
  1550.             // İleride performans sorunu olursa Native SQL ile optimize edilebilir.
  1551.             $lastStocks = $stockRepo->findBy(
  1552.                 ['product' => $row['id']],
  1553.                 ['buyingDate' => 'DESC'],
  1554.                 6
  1555.             );
  1557.             $averageUnitPrice = 0;
  1558.             if (count($lastStocks) > 0) {
  1559.                 $totalPriceSum = 0;
  1560.                 foreach ($lastStocks as $stockItem) {
  1561.                     $totalPriceSum += $stockItem->getTotalUnitPrice();
  1562.                 }
  1563.                 $averageUnitPrice = $totalPriceSum / count($lastStocks);
  1564.             }
  1565.             $row['unitPrice'] = $averageUnitPrice;
  1566.             // -------------------------------------------------------
  1568.             // Mevsimsellik Analizi Verileri
  1569.             $monthlySalesVars = [];
  1570.             for ($k = 1; $k <= 12; $k++) {
  1571.                 $monthlySalesVars[$k] = (float) $row['m' . $k];
  1572.             }
  1574.             // Stok Ömrü Hesaplama
  1575.             $stockDurationDays = 0;
  1576.             if ($currentStock <= 0) {
  1577.                 $stockDurationDays = -1; // Tükendi
  1578.             } else {
  1579.                 $totalAnnualSales = array_sum($monthlySalesVars);
  1580.                 if ($totalAnnualSales <= 0) {
  1581.                     $stockDurationDays = 99999; // Sonsuz
  1582.                 } else {
  1583.                     $tempStock = $currentStock;
  1584.                     $daysAccumulated = 0;
  1585.                     $calcMonthIndex = (int) date('n');
  1586.                     $calcCurrentDay = (int) date('j');
  1587.                     $safetyBreak = 730;
  1589.                     while ($tempStock > 0 && $daysAccumulated < $safetyBreak) {
  1590.                         $monthlySales = $monthlySalesVars[$calcMonthIndex];
  1591.                         $daysInMonth = 30;
  1593.                         if ($daysAccumulated == 0) {
  1594.                             $daysRemaining = max(0, $daysInMonth - $calcCurrentDay);
  1595.                         } else {
  1596.                             $daysRemaining = $daysInMonth;
  1597.                         }
  1599.                         $dailyRate = $monthlySales / $daysInMonth;
  1600.                         $needed = $dailyRate * $daysRemaining;
  1602.                         if ($needed <= 0) {
  1603.                             $daysAccumulated += $daysRemaining;
  1604.                         } else {
  1605.                             if ($tempStock >= $needed) {
  1606.                                 $tempStock -= $needed;
  1607.                                 $daysAccumulated += $daysRemaining;
  1608.                             } else {
  1609.                                 $daysLasted = ($dailyRate > 0) ? ($tempStock / $dailyRate) : 0;
  1610.                                 $daysAccumulated += $daysLasted;
  1611.                                 $tempStock = 0;
  1612.                                 break;
  1613.                             }
  1614.                         }
  1615.                         $calcMonthIndex++;
  1616.                         if ($calcMonthIndex > 12)
  1617.                             $calcMonthIndex = 1;
  1618.                     }
  1619.                     $stockDurationDays = $daysAccumulated;
  1620.                 }
  1621.             }
  1623.             $processedRows[] = [
  1624.                 'dbRow' => $row,
  1625.                 'currentStock' => $currentStock,
  1626.                 'stockDurationDays' => $stockDurationDays,
  1627.                 'indices' => $seasonalityService->calculateSeasonalityIndices($monthlySalesVars),
  1628.                 'monthlySalesVars' => $monthlySalesVars
  1629.             ];
  1630.         }
  1632.         // Client-side DataTable - PHP tarafında sıralama veya pagination yok
  1633.         // Tüm veri işlenip döndürülüyor
  1635.         $data = [];
  1636.         $currentMonth = (int) date('n');
  1638.         foreach ($processedRows as $pRow) {
  1639.             $row = $pRow['dbRow'];
  1640.             $currentStock = $pRow['currentStock'];
  1641.             $stockDurationDays = $pRow['stockDurationDays'];
  1642.             $indices = $pRow['indices'];
  1643.             $monthlySalesVars = $pRow['monthlySalesVars'];
  1645.             $unitSymbol = $row['unitSymbol'] ?? '';
  1647.             // Client-side sorting için orthogonal data formatı: { display: HTML, sort: numeric }
  1648.             $item = [
  1649.                 'name' => [
  1650.                     'display' => '<strong>' . htmlspecialchars($row['name']) . '</strong><br><small class="text-muted">' . htmlspecialchars($row['code']) . '</small>',
  1651.                     'sort' => $row['name']
  1652.                 ],
  1653.             ];
  1655.             $item['currentStock'] = [
  1656.                 'display' => '<span class="badge badge-info" style="font-size: 0.9rem;">' . number_format($currentStock, 0, ',', '.') . ' ' . $unitSymbol . '</span>',
  1657.                 'sort' => (int) $currentStock
  1658.             ];
  1660.             // Stok Süresi Görselleştirme
  1661.             $stockDurationHtml = '';
  1662.             $stockStatus = 'success'; // default: yeşil (iyi durum)
  1664.             if ($stockDurationDays == -1) {
  1665.                 $stockDurationHtml = '<span class="badge badge-secondary" style="background-color: #333;">Tükendi</span>';
  1666.                 $stockStatus = 'empty';
  1667.             } elseif ($stockDurationDays == 99999) {
  1668.                 $stockDurationHtml = '<span class="badge badge-secondary">∞ (Satış Yok)</span>';
  1669.                 $stockStatus = 'noSales';
  1670.             } else {
  1671.                 $badgeClass = 'badge-success'; // > 90 gün
  1672.                 if ($stockDurationDays < 45) { // < 45 gün KIRMIZI
  1673.                     $badgeClass = 'badge-danger';
  1674.                     $stockStatus = 'danger';
  1675.                 } elseif ($stockDurationDays < 90) { // 45-90 gün SARI
  1676.                     $badgeClass = 'badge-warning';
  1677.                     $stockStatus = 'warning';
  1678.                 }
  1680.                 $displayDays = $stockDurationDays >= 730 ? '> 2 Yıl' : number_format($stockDurationDays, 0) . ' Gün';
  1681.                 $stockDurationHtml = '<span class="badge ' . $badgeClass . '">' . $displayDays . '</span>';
  1682.             }
  1684.             // Sıralama için mantıklı değerler:
  1685.             // Tükendi (-1) → 0 (en kritik, en üstte olmalı)
  1686.             // Normal değerler → gerçek gün sayısı
  1687.             // Satış Yok (99999) → 999999 (sonsuz, en altta olmalı)
  1688.             $sortValue = $stockDurationDays;
  1689.             if ($stockDurationDays == -1) {
  1690.                 $sortValue = 0; // Tükendi = en kritik
  1691.             } elseif ($stockDurationDays == 99999) {
  1692.                 $sortValue = 999999; // Satış yok = pratik olarak sonsuz
  1693.             }
  1695.             $item['stockDuration'] = [
  1696.                 'display' => $stockDurationHtml,
  1697.                 'sort' => $sortValue,
  1698.                 'status' => $stockStatus // Filtreleme için: empty, noSales, danger, warning, success
  1699.             ];
  1701.             // Filtreleme için ek metadata
  1702.             $item['_meta'] = [
  1703.                 'stockStatus' => $stockStatus,
  1704.                 'stockValue' => (int) $currentStock,
  1705.                 'productName' => $row['name'],
  1706.                 'productCode' => $row['code']
  1707.             ];
  1709.             // Ayları ekle
  1710.             for ($i = 1; $i <= 12; $i++) {
  1711.                 $val = $monthlySalesVars[$i];
  1712.                 $idx = $indices[$i];
  1714.                 $style = '';
  1715.                 if ($i < $currentMonth) {
  1716.                     $style = 'background-color: #ffebee; color: #c62828;';
  1717.                 } elseif ($i === $currentMonth) {
  1718.                     $style = 'background-color: #e8f5e9; color: #2e7d32;';
  1719.                 }
  1721.                 if ($val > 0) {
  1722.                     $formattedVal = number_format($val, 0, ',', '.');
  1723.                     $formattedIdx = number_format($idx, 2);
  1724.                     $content = $formattedVal . ' <small style="font-size: 0.7em; opacity: 0.8;">/ ' . $formattedIdx . 'x</small>';
  1725.                 } else {
  1726.                     $content = '<span style="opacity: 0.5;">-</span>';
  1727.                 }
  1729.                 if ($style !== '') {
  1730.                     $displayContent = '<div style="' . $style . ' border-radius: 5px; padding: 6px 0;">' . $content . '</div>';
  1731.                 } else {
  1732.                     $displayContent = $content;
  1733.                 }
  1735.                 $item['m' . $i] = [
  1736.                     'display' => $displayContent,
  1737.                     'sort' => (float) $val
  1738.                 ];
  1739.             }
  1741.             // Toplam
  1742.             $total = (float) $row['total'];
  1743.             $item['total'] = [
  1744.                 'display' => '<span class="font-weight-bold text-primary">' . number_format($total, 0, ',', '.') . '</span>',
  1745.                 'sort' => $total
  1746.             ];
  1748.             // --- TAVSİYE EDİLEN STOK ALIMI ve MALİYETİ ---
  1749.             // --- TAVSİYE EDİLEN STOK ALIMI ve MALİYETİ (Merkezi Mantık) ---
  1750.             $unitPrice = (float) $row['unitPrice'];
  1752.             // Mevcut ay ve sonraki 2 ayın taleplerini al (Döngüsel)
  1753.             $getDemand = function ($m) use ($monthlySalesVars) {
  1754.                 $idx = (($m - 1) % 12) + 1;
  1755.                 return $monthlySalesVars[$idx] ?? 0;
  1756.             };
  1758.             $d1 = $getDemand($currentMonth);
  1759.             $d2 = $getDemand($currentMonth + 1);
  1760.             $d3 = $getDemand($currentMonth + 2);
  1762.             // Merkezi Servis ile Analiz
  1763.             $stockAnalysis = $forecastingService->checkStockStatus((float) $currentStock, $d1, $d2, $d3, $unitPrice);
  1765.             $suggestedOrderQty = $stockAnalysis['order_qty'];
  1766.             $suggestedOrderCost = $stockAnalysis['order_cost'];
  1767.             $coverageDateStr = '';
  1769.             if ($suggestedOrderQty > 0) {
  1770.                 // Tooltip için tarih hesapla: Bugün + 3 ay
  1771.                 $targetDate = new \DateTime();
  1772.                 $targetDate->modify('+3 months');
  1773.                 $coverageDateStr = $targetDate->format('d.m.Y');
  1774.             }
  1776.             // 1. Tavsiye Edilen Stok Alımı (Tooltip ile)
  1777.             $tooltipAttr = $suggestedOrderQty > 0 ? 'data-toggle="tooltip" title="' . $coverageDateStr . ' tarihine kadar yeterli"' : '';
  1778.             $style = $suggestedOrderQty > 0 ? 'color: #e74a3b; font-size:1.1em; cursor:help;' : 'text-muted';
  1779.             $valInfo = $suggestedOrderQty > 0 ? number_format($suggestedOrderQty, 0, ',', '.') : '-';
  1781.             $item['suggestedOrderQty'] = [
  1782.                 'display' => '<span class="font-weight-bold" ' . $tooltipAttr . ' style="' . $style . '">' . $valInfo . '</span>',
  1783.                 'sort' => $suggestedOrderQty
  1784.             ];
  1786.             // 2. Tavsiye Edilen Stok Maliyeti (Yeni Sütun)
  1787.             $item['suggestedOrderCost'] = [
  1788.                 'display' => $suggestedOrderCost > 0 ? '<span class="text-danger">' . number_format($suggestedOrderCost, 2, ',', '.') . ' ' . $currencySymbol . '</span>' : '-',
  1789.                 'sort' => $suggestedOrderCost
  1790.             ];
  1792.             // 3. Birim Maliyet (Yeni Sütun)
  1793.             $item['unitPrice'] = [
  1794.                 'display' => number_format($unitPrice, 2, ',', '.') . ' ' . $currencySymbol,
  1795.                 'sort' => $unitPrice
  1796.             ];
  1798.             $data[] = $item;
  1799.         }
  1801.         // Client-side DataTable için sadece data array döndürülüyor
  1802.         return new JsonResponse([
  1803.             'data' => $data
  1804.         ]);
  1805.     }
  1807.     /**
  1808.      * AJAX endpoint for monthly stock purchase detail (used in budget planning info popup)
  1809.      */
  1810.     #[Route('/admin/dashboard/stock-purchase-detail/{month}', name: 'admin_dashboard_stock_purchase_detail', methods: ['GET'])]
  1811.     public function getStockPurchaseDetail(int $month, FinancialForecastingService $financialService): JsonResponse
  1812.     {
  1813.         // Validate month
  1814.         if ($month < 1 || $month > 12) {
  1815.             return new JsonResponse(['error' => 'Invalid month'], 400);
  1816.         }
  1818.         $detail = $financialService->getMonthlyStockPurchaseDetail(2025, 2026, $month, true);
  1820.         return new JsonResponse($detail);
  1821.     }
  1823.     /**
  1824.      * AJAX endpoint for 2026 Stock & Order Simulation data (for DataTables on Dashboard)
  1825.      */
  1826.     #[Route('/admin/api/stock-simulation-data', name: 'app_dashboard_stock_simulation_data', methods: ['GET'])]
  1827.     public function getStockSimulationData(\App\Service\Analysis\StrategicForecastingService $forecastingService): JsonResponse
  1828.     {
  1829.         // Generate forecast data
  1830.         $forecastData = $forecastingService->generateForecast(2025, 2026);
  1831.         $forecasts = $forecastData['product_forecasts'];
  1833.         $data = [];
  1835.         foreach ($forecasts as $pid => $product) {
  1836.             $row = [
  1837.                 'product_code' => $product['code'],
  1838.                 'product_name' => $product['name'],
  1839.             ];
  1841.             // Add monthly data
  1842.             $totalSales2025 = 0;
  1843.             for ($month = 1; $month <= 12; $month++) {
  1844.                 $plan = $product['plan'][$month] ?? [];
  1845.                 $demand = (int) ($plan['demand'] ?? 0);
  1846.                 $row['month_' . $month . '_stock'] = (int) ($plan['stock_end'] ?? 0);
  1847.                 $row['month_' . $month . '_demand'] = $demand;
  1848.                 $row['month_' . $month . '_order'] = (int) ($plan['order_qty'] ?? 0);
  1849.                 $row['month_' . $month . '_status'] = $plan['status'] ?? 'secure';
  1851.                 $totalSales2025 += $demand;
  1852.             }
  1854.             $row['total_sales_2025'] = $totalSales2025;
  1856.             $data[] = $row;
  1857.         }
  1859.         return new JsonResponse(['data' => $data]);
  1860.     }
  1862.     /**
  1863.      * AJAX endpoint for Yearly Plan Table data
  1864.      * Veri Kaynakları:
  1865.      * - Yıllık Satılan: product_monthly_stats.total_sales_qty (SUM for year)
  1866.      * - Mevcut Stok: stock_info.total_quantity (SUM)
  1867.      * - Birim Fiyat: product_monthly_stats.avg_cost_price (Ağırlıklı ortalama)
  1868.      */
  1869.     #[Route('/admin/api/yearly-plan-data', name: 'app_dashboard_yearly_plan_data', methods: ['GET'])]
  1870.     public function getYearlyPlanData(ProductMonthlyStatsRepository $statsRepository): JsonResponse
  1871.     {
  1872.         // 2025 yılı için tüm ürünlerin aylık istatistiklerini al
  1873.         $allStats = $statsRepository->findBy(['year' => 2025]);
  1875.         // Ürün bazlı verileri topla
  1876.         $productData = [];
  1878.         foreach ($allStats as $stat) {
  1879.             $product = $stat->getProduct();
  1880.             if ($product === null) {
  1881.                 continue;
  1882.             }
  1884.             $pId = $product->getId();
  1886.             if (!isset($productData[$pId])) {
  1887.                 // Mevcut stok: StockInfo tablosundan
  1888.                 $currentStock = 0;
  1889.                 foreach ($product->getStockInfos() as $stockInfo) {
  1890.                     $currentStock += $stockInfo->getTotalQuantity();
  1891.                 }
  1893.                 $productData[$pId] = [
  1894.                     'id' => $pId,
  1895.                     'name' => $product->getName(),
  1896.                     'code' => $product->getCode(),
  1897.                     'currentStock' => (float) $currentStock,
  1898.                     'totalSales' => 0,
  1899.                     'totalCostSum' => 0,
  1900.                     'totalQtyForCost' => 0,
  1901.                 ];
  1902.             }
  1904.             $m = $stat->getMonth();
  1905.             if ($m >= 1 && $m <= 12) {
  1906.                 $qty = (float) $stat->getTotalSalesQty();
  1907.                 $avgCostPrice = (float) $stat->getAvgCostPrice();
  1909.                 $productData[$pId]['totalSales'] += $qty;
  1911.                 // Ağırlıklı ortalama maliyet hesabı için
  1912.                 if ($qty > 0 && $avgCostPrice > 0) {
  1913.                     $productData[$pId]['totalCostSum'] += ($qty * $avgCostPrice);
  1914.                     $productData[$pId]['totalQtyForCost'] += $qty;
  1915.                 }
  1916.             }
  1917.         }
  1919.         // Hesaplamaları yap ve sonuç dizisini oluştur
  1920.         $result = [];
  1922.         foreach ($productData as $pId => $data) {
  1923.             $yearlySales = $data['totalSales'];
  1924.             $currentStock = $data['currentStock'];
  1926.             // Birim Fiyat: Ağırlıklı ortalama
  1927.             $unitPrice = 0;
  1928.             if ($data['totalQtyForCost'] > 0) {
  1929.                 $unitPrice = $data['totalCostSum'] / $data['totalQtyForCost'];
  1930.             }
  1932.             // Hesaplamalar
  1933.             $salesMinusStock = $yearlySales - $currentStock;
  1934.             $orderQty = max(0, ceil($salesMinusStock));
  1935.             $totalCost = $orderQty * $unitPrice;
  1937.             $result[] = [
  1938.                 'id' => $pId,
  1939.                 'name' => $data['name'],
  1940.                 'code' => $data['code'],
  1941.                 'yearlySales' => ceil($yearlySales),        // Yıllık Satılan
  1942.                 'currentStock' => $currentStock,             // Mevcut Stok
  1943.                 'salesMinusStock' => ceil($salesMinusStock), // Satılan - Stok
  1944.                 'orderQty' => $orderQty,                     // Sipariş Miktarı
  1945.                 'unitPrice' => round($unitPrice, 2),         // Birim Fiyat
  1946.                 'totalCost' => round($totalCost, 2),         // Toplam
  1947.             ];
  1948.         }
  1950.         // Yıllık satışa göre sırala (çoktan aza)
  1951.         usort($result, function ($a, $b) {
  1952.             return $b['yearlySales'] <=> $a['yearlySales'];
  1953.         });
  1955.         return new JsonResponse(['data' => $result]);
  1956.     }
  1958.     /**
  1959.      * AJAX endpoint for Monthly Plan Table data
  1960.      * Seçilen ay için ürün bazlı satış ve sipariş planı
  1961.      * Yıllık satışa göre sıralanır (en çoktan en aza)
  1962.      */
  1963.     #[Route('/admin/api/monthly-plan-data/{month}', name: 'app_dashboard_monthly_plan_data', methods: ['GET'])]
  1964.     public function getMonthlyPlanData(int $month, ProductMonthlyStatsRepository $statsRepository): JsonResponse
  1965.     {
  1966.         // Validate month
  1967.         if ($month < 1 || $month > 12) {
  1968.             return new JsonResponse(['error' => 'Invalid month'], 400);
  1969.         }
  1971.         // 2025 yılı için tüm ürünlerin aylık istatistiklerini al
  1972.         $allStats = $statsRepository->findBy(['year' => 2025]);
  1974.         // Ürün bazlı verileri topla
  1975.         $productData = [];
  1977.         foreach ($allStats as $stat) {
  1978.             $product = $stat->getProduct();
  1979.             if ($product === null) {
  1980.                 continue;
  1981.             }
  1983.             $pId = $product->getId();
  1985.             if (!isset($productData[$pId])) {
  1986.                 // Mevcut stok: StockInfo tablosundan
  1987.                 $currentStock = 0;
  1988.                 foreach ($product->getStockInfos() as $stockInfo) {
  1989.                     $currentStock += $stockInfo->getTotalQuantity();
  1990.                 }
  1992.                 $productData[$pId] = [
  1993.                     'id' => $pId,
  1994.                     'name' => $product->getName(),
  1995.                     'code' => $product->getCode(),
  1996.                     'currentStock' => (float) $currentStock,
  1997.                     'yearlySales' => 0,
  1998.                     'monthlySales' => 0,
  1999.                     'monthlyUnitPrice' => 0,
  2000.                 ];
  2001.             }
  2003.             $m = $stat->getMonth();
  2004.             $qty = (float) $stat->getTotalSalesQty();
  2005.             $avgCostPrice = (float) $stat->getAvgCostPrice();
  2007.             // Yıllık toplam satış
  2008.             if ($m >= 1 && $m <= 12) {
  2009.                 $productData[$pId]['yearlySales'] += $qty;
  2010.             }
  2012.             // Seçilen ay için satış
  2013.             if ($m === $month) {
  2014.                 $productData[$pId]['monthlySales'] = $qty;
  2015.                 $productData[$pId]['monthlyUnitPrice'] = $avgCostPrice;
  2016.             }
  2017.         }
  2019.         // Hesaplamaları yap ve sonuç dizisini oluştur
  2020.         $result = [];
  2022.         foreach ($productData as $pId => $data) {
  2023.             $monthlySales = $data['monthlySales'];
  2024.             $currentStock = $data['currentStock'];
  2025.             $unitPrice = $data['monthlyUnitPrice'];
  2027.             // Hesaplamalar
  2028.             $stockMinusSales = $currentStock - $monthlySales;
  2029.             $orderQty = max(0, ceil($monthlySales - $currentStock));
  2030.             $totalCost = $orderQty * $unitPrice;
  2032.             $result[] = [
  2033.                 'id' => $pId,
  2034.                 'name' => $data['name'],
  2035.                 'code' => $data['code'],
  2036.                 'currentStock' => $currentStock,             // Mevcut Stok
  2037.                 'monthlySales' => ceil($monthlySales),       // Aylık Satılan
  2038.                 'stockMinusSales' => ceil($stockMinusSales), // Stok - Satılan
  2039.                 'unitPrice' => round($unitPrice, 2),         // Birim Fiyat
  2040.                 'orderQty' => $orderQty,                     // Sipariş Miktarı
  2041.                 'totalCost' => round($totalCost, 2),         // Toplam
  2042.                 'yearlySales' => ceil($data['yearlySales']), // Sıralama için
  2043.             ];
  2044.         }
  2046.         // Yıllık satışa göre sırala (çoktan aza)
  2047.         usort($result, function ($a, $b) {
  2048.             return $b['yearlySales'] <=> $a['yearlySales'];
  2049.         });
  2051.         return new JsonResponse(['data' => $result]);
  2052.     }
  2054.     #[Route('/monthly-plan/{month}', name: 'app_dashboard_monthly_plan_data', methods: ['GET'])]
  2055.     public function getMonthlyOrderPlan(int $month, ProductMonthlyStatsRepository $statsRepository, \Symfony\Component\HttpFoundation\Request $request): JsonResponse
  2056.     {
  2057.         $filterName = $request->query->get('name');
  2058.         $filterCodes = $request->query->all()['codes'] ?? [];
  2059.         $filterMeasurements = $request->query->all()['measurements'] ?? [];
  2060.         $filterUnits = $request->query->all()['units'] ?? [];
  2062.         // 1. Fetch all 2025 stats
  2063.         $allStats2025 = $statsRepository->findBy(['year' => 2025]);
  2065.         // 2. Group by Product
  2066.         $productData = [];
  2068.         foreach ($allStats2025 as $stat) {
  2069.             $product = $stat->getProduct();
  2070.             // Skip if product is null OR if it has no measurement unit
  2071.             if ($product === null || $product->getMeasurementUnit() === null) {
  2072.                 continue;
  2073.             }
  2075.             $code = $product->getCode();
  2076.             $key = $code ? strtoupper(trim($code)) : $product->getId();
  2078.             if (!isset($productData[$key])) {
  2079.                 $productData[$key] = [
  2080.                     'name' => $product->getName(),
  2081.                     'code' => $product->getCode(),
  2082.                     'currentStock' => 0,
  2083.                     'total2025' => 0,
  2084.                     'monthlySales' => 0, // Sales for the requested month
  2086.                     'totalCostSum' => 0,
  2087.                     'totalQtyForCost' => 0,
  2088.                     'seen_pids' => [],
  2089.                     'measurement' => $product->getMeasurement() ? $product->getMeasurement()->getMeasurement() : '',
  2090.                     'measurementId' => $product->getMeasurement() ? $product->getMeasurement()->getId() : null,
  2091.                     'unitId' => $product->getMeasurementUnit() ? $product->getMeasurementUnit()->getId() : null,
  2092.                     'unitSymbol' => $product->getMeasurementUnit() ? $product->getMeasurementUnit()->getSymbol() : ''
  2093.                 ];
  2094.             }
  2096.             $pId = $product->getId();
  2097.             if (!in_array($pId, $productData[$key]['seen_pids'])) {
  2098.                 $thisStock = array_reduce($product->getStockInfos()->toArray(), function ($sum, $item) {
  2099.                     return $sum + $item->getTotalQuantity();
  2100.                 }, 0);
  2101.                 $productData[$key]['currentStock'] += $thisStock;
  2102.                 $productData[$key]['seen_pids'][] = $pId;
  2103.             }
  2105.             $m = $stat->getMonth();
  2106.             $qty = (float) $stat->getTotalSalesQty();
  2107.             $avgCost = (float) $stat->getAvgCostPrice();
  2109.             // Total 2025 Sales
  2110.             if ($m >= 1 && $m <= 12) {
  2111.                 $productData[$key]['total2025'] += $qty;
  2113.                 // For Unit Cost Calculation
  2114.                 if ($qty > 0 && $avgCost > 0) {
  2115.                     $productData[$key]['totalCostSum'] += ($qty * $avgCost);
  2116.                     $productData[$key]['totalQtyForCost'] += $qty;
  2117.                 }
  2118.             }
  2120.             // Month specific sales
  2121.             if ($m == $month) {
  2122.                 $productData[$key]['monthlySales'] += $qty;
  2123.             }
  2126.         }
  2128.         // 3. Format result and Calculate Totals
  2129.         $result = [];
  2130.         $totalS1Order = 0;
  2131.         $totalS1Cost = 0;
  2132.         $totalS2Order = 0;
  2133.         $totalS2Cost = 0;
  2135.         foreach ($productData as $key => $data) {
  2136.             // Server-side filtering
  2137.             if ($filterName && stripos($data['name'], $filterName) === false)
  2138.                 continue;
  2139.             if (!empty($filterCodes) && !in_array($data['code'], $filterCodes))
  2140.                 continue;
  2141.             if (!empty($filterMeasurements) && !in_array($data['measurementId'], $filterMeasurements))
  2142.                 continue;
  2143.             if (!empty($filterUnits) && !in_array($data['unitId'], $filterUnits))
  2144.                 continue;
  2146.             // Unit Price (Weighted Average)
  2147.             $unitPrice = 0;
  2148.             if ($data['totalQtyForCost'] > 0) {
  2149.                 $unitPrice = $data['totalCostSum'] / $data['totalQtyForCost'];
  2150.             }
  2152.             $currentStock = $data['currentStock'];
  2153.             $monthSales = ceil($data['monthlySales']);
  2154.             $total2025 = ceil($data['total2025']);
  2156.             // Scenario 1: Equal Distribution (Stock / 12)
  2157.             $allocatedEqual = $currentStock / 12;
  2158.             $orderEqual = 0;
  2159.             // Order amount is difference between Demand (monthSales) and Allocated Stock
  2160.             // User requested: "2025 yılında o ay satılan gerçek stok miktarından her iki senaryodaki miktarları çıkaracak ortaya çıkan miktar iki senaryo için sipariş miktarı olacak."
  2161.             // So: monthSales - allocatedEqual
  2162.             if ($monthSales > $allocatedEqual) {
  2163.                 $orderEqual = $monthSales - $allocatedEqual;
  2164.             }
  2165.             $costEqual = $orderEqual * $unitPrice;
  2167.             // Scenario 2: Weighted Distribution (Stock * (MonthSale / YearSale))
  2168.             $allocatedWeighted = 0;
  2169.             if ($total2025 > 0) {
  2170.                 $ratio = $monthSales / $total2025;
  2171.                 $allocatedWeighted = $currentStock * $ratio;
  2172.             }
  2173.             $orderWeighted = 0;
  2174.             if ($monthSales > $allocatedWeighted) {
  2175.                 $orderWeighted = $monthSales - $allocatedWeighted;
  2176.             }
  2177.             $costWeighted = $orderWeighted * $unitPrice;
  2179.             // Add to totals
  2180.             $totalS1Order += ceil($orderEqual);
  2181.             $totalS1Cost += $costEqual;
  2182.             $totalS2Order += ceil($orderWeighted);
  2183.             $totalS2Cost += $costWeighted;
  2185.             $result[] = [
  2186.                 'name' => $data['name'],
  2187.                 'code' => $data['code'],
  2188.                 'currentStock' => $currentStock,
  2189.                 'sales2025' => $total2025,
  2190.                 'monthSales' => $monthSales, // Demand
  2191.                 'unitPrice' => round($unitPrice, 2),
  2193.                 // Scenario 1
  2194.                 'allocatedEqual' => floor($allocatedEqual),
  2195.                 'orderEqual' => ceil($orderEqual),
  2196.                 'costEqual' => round($costEqual, 2),
  2198.                 // Scenario 2
  2199.                 'allocatedWeighted' => floor($allocatedWeighted),
  2200.                 'orderWeighted' => ceil($orderWeighted),
  2201.                 'costWeighted' => round($costWeighted, 2),
  2202.                 'measurement' => $data['measurement'],
  2203.                 'measurementId' => $data['measurementId'],
  2204.                 'unitId' => $data['unitId'],
  2205.                 'unitSymbol' => $data['unitSymbol']
  2206.             ];
  2207.         }
  2209.         // Sort by Monthly Sales Descending (Primary focus) or Order Cost
  2210.         usort($result, function ($a, $b) {
  2211.             return $b['monthSales'] <=> $a['monthSales'];
  2212.         });
  2214.         return new JsonResponse([
  2215.             'data' => $result,
  2216.             'totals' => [
  2217.                 's1Order' => $totalS1Order,
  2218.                 's1Cost' => round($totalS1Cost, 2),
  2219.                 's2Order' => $totalS2Order,
  2220.                 's2Cost' => round($totalS2Cost, 2)
  2221.             ]
  2222.         ]);
  2223.     }
  2224. }