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

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 App\Repository\SalesRepository;
  43. use function Doctrine\ORM\QueryBuilder;
  45. class DashboardController extends AbstractController
  46. {
  47.     use Referer;
  48.     private UserService $userService;
  49.     private StockService $stockService;
  50.     private SalesService $salesService;
  51.     private StockTransferService $stockTransferService;
  52.     private EntityManagerInterface $entityManager;
  53.     private StockRepository $stockRepository;
  54.     private SalesServiceImpl $salesServiceImpl;
  55.     private ProductServiceImpl $productServiceImpl;
  56.     private PaginatorInterface $paginator;
  57.     private WarehouseServiceImpl $warehouseService;
  58.     private SalesProductsServiceImpl $salesProductsServiceImpl;
  60.     /**
  61.      * @param UserService $userService
  62.      * @param StockService $stockService
  63.      * @param SalesService $salesService
  64.      * @param StockTransferService $stockTransferService
  65.      * @param EntityManagerInterface $entityManager
  66.      * @param StockRepository $stockRepository
  67.      * @param SalesServiceImpl $salesServiceImpl
  68.      * @param ProductServiceImpl $productServiceImpl
  69.      * @param PaginatorInterface $paginator
  70.      * @param WarehouseServiceImpl $warehouseService
  71.      * @param SalesProductsServiceImpl $salesProductsServiceImpl
  72.      */
  73.     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)
  74.     {
  76.         $this->userService = $userService;
  77.         $this->stockService = $stockService;
  78.         $this->salesService = $salesService;
  79.         $this->stockTransferService = $stockTransferService;
  80.         $this->entityManager = $entityManager;
  81.         $this->stockRepository = $stockRepository;
  82.         $this->salesServiceImpl = $salesServiceImpl;
  83.         $this->productServiceImpl = $productServiceImpl;
  84.         $this->paginator = $paginator;
  85.         $this->warehouseService = $warehouseService;
  86.         $this->salesProductsServiceImpl = $salesProductsServiceImpl;
  87.     }
  90.     public function getProfitByPeriots(DateZoneEnums $dateZoneEnums, $year = null)
  91.     {
  92.         if ($year == null) {
  93.             $year = date('Y');
  94.         }
  95.         $salesRepo = $this->entityManager->getRepository(Sales::class);
  96.         if ($dateZoneEnums->value == 'monthly') {
  97.             $time = new \DateTimeImmutable('1 month ago');
  98.             $endTime = new \DateTimeImmutable('now');
  99.         }
  100.         if ($dateZoneEnums->value == 'weekly') {
  101.             $time = new \DateTimeImmutable('1 week ago');
  102.             $endTime = new \DateTimeImmutable('now');
  103.         }
  104.         if ($dateZoneEnums->value == 'yearly') {
  105.             $time = new \DateTimeImmutable('first day of January ' . $year);
  106.             $endTime = new \DateTimeImmutable('last day of December ' . $year . ' 23:59:59');
  107.         }
  109.         $qb = $salesRepo->createQueryBuilder('s')
  110.             ->leftJoin('s.productsSolds', 'productsSolds')
  111.             ->where('s.salesDate >= :time')
  112.             ->andWhere('s.salesDate <= :endTime')
  113.             ->setParameter('time', $time)
  114.             ->setParameter('endTime', $endTime);
  116.         if (!$this->canCurrentUserSeeHiddenSales()) {
  117.             $qb->andWhere('s.visible = :visible')
  118.                 ->setParameter('visible', true);
  119.         }
  121.         $sales = $qb->getQuery()->getResult();
  123.         $totalProfit = 0.00;
  124.         foreach ($sales as $sale) {
  125.             foreach ($sale->getProductsSolds() as $productsSold) {
  126.                 $totalProfit += $this->salesProductsServiceImpl->calculateProfitByProductSold($productsSold);
  127.             }
  128.         }
  129.         return CurrencyHelper::convertToCurrency($totalProfit);
  130.     }
  133.     #[Route('/get-products-summary', name: 'get_products_summary')]
  134.     public function getProductsSummary(Request $request, ProductRepository $productRepository)
  135.     {
  137.         $s = isset($request->get('search')['value']) ? $request->get('search')['value'] : null;
  138.         $startDate = $request->get('startDate') != null ? $request->get('startDate') : (new \DateTimeImmutable('now'))->modify('-1 month')->format('Y-m-d');
  139.         $endDate = $request->get('endDate') != null ? $request->get('endDate') : (new \DateTimeImmutable('now'))->format('Y-m-d');
  140.         $id = $request->get('id');
  141.         $column = $request->get('order') != null ? $request->get('order')[0]['column'] : '0';
  142.         $seller = $request->get('sellerId') == 0 ? null : $request->get('sellerId');
  143.         $dir = $request->get('order') != null ? $request->get('order')[0]['dir'] : 'asc';
  144.         $limit = $request->get('length');
  145.         if ($request->get('start'))
  146.             $page = 1 + ($request->get('start') / $limit);
  147.         else
  148.             $page = 1;
  150.         $startDate = \DateTimeImmutable::createFromFormat('Y-m-d', $startDate);
  151.         $endDate = \DateTimeImmutable::createFromFormat('Y-m-d', $endDate);
  154.         $query = $this->entityManager->getRepository(Product::class)->createQueryBuilder('p')
  155.             ->leftJoin('p.productsSolds', 'productsSolds')
  156.             ->leftJoin('productsSolds.sales', 'sales')
  157.             ->leftJoin('sales.seller', 'seller')
  158.             ->leftJoin('p.measurement', 'w')
  159.             ->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')
  160.             ->setParameter('s', "%$s%")
  161.             ->orWhere('w.measurement LIKE :s')
  162.             ->setParameter('s', "%$s%");
  164.         if ($seller != null) {
  165.             $query->andWhere('seller.id = :sellerId')
  166.                 ->setParameter('sellerId', $seller);
  167.         }
  169.         $query = $query->getQuery();
  171.         $products = $query->getResult();
  173.         //        switch ($column){
  174. //            case 0:
  175. //                $column = 'id';
  176. //                break;
  177. //            case 1:
  178. //                $column = 'productName';
  179. //                break;
  180. //            case 2:
  181. //                $column = 'code';
  182. //                break;
  183. //            case 3:
  184. //                $column = 'soldPrice';
  185. //                break;
  186. //            case 4:
  187. //                $column = 'totalEarn';
  188. //                break;
  189. //            case 5:
  190. //                $column = 'totalProfit';
  191. //                break;
  192. //        }
  193.         $datas = $this->createArrayForProductsDatatable(
  194.             $products,
  195.             $startDate,
  196.             $endDate,
  197.             $column,
  198.             $dir,
  199.             $page,
  200.             $limit
  201.         );
  202.         //        dd($datas);
  203. //
  204. //        dd($column);
  209.         return $this->json($datas, 200);
  211.         dd($products->getItems());
  213.         return $this->json(['data' => 'ss'], 200);
  215.         $products = $this->entityManager->getRepository(Product::class);
  217.     }
  220.     public function createArrayForProductsDatatable($products, \DateTimeImmutable $startDate, \DateTimeImmutable $endDate, $column, $dir, $page, $limit)
  221.     {
  222.         $records = [];
  223.         $records["data"] = [];
  225.         /**
  226.          * @var Product $entity
  227.          */
  228.         foreach ($products as $entity) {
  229.             $records["data"][] = array(
  230.                 $entity->getId(),
  231.                 $entity->getName(),
  232.                 $entity->getCode() . " - " . ($entity->getMeasurement() != null ? $entity->getMeasurement()->getMeasurement() : ''),
  233.                 $this->salesServiceImpl->getTotalSoldQuantityByDateSellerAndProduct($startDate, $endDate, null, $entity->getId()),
  234.                 $this->salesServiceImpl->getTotalSalesPriceByDateSellerAndProduct($startDate, $endDate, null, $entity->getId()),
  235.                 $this->salesServiceImpl->getTotalProfitPriceByDateSellerAndProduct($startDate, $endDate, null, $entity->getId()),
  236.                 "<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>"
  237.             );
  238.         }
  240.         $this->sortArrayByKey($records["data"], $column, false, $dir == 'asc');
  241.         $pagination = $this->paginator->paginate(
  242.             $records["data"],
  243.             $page,
  244.             $limit
  245.         );
  248.         $records['recordsTotal'] = $pagination->getTotalItemCount();
  249.         $records['recordsFiltered'] = $pagination->getTotalItemCount();
  250.         $records["data"] = $pagination->getItems();
  253.         return $records;
  254.     }
  256.     #[Route('/sales-prices-and-profits-by-year-range-month', name: 'sales_prices_and_profits_by_year_range_month')]
  257.     public function getSalesPricesAndProfitsByYearRangeMonth(Request $request)
  258.     {
  259.         $year = $request->get('year') != null ? $request->get('year') : date('Y');
  261.         $months = [];
  262.         $format = 'Y-m-d';
  264.         for ($month = 1; $month <= 12; $month++) {
  265.             //            if($month > date('m'))
  266. //                break;
  267.             $startOfMonth = \DateTimeImmutable::createFromFormat($format, "$year-$month-01");
  269.             $endOfMonth = (\DateTimeImmutable::createFromFormat($format, "$year-$month-01"))->modify('last day of this month');
  270.             $months[$month - 1]['start'] = $startOfMonth;
  271.             $months[$month - 1]['end'] = $endOfMonth;
  273.         }
  274.         $data = [];
  276.         foreach ($months as $month) {
  277.             $data['profit'][] = $this->salesServiceImpl->getTotalSalesProfitBetweenTwoDate($month['start'], $month['end']);
  278.             $data['sales'][] = $this->salesServiceImpl->getTotalSalesPriceBetweenTwoDate($month['start'], $month['end']);
  279.         }
  283.         //        $qb = $this->entityManager->getRepository(Sales::class)->createQueryBuilder('s')
  284. //                    ->select('MONTH(s.salesDate) as month, SUM(s.totalPurchasePrice) as total')
  285. //                    ->where('YEAR(s.salesDate) = :year')
  286. //                    ->setParameter('year', $year)
  287. //                    ->groupBy('month')
  288. //                    ->orderBy('month', 'ASC')
  289. //                    ->getQuery();
  291.         //        dd($qb->getResult());
  292.         return $this->json($data, 200);
  293.     }
  296.     function sortArrayByKey(&$array, $key, $string = false, $asc = true)
  297.     {
  298.         if ($string) {
  299.             usort($array, function ($a, $b) use (&$key, &$asc) {
  300.                 if ($asc)
  301.                     return strcmp(strtolower($a[$key]), strtolower($b[$key]));
  302.                 else
  303.                     return strcmp(strtolower($b[$key]), strtolower($a[$key]));
  304.             });
  305.         } else {
  306.             usort($array, function ($a, $b) use (&$key, &$asc) {
  307.                 if ($a[$key] == $b[$key]) {
  308.                     return 0;
  309.                 }
  310.                 if ($asc)
  311.                     return ($a[$key] < $b[$key]) ? -1 : 1;
  312.                 else
  313.                     return ($a[$key] > $b[$key]) ? -1 : 1;
  315.             });
  316.         }
  317.     }
  320.     #[Route('/admin', name: 'app_panel_dashboard')]
  321.     public function index(Request $request, SellerDetailRequestDto $sellerDetailRequestDto, \App\Repository\ProductMonthlyStatsRepository $statsRepository, FinancialForecastingService $financialService, \App\Service\Analysis\StrategicForecastingService $forecastingService): Response
  322.     {
  324.         if ($request->get('year') != null) {
  325.             $date = new \DateTimeImmutable('first day of January ' . $request->get('year'));
  326.             $year = $request->get('year');
  327.         } else {
  328.             $date = new \DateTimeImmutable('first day of January this year');
  329.             $year = date('Y');
  330.         }
  331.         $mountly = $this->salesService->getEarningsByPeriot(DateZoneEnums::MONTHLY);
  332.         $weekly = $this->salesService->getEarningsByPeriot(DateZoneEnums::WEEKLY);
  333.         $yearly = $this->salesService->getEarningsByPeriot(DateZoneEnums::YEARLY);
  334.         $profitMothly = $this->getProfitByPeriots(DateZoneEnums::MONTHLY, $year);
  335.         $profitWeekly = $this->getProfitByPeriots(DateZoneEnums::WEEKLY, $year);
  336.         $months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
  337.         $monthsTr = ['Ocak', 'Şubat', 'Mart', 'Nisan', 'Mayıs', 'Haziran', 'Temmuz', 'Ağustos', 'Eylül', 'Ekim', 'Kasım', 'Aralık'];
  339.         $array = [];
  340.         foreach ($months as $key => $month) {
  341.             $thisMonth = (int) date('m');
  342.             if ($month != $months[$thisMonth - 1]) {
  343.                 $startDate = new \DateTimeImmutable('first day of ' . $months[$key] . ' ' . $year);
  344.                 $endDate = new \DateTimeImmutable('last day of ' . $months[$key] . ' ' . $year);
  345.                 $earn = $this->salesService->getEarningsBetwenTwoDate($startDate, $endDate);
  346.                 $array[] = [
  347.                     $monthsTr[$key],
  348.                     $earn ? $earn : 0.00,
  349.                 ];
  350.             } else {
  351.                 $startDate = new \DateTimeImmutable('first day of ' . $months[$thisMonth - 1] . ' ' . $year);
  352.                 $endDate = new \DateTimeImmutable('now');
  353.                 $array[] = [
  354.                     $monthsTr[$thisMonth - 1],
  355.                     $this->salesService->getEarningsBetwenTwoDate($startDate, $endDate),
  356.                 ];
  357.                 break;
  358.             }
  359.         }
  361.         $inTransitTransferNumber = $this->stockTransferService->getNumberOfInTransitTransfers();
  363.         $allSallers = $this->entityManager->getRepository(User::class)->findAll();
  364.         $allWarehouses = $this->entityManager->getRepository(Warehouse::class)->findAll();
  365.         $allProducts = $this->entityManager->getRepository(Product::class)->findAll();
  367.         $uniqueProductCodes = [];
  368.         foreach ($allProducts as $p) {
  369.             $c = $p->getCode();
  370.             if ($c) {
  371.                 $uniqueProductCodes[] = $c;
  372.             }
  373.         }
  374.         $uniqueProductCodes = array_unique($uniqueProductCodes);
  375.         sort($uniqueProductCodes);
  377.         $requestedProducts = $request->get('pproductId');
  378.         $products = [];
  379.         if (is_array($requestedProducts)) {
  380.             $products = array_values(array_filter($requestedProducts));
  381.         } elseif (!empty($requestedProducts)) {
  382.             $products = [(int) $requestedProducts];
  383.         }
  384.         if (empty($products)) {
  385.             $ps = $this->entityManager->getRepository(Product::class)
  386.                 ->createQueryBuilder('c')
  387.                 ->select('c.id')
  388.                 ->setMaxResults(5)
  389.                 ->getQuery()
  390.                 ->getResult();
  391.             foreach ($ps as $p) {
  392.                 $products[] = (int) $p['id'];
  393.             }
  394.         }
  395.         $startDate = $request->get('pstartDate') ? new \DateTimeImmutable($request->get('pstartDate')) : new \DateTimeImmutable("30 days ago");
  396.         $finishDate = $request->get('pfinishDate') ? new \DateTimeImmutable($request->get('pfinishDate')) : new \DateTimeImmutable('now');
  397.         if (isset($this->entityManager->getRepository(Warehouse::class)->createQueryBuilder('c')->leftJoin('c.sales', 'sales')->where('sales.id is not null')->setMaxResults(1)->getQuery()->getResult()[0])) {
  398.             $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();
  399.         } else {
  400.             try {
  401.                 $warehouseId = $request->get('pwarehouseId') ? $request->get('pwarehouseId') : $this->entityManager->getRepository(Warehouse::class)->createQueryBuilder('c')->leftJoin('c.sales', 'sales')->setMaxResults(1)->getQuery()->getResult()[0]->getId();
  402.             } catch (\Exception $e) {
  403.                 $warehouseId = 0;
  404.             }
  405.         }
  406.         $sellerId = $request->get('psellerId');
  407.         $periyot = 0;
  408.         if ($request->get('periyot') !== null) {
  409.             if ($request->get('periyot') == 'weekly') {
  410.                 $periyot = 7;
  411.                 $periyotAdi = 'Hafta';
  412.             }
  413.             if ($request->get('periyot') == 'mothly') {
  414.                 $periyot = 30;
  415.                 $periyotAdi = 'Ay';
  416.             }
  417.             if ($request->get('periyot') == 'daily') {
  418.                 $periyot = 1;
  419.                 $periyotAdi = 'Gün';
  420.             }
  421.         } else {
  422.             $periyot = 7;
  423.             $periyotAdi = 'Hafta';
  424.         }
  427.         $fark = $startDate->diff($finishDate);
  428.         if ($fark->m != 0) {
  429.             $fark = $fark->m * 30 + $fark->d;
  430.         } else {
  431.             $fark = $fark->d;
  432.         }
  434.         $periyotSayisi = (int) ceil($fark / $periyot);
  435.         $arrays = [];
  438.         $baslangicTarihi = $startDate->format('Y-m-d');
  439.         $bitisTarihi = $startDate->modify('+' . $periyot . 'days')->format('Y-m-d');
  441.         for ($i = 0; $i < $periyotSayisi; $i++) {
  442.             if ($finishDate < $bitisTarihi) {
  443.                 $bitisTarihi = $finishDate;
  444.             }
  445.             foreach ($products as $productId) {
  446.                 $product = $this->entityManager->getRepository(Product::class)->find($productId);
  447.                 if (!$product) {
  448.                     continue;
  449.                 }
  450.                 $periotData = $this->getProductsByPeriot($baslangicTarihi, $bitisTarihi, $productId, $warehouseId, $sellerId);
  451.                 $totalAmount = 0.00;
  452.                 if (!empty($periotData) && isset($periotData[0]['totalAmount'])) {
  453.                     $totalAmount = (float) $periotData[0]['totalAmount'];
  454.                 }
  455.                 $arrays[$i + 1 . '.' . $periyotAdi][$product->getName()] = $totalAmount;
  456.             }
  457.             $baslangicTarihi = $bitisTarihi;
  458.             $yeniBaglangicTarihi = new \DateTimeImmutable($baslangicTarihi);
  459.             $bitisTarihi = $yeniBaglangicTarihi->modify('+' . $periyot . 'days')->format('Y-m-d');
  460.         }
  461.         $sellers = $this->entityManager->getRepository(User::class)->findAll();
  463.         $urun = [];
  464.         $periyotlar = [];
  465.         foreach ($arrays as $key => $arrayy) {
  466.             $periyotlar[] = $key;
  467.             foreach ($arrayy as $key => $arr) {
  468.                 $urun[$key][] = $arr;
  469.             }
  470.         }
  472.         $lowStockProducts = $this->getLowStockProducts();
  475.         $sellersDetail = $this->getSalesBySeller(
  476.             $sellerDetailRequestDto->getSellerStartDate(),
  477.             $sellerDetailRequestDto->getSellerFinishDate(),
  478.             $sellerDetailRequestDto->getSellerProducts(),
  479.             $sellerDetailRequestDto->getSellerId(),
  480.             $sellerDetailRequestDto->getSelectWarehouseForSellersTable(),
  482.         );
  484.         // --- NEW: 2025 Strategic Data Calculation ---
  485.         $stats2025 = $statsRepository->findBy(['year' => 2025]);
  486.         $totalRevenue2025 = 0;
  487.         $totalProfit2025 = 0;
  489.         foreach ($stats2025 as $stat) {
  490.             $totalRevenue2025 += $stat->getTotalSalesQty() * $stat->getAvgSalesPrice();
  491.             // Net Profit field might be string or float, ensure float
  492.             $cost = (float) $stat->getAvgCostPrice();
  493.             $price = (float) $stat->getAvgSalesPrice();
  494.             $qty = (float) $stat->getTotalSalesQty();
  495.             $totalProfit2025 += ($price - $cost) * $qty;
  496.         }
  498.         $selectedMonth = $request->query->getInt('analysis_month', (int) date('m'));
  499.         $statsMonth = $statsRepository->findBy(['year' => 2025, 'month' => $selectedMonth]);
  500.         $monthRevenue2025 = 0;
  501.         $monthProfit2025 = 0;
  503.         foreach ($statsMonth as $stat) {
  504.             $monthRevenue2025 += $stat->getTotalSalesQty() * $stat->getAvgSalesPrice();
  505.             $cost = (float) $stat->getAvgCostPrice();
  506.             $price = (float) $stat->getAvgSalesPrice();
  507.             $qty = (float) $stat->getTotalSalesQty();
  508.             $monthProfit2025 += ($price - $cost) * $qty;
  509.         }
  511.         // --- 2026 Projeksiyon (Aylık Gelir Özeti) Hesaplaması (2025 Bazlı) ---
  512.         $strategicRevenue2026Breakdown = [];
  513.         $strategicRevenue2026Total = 0;
  515.         // 2025 yılının tüm verilerini çekiyoruz
  516.         $allStats2025 = $statsRepository->findBy(['year' => 2025]);
  518.         // 12 aylık boş bir dizi oluştur (1-12)
  519.         $monthlyRevenues = array_fill(1, 12, 0.0);
  521.         foreach ($allStats2025 as $stat) {
  522.             $m = $stat->getMonth();
  523.             if ($m >= 1 && $m <= 12) {
  524.                 $rev = (float) $stat->getTotalSalesQty() * (float) $stat->getAvgSalesPrice();
  525.                 $monthlyRevenues[$m] += $rev;
  526.             }
  527.         }
  529.         foreach ($monthlyRevenues as $m => $val) {
  530.             $strategicRevenue2026Breakdown[$m] = $val;
  531.             $strategicRevenue2026Total += $val;
  532.         }
  533.         // ---------------------------------------------------------------------
  534.         // --- 2026 Projeksiyon (Aylık Kâr Özeti) Hesaplaması (2025 Bazlı) ---
  535.         $strategicProfit2026Breakdown = [];
  536.         $strategicProfit2026Total = 0;
  537.         $monthlyProfits = array_fill(1, 12, 0.0);
  538.         foreach ($allStats2025 as $stat) {
  539.             $m = $stat->getMonth();
  540.             if ($m >= 1 && $m <= 12) {
  541.                 $cost = (float) $stat->getAvgCostPrice();
  542.                 $price = (float) $stat->getAvgSalesPrice();
  543.                 $qty = (float) $stat->getTotalSalesQty();
  544.                 $monthlyProfits[$m] += ($price - $cost) * $qty;
  545.             }
  546.         }
  547.         foreach ($monthlyProfits as $m => $val) {
  548.             $strategicProfit2026Breakdown[$m] = $val;
  549.             $strategicProfit2026Total += $val;
  550.         }
  552.         // --- 2026 Gerçekleşen Veriler (Actuals) ---
  553.         $allStats2026 = $statsRepository->findBy(['year' => 2026]);
  554.         $actualRevenue2026Breakdown = array_fill(1, 12, 0.0);
  555.         $actualProfit2026Breakdown = array_fill(1, 12, 0.0);
  556.         $actualRevenue2026Total = 0;
  557.         $actualProfit2026Total = 0;
  559.         foreach ($allStats2026 as $stat) {
  560.             $m = $stat->getMonth();
  561.             if ($m >= 1 && $m <= 12) {
  562.                 $rev = (float) $stat->getTotalSalesQty() * (float) $stat->getAvgSalesPrice();
  564.                 $cost = (float) $stat->getAvgCostPrice();
  565.                 $price = (float) $stat->getAvgSalesPrice();
  566.                 $qty = (float) $stat->getTotalSalesQty();
  567.                 $prof = ($price - $cost) * $qty;
  569.                 $actualRevenue2026Breakdown[$m] += $rev;
  570.                 $actualProfit2026Breakdown[$m] += $prof;
  571.             }
  572.         }
  573.         // Toplamları hesapla
  574.         $actualRevenue2026Total = array_sum($actualRevenue2026Breakdown);
  575.         $actualProfit2026Total = array_sum($actualProfit2026Breakdown);
  577.         // --- 2025 Ürün Bazlı Aylık Satış Raporu ---
  578.         // Veri Kaynakları:
  579.         // - Satış Miktarları: product_monthly_stats.total_sales_qty
  580.         // - Mevcut Stok: StockInfo tablosu
  581.         // - Birim Maliyet: product_monthly_stats.avg_cost_price (ağırlıklı ortalama)
  582.         $productSales2025 = [];
  584.         foreach ($allStats2025 as $stat) {
  585.             $product = $stat->getProduct();
  586.             if ($product === null) {
  587.                 continue;
  588.             }
  590.             $pId = $product->getId();
  592.             if (!isset($productSales2025[$pId])) {
  593.                 $productSales2025[$pId] = [
  594.                     'name' => $product->getName(),
  595.                     'code' => $product->getCode(),
  596.                     'months' => array_fill(1, 12, 0),
  597.                     'total' => 0,
  598.                     // Mevcut Stok: StockInfo tablosundan
  599.                     'currentStock' => array_reduce($product->getStockInfos()->toArray(), function ($sum, $item) {
  600.                         return $sum + $item->getTotalQuantity();
  601.                     }, 0),
  602.                     // Maliyet hesaplaması için ara değerler
  603.                     'totalCostSum' => 0,  // Toplam maliyet (qty * cost)
  604.                     'totalQtyForCost' => 0, // Toplam miktar (ağırlıklı ortalama için)
  605.                     'unitPrice' => 0  // Sonradan hesaplanacak
  606.                 ];
  607.             }
  609.             $m = $stat->getMonth();
  610.             if ($m >= 1 && $m <= 12) {
  611.                 $qty = (float) $stat->getTotalSalesQty();
  612.                 $avgCostPrice = (float) $stat->getAvgCostPrice();
  614.                 $productSales2025[$pId]['months'][$m] += $qty;
  615.                 $productSales2025[$pId]['total'] += $qty;
  617.                 // Ağırlıklı ortalama maliyet hesabı için: (qty * cost) toplamı
  618.                 if ($qty > 0 && $avgCostPrice > 0) {
  619.                     $productSales2025[$pId]['totalCostSum'] += ($qty * $avgCostPrice);
  620.                     $productSales2025[$pId]['totalQtyForCost'] += $qty;
  621.                 }
  622.             }
  623.         }
  625.         // Post-process: Ağırlıklı ortalama maliyeti hesapla ve derived values'ları oluştur
  626.         foreach ($productSales2025 as $pId => &$data) {
  627.             $currentStock = $data['currentStock'];
  628.             $yearlySales = $data['total'];
  630.             // Birim Fiyat: Ağırlıklı ortalama maliyet (product_monthly_stats'tan)
  631.             $unitPrice = 0;
  632.             if ($data['totalQtyForCost'] > 0) {
  633.                 $unitPrice = $data['totalCostSum'] / $data['totalQtyForCost'];
  634.             }
  635.             $data['unitPrice'] = $unitPrice;
  637.             // --- Yearly Plan Calculations ---
  638.             // Yıllık Satılan: $yearlySales (product_monthly_stats'tan toplam)
  639.             // Mevcut Stok: $currentStock (StockInfo'dan)
  640.             // Satılan - Stok: $yearlySales - $currentStock
  641.             // Sipariş Miktarı: Satılan - Stok (negatifse 0)
  642.             // Toplam Maliyet: Sipariş Miktarı * Birim Fiyat
  644.             $salesMinusStock = $yearlySales - $currentStock;
  645.             $orderQty = max(0, ceil($salesMinusStock)); // Negatif siparişi engelle
  646.             $yearlyTotalCost = $orderQty * $unitPrice;
  648.             $data['yearly'] = [
  649.                 'sales' => ceil($yearlySales),         // Yıllık Satılan
  650.                 'remaining' => ceil($salesMinusStock), // Satılan - Stok
  651.                 'order' => $orderQty,                  // Sipariş Miktarı
  652.                 'totalCost' => $yearlyTotalCost        // Toplam
  653.             ];
  655.             // --- Monthly Projection Calculations (Stok - Satılan) ---
  656.             $monthlyCalculations = [];
  657.             for ($m = 1; $m <= 12; $m++) {
  658.                 $monthlySales = $data['months'][$m];
  659.                 $monthlyRemaining = ceil($currentStock - $monthlySales);
  660.                 $monthlyOrder = $monthlyRemaining;
  661.                 $monthlyTotalCost = $monthlyOrder * $unitPrice;
  663.                 $monthlyCalculations[$m] = [
  664.                     'sales' => $monthlySales,
  665.                     'remaining' => $monthlyRemaining,
  666.                     'order' => $monthlyOrder,
  667.                     'totalCost' => $monthlyTotalCost
  668.                 ];
  669.             }
  670.             $data['monthly_derived'] = $monthlyCalculations;
  672.             // Temizlik: Ara hesaplama alanlarını kaldır
  673.             unset($data['totalCostSum'], $data['totalQtyForCost']);
  674.         }
  675.         unset($data); // Break reference
  677.         // Çok satandan aza doğru sırala - uasort ile anahtarları koru (frontend için gerekli)
  678.         uasort($productSales2025, function ($a, $b) {
  679.             return $b['total'] <=> $a['total'];
  680.         });
  682.         // Sort allProducts based on 2025 sales totals (Added for Product Projection Table)
  683.         usort($allProducts, function ($a, $b) use ($productSales2025) {
  684.             $totalA = $productSales2025[$a->getId()]['total'] ?? 0;
  685.             $totalB = $productSales2025[$b->getId()]['total'] ?? 0;
  686.             return $totalB <=> $totalA; // DESC
  687.         });
  688.         // --- 2025-2026 Inventory Turn & Sleeping Stock Analysis (Rolling 12 Months) ---
  689.         $inventoryAnalysis = [];
  691.         // 1. Fetch Lifecycle Stats (First Seen, All-time Sales/Purchases) for ALL products
  692.         $lifecycleStats = $statsRepository->getProductLifecycleStats();
  694.         // Dinamik olarak son 12 ayı belirle
  695.         $rollingMonths = [];
  696.         $currentMonthObj = new \DateTimeImmutable('first day of this month');
  697.         for ($i = 0; $i < 12; $i++) {
  698.             $date = $currentMonthObj->modify("-$i month");
  699.             $rollingMonths[] = [
  700.                 'year' => (int) $date->format('Y'),
  701.                 'month' => (int) $date->format('m')
  702.             ];
  703.         }
  705.         // Son 12 ayın verilerini toplu çek (Performans için)
  706.         $yearsToFetch = array_unique(array_column($rollingMonths, 'year'));
  707.         $allRecentStats = $statsRepository->findBy(['year' => $yearsToFetch]);
  709.         // Ürün bazlı grupla
  710.         $statsByProduct = [];
  711.         foreach ($allRecentStats as $s) {
  712.             if ($s->getProduct()) {
  713.                 $pId = $s->getProduct()->getId();
  714.                 $statsByProduct[$pId][$s->getYear()][$s->getMonth()] = $s;
  715.             }
  716.         }
  718.         foreach ($allProducts as $product) {
  719.             // Sadece Tekil Ürün ve Paket Ürün olanları dahil et (Transport, Servis vb. hariç)
  720.             $type = $product->getProductTypeEnum();
  721.             if ($type !== ProductTypeEnum::SINGLE_ITEM && $type !== ProductTypeEnum::BUNDLE) {
  722.                 continue;
  723.             }
  725.             $pId = $product->getId();
  727.             // Mevcut Stok (Tüm depolardan)
  728.             $currentStock = array_reduce($product->getStockInfos()->toArray(), function ($sum, $item) {
  729.                 return $sum + $item->getTotalQuantity();
  730.             }, 0);
  732.             $totalSalesLast12Months = 0;
  733.             $totalSales3Months = 0;
  734.             $totalSales6Months = 0;
  735.             $inactiveMonthsCount = 0; // Last 8 months
  736.             $revenueLast12Months = 0;
  737.             $costLast12Months = 0;
  739.             // Rolling months dizisi tersten (en eskiden en yeniye) değil, en yeniden en eskiye doğru
  740.             foreach ($rollingMonths as $index => $period) {
  741.                 $s = $statsByProduct[$pId][$period['year']][$period['month']] ?? null;
  742.                 $qty = $s ? (float) $s->getTotalSalesQty() : 0;
  744.                 $totalSalesLast12Months += $qty;
  746.                 // Ek kolonlar için (3 Ay, 6 Ay)
  747.                 if ($index < 3) {
  748.                     $totalSales3Months += $qty;
  749.                 }
  750.                 if ($index < 6) {
  751.                     $totalSales6Months += $qty;
  752.                 }
  754.                 // Hareketsizlik kontrolü (Son 8 ay için)
  755.                 if ($index < 8) {
  756.                     if ($qty <= 0) {
  757.                         $inactiveMonthsCount++;
  758.                     }
  759.                 }
  761.                 if ($s) {
  762.                     $revenueLast12Months += $qty * (float) $s->getAvgSalesPrice();
  763.                     $costLast12Months += $qty * (float) $s->getAvgCostPrice();
  764.                 }
  765.             }
  767.             // Eğer verilerde maliyet/fiyat yoksa ürün kartından al
  768.             $avgCostLast12 = $totalSalesLast12Months > 0 ? $costLast12Months / $totalSalesLast12Months : (float) ($product->getPurchasePrice() ?? 0);
  769.             $avgPriceLast12 = $totalSalesLast12Months > 0 ? $revenueLast12Months / $totalSalesLast12Months : (float) ($product->getSalePrice() ?? 0);
  771.             // 1. Satış Hızı (Velocity) - Aylık Ortalama
  772.             $velocity = $totalSalesLast12Months / 12;
  774.             // Lifecycle Verileri
  775.             $lStats = $lifecycleStats[$pId] ?? null;
  776.             $isNewProduct = false;
  777.             $allTimeSellThrough = 0;
  779.             if ($lStats) {
  780.                 // Yeni Ürün Kontrolü: < 3 Ay (First Seen Date)
  781.                 $firstSeenDate = new \DateTime($lStats['firstSeen'] . '-01'); // YYYY-MM-01
  782.                 $threeMonthsAgo = (new \DateTime())->modify('-3 months');
  784.                 if ($firstSeenDate > $threeMonthsAgo) {
  785.                     $isNewProduct = true;
  786.                 }
  788.                 // Sell-Through Rate (All Time)
  789.                 if ($lStats['totalPurchases'] > 0) {
  790.                     $allTimeSellThrough = $lStats['totalSales'] / $lStats['totalPurchases'];
  791.                 }
  792.             } else {
  793.                 // İstatistik tablosunda hiç kaydı yoksa (veya eski değilse) Yeni Ürün kabul edebiliriz
  794.                 $isNewProduct = true;
  795.             }
  797.             // 2. Sleeping Stock & Status Logic (Advanced)
  798.             $sleepingStock = 0;
  799.             $status = 'Normal';
  801.             if ($isNewProduct) {
  802.                 $status = 'Yeni Ürün';
  803.             } else {
  804.                 // Atıl Stok Kontrolü: 8 aydır satış yok
  805.                 if ($inactiveMonthsCount >= 8 && $currentStock > 0) {
  806.                     $status = 'Atıl Stok (8 Ay Hareketsiz)';
  807.                     $sleepingStock = $currentStock; // Hepsi uyuyan kabul edilir
  808.                 } else {
  809.                     // Uyuyan Stok (Coverage & Turnover Logic)
  810.                     // Stok bizi kaç ay idare eder? (Stock Coverage)
  811.                     $stockCoverageMonths = $velocity > 0 ? ($currentStock / $velocity) : 999;
  813.                     // Kural 1: 12 Aydan fazla yetecek stok varsa -> Fazlası uyuyandır
  814.                     if ($stockCoverageMonths > 12) {
  815.                         $neededStock = $velocity * 12; // 1 senelik stok makul
  816.                         $sleepingStock = max(0, $currentStock - $neededStock);
  817.                         if ($sleepingStock > 0) {
  818.                             $status = 'Uyuyan Stok';
  819.                         }
  820.                     }
  821.                     // Kural 2: 6 Aydan fazla yetecek stok var VE Satış Performansı (Sell-Through) %20'nin altındaysa
  822.                     elseif ($stockCoverageMonths > 6 && $allTimeSellThrough < 0.20) {
  823.                         $neededStock = $velocity * 6; // 6 aylık stok makul
  824.                         $sleepingStock = max(0, $currentStock - $neededStock);
  825.                         if ($sleepingStock > 0) {
  826.                             $status = 'Uyuyan Stok (Düşük Performans)';
  827.                         }
  828.                     } elseif ($currentStock <= ($velocity * 1.5) && $velocity > 0) {
  829.                         $status = 'Hızlı Dönüş (Kritik)';
  830.                     } else {
  831.                         // Verimlilik kontrolü ekle: Eğer stok varsa ama verimlilik/satış hızı çok düşükse Normal demeyelim
  832.                         if ($currentStock > 0 && $velocity < 0.1) {
  833.                             $status = 'Takip Gereken (Düşük Hız)';
  834.                         }
  835.                     }
  836.                 }
  837.             }
  840.             // 4. Yatırım Verimliliği (ROI)
  841.             // Bağlı Sermaye: Mevcut Stok * Maliyet
  842.             $tiedCapital = $currentStock * $avgCostLast12;
  843.             // Verimlilik: Son 12 aylık ciro / Bağlı sermaye (veya benzeri bir oran)
  844.             $efficiency = $tiedCapital > 0 ? ($revenueLast12Months / $tiedCapital) : ($totalSalesLast12Months > 0 ? 99 : 0);
  846.             if ($currentStock > 0 || $totalSalesLast12Months > 0) {
  847.                 $inventoryAnalysis[] = [
  848.                     'id' => $product->getId(),
  849.                     'name' => $product->getName(),
  850.                     'code' => $product->getCode(),
  851.                     'endStock' => $currentStock,
  852.                     'totalSales' => $totalSalesLast12Months,
  853.                     'totalSales3Months' => $totalSales3Months,
  854.                     'totalSales6Months' => $totalSales6Months,
  855.                     'velocity' => $velocity,
  856.                     'sleepingStock' => $sleepingStock,
  857.                     'status' => $status,
  858.                     'avgCost' => $avgCostLast12,
  859.                     'avgPrice' => $avgPriceLast12,
  860.                     'sleepingStockCost' => $sleepingStock * $avgCostLast12,
  861.                     'sleepingStockRevenue' => $sleepingStock * $avgPriceLast12,
  862.                     'efficiency' => $efficiency,
  863.                     'inactiveMonths' => $inactiveMonthsCount
  864.                 ];
  865.             }
  866.         }
  868.         // Uyuyan stok miktarına göre azalan sırala
  869.         usort($inventoryAnalysis, function ($a, $b) {
  870.             return $b['sleepingStock'] <=> $a['sleepingStock'];
  871.         });
  873.         // --- Budget Planning Data (Aylık Bütçe Detayı) ---
  874.         $budgetPlanningData = $financialService->generateFinancialForecast(2025, 2026, true);
  876.         // --------------------------------------------
  878.         return $this->render('admin/dashboard/index.html.twig', [
  879.             'controller_name' => 'DashboardController',
  880.             'mountly' => CurrencyHelper::convertToCurrency($mountly),
  881.             'weekly' => CurrencyHelper::convertToCurrency($weekly),
  882.             'profitMonthly' => $profitMothly,
  883.             'profitWeekly' => $profitWeekly,
  884.             'yearly' => $yearly,
  885.             'inTransits' => $inTransitTransferNumber,
  886.             'earningInPeriots' => $array,
  887.             'sallers' => $this->userService->getTotalUsersEarns(),
  888.             'allSallers' => $allSallers,
  889.             'allWarehouses' => $allWarehouses,
  890.             'allProducts' => $allProducts,
  891.             'periyotlar' => $periyotlar,
  892.             'urunler' => $urun,
  893.             'monthsTr' => $monthsTr,
  894.             'sellers' => $sellers,
  895.             'sellersDetail' => $sellersDetail,
  896.             'warehouses' => $this->warehouseService->getAll(),
  897.             'lowStockProducts' => $lowStockProducts,
  898.             // New Variables (Strategic)
  899.             'strategic_2025_revenue' => $totalRevenue2025,
  900.             'strategic_2025_profit' => $totalProfit2025,
  901.             'strategic_month_revenue' => $monthRevenue2025,
  902.             'strategic_month_profit' => $monthProfit2025,
  903.             'selected_analysis_month' => $selectedMonth,
  904.             'strategic_revenue_2026_breakdown' => $strategicRevenue2026Breakdown,
  905.             'strategic_revenue_2026_total' => $strategicRevenue2026Total,
  906.             // New Variables (Actuals & Profit Projection)
  907.             'strategic_profit_2026_breakdown' => $strategicProfit2026Breakdown,
  908.             'strategic_profit_2026_total' => $strategicProfit2026Total,
  909.             'actual_revenue_2026_breakdown' => $actualRevenue2026Breakdown,
  910.             'actual_revenue_2026_total' => $actualRevenue2026Total,
  911.             'actual_profit_2026_breakdown' => $actualProfit2026Breakdown,
  912.             'actual_profit_2026_total' => $actualProfit2026Total,
  913.             'product_sales_2025' => $productSales2025,
  914.             'inventory_analysis' => $inventoryAnalysis,
  915.             // Budget Planning Data (Aylık Bütçe Detayı)
  916.             'budget_planning' => $budgetPlanningData,
  917.             'allMeasurementUnits' => $this->entityManager->getRepository(\App\Entity\MeasurementUnits::class)->findAll(),
  918.             'allMeasurements' => $this->entityManager->getRepository(\App\Entity\Measurements::class)->findAll(),
  919.             'uniqueProductCodes' => $uniqueProductCodes,
  920.         ]);
  922.     }
  924.     public function getLowStockProducts()
  925.     {
  927.         $qb = $this->entityManager->getRepository(StockInfo::class)->createQueryBuilder('si');
  929.         $qb
  930.             ->leftJoin('si.product', 'p')
  931.             ->leftJoin('si.warehouse', 'w')
  932.             ->leftJoin('p.measurementUnit', 'mu')
  933.             ->leftJoin('p.measurement', 'm')
  934.             ->where(
  935.                 $qb->expr()->orX(
  936.                     // Eğer symbol 'SET' ise totalQuantity 200 altı olanları getir
  937.                     $qb->expr()->andX(
  938.                         $qb->expr()->eq('mu.symbol', ':setSymbol'),
  939.                         $qb->expr()->lt('si.totalQuantity', ':setThreshold')
  940.                     ),
  941.                     // Aksi durumda totalQuantity 300 altı olanları getir
  942.                     $qb->expr()->andX(
  943.                         $qb->expr()->neq('mu.symbol', ':setSymbol'),
  944.                         $qb->expr()->lt('si.totalQuantity', ':defaultThreshold')
  945.                     )
  946.                 )
  947.             )
  948.             ->setParameter('setSymbol', 'SET')
  949.             ->setParameter('setThreshold', 200)
  950.             ->setParameter('defaultThreshold', 300)
  951.             ->select(
  952.                 'p.id as productId',
  953.                 'p.name as name',
  954.                 'p.code as productCode',
  955.                 'm.name as measurement',
  956.                 'si.totalQuantity as totalQuantity',
  957.                 'si.id as siId',
  958.                 'w.name as warehouseName',
  959.                 'mu.name as measurementUnit',
  960.                 'w.id as warehouseId',
  961.             )
  962.             ->orderBy('si.totalQuantity', 'desc');
  964.         $result = $qb->getQuery()->getResult();
  966.         $dates = $this->getDatesFromOneYear();
  967.         for ($i = 0; $i < count($result); $i++) {
  968.             foreach ($dates as $date) {
  969.                 $product = $this->productServiceImpl->getEntityId($result[$i]['productId']);
  970.                 $price = $this->salesProductsServiceImpl->getQuantityOfProductSoldBy($date['start'], $date['end'], $product, $result[$i]['warehouseId']);
  971.                 $result[$i]['quantities'][] = $price;
  972.                 $result[$i]['uuid'] = str_replace(".", "", uniqid('', true));
  973.             }
  974.         }
  975.         //        dd($result);
  976. //        dd($this->getDatesFromOneYear());
  977.         return $result;
  978.     }
  980.     #[Route('/admin/dashboard/product/sold/details/{productId}/{warehouseId}', name: 'admin_dashboard_product_sold_details')]
  981.     public function getQuantityOfSoldProductDetails(Request $request, $productId, $warehouseId)
  982.     {
  983.         $dates = $this->getDatesFromOneYear();
  984.         $product = $this->productServiceImpl->getEntityId($productId);
  985.         $warehouse = null;
  986.         if ($warehouseId != null && $warehouseId != 0) {
  987.             $warehouse = $this->warehouseService->getEntityById($warehouseId);
  988.         }
  989.         $result = [];
  990.         for ($i = 0; $i < count($dates); $i++) {
  991.             $month = DateUtil::getMonthOfTurkish((int) (new \DateTimeImmutable($dates[$i]['start']))->format('m'));
  992.             $quantity = $this->salesProductsServiceImpl->getQuantityOfProductSoldBy(
  993.                 $dates[$i]['start'],
  994.                 $dates[$i]['end'],
  995.                 $product,
  996.                 $warehouse
  997.             );
  999.             if ($quantity == null)
  1000.                 $quantity = 0.00;
  1001.             else
  1002.                 $quantity = CurrencyHelper::roundUp($quantity);
  1003.             $result[$month] = [
  1004.                 'quantity' => $quantity,
  1005.                 'measurement' => $product->getMeasurementUnit()->getSymbol(),
  1006.                 'startDate' => $dates[$i]['start'],
  1007.                 'endDate' => $dates[$i]['end']
  1008.             ];
  1009.         }
  1012.         return new JsonResponse($result);
  1014.     }
  1016.     public function getDatesFromOneYear()
  1017.     {
  1018.         $dates = [];
  1019.         $today = new \DateTimeImmutable();
  1021.         // Son bir yıl boyunca her ay için başlangıç ve bitiş tarihi
  1022.         for ($i = 0; $i < 12; $i++) {
  1023.             // Geçmişe doğru git
  1024.             $monthStart = $today->modify("-$i month")->modify('first day of this month');
  1025.             $monthEnd = $monthStart->modify('last day of this month');
  1027.             $dates[] = [
  1028.                 'month' => 12 - $i,
  1029.                 'start' => $monthStart->format('Y-m-d'), // Başlangıç tarihi
  1030.                 'end' => $monthEnd->format('Y-m-d')     // Bitiş tarihi
  1031.             ];
  1032.         }
  1033.         return $dates;
  1035.     }
  1039.     public function getSalesBySeller($startDate = null, $finishDate = null, $products = null, $sellerIds = null, $warehouseId = null)
  1040.     {
  1042.         $year = date('Y');
  1043.         if ($startDate == null)
  1044.             $startDate = new \DateTimeImmutable('first day of january ' . $year);
  1045.         else {
  1046.             $startDate = \DateTimeImmutable::createFromFormat('Y-m-d', $startDate);
  1047.         }
  1048.         if ($finishDate == null)
  1049.             $finishDate = new \DateTimeImmutable('last day of december ' . $year);
  1050.         else {
  1051.             $finishDate = \DateTimeImmutable::createFromFormat('Y-m-d', $finishDate);
  1052.         }
  1054.         $userRepo = $this->entityManager->getRepository(User::class);
  1055.         $canSeeHidden = $this->canCurrentUserSeeHiddenSales();
  1057.         $qb = $userRepo->createQueryBuilder('u')
  1058.             ->leftJoin('u.sales', 's')
  1059.             ->leftJoin('s.warehouse', 'w')
  1060.             ->leftJoin('s.productsSolds', 'ps')
  1061.             ->leftJoin('ps.product', 'p')
  1062.             ->where('s.salesDate >= :startDate')
  1063.             ->andWhere('s.salesDate <= :finishDate')
  1064.             ->setParameter('startDate', $startDate)
  1065.             ->setParameter('finishDate', $finishDate);
  1067.         if (!$canSeeHidden) {
  1068.             $qb->andWhere('s.visible = :visible')
  1069.                 ->setParameter('visible', true);
  1070.         }
  1072.         if ($sellerIds != null) {
  1073.             $qb->andWhere(
  1074.                 $qb->expr()->in('u.id', $sellerIds)
  1075.             );
  1076.         }
  1077.         if ($products != null) {
  1078.             $qb->andWhere(
  1079.                 $qb->expr()->in('product.id', $products)
  1080.             );
  1081.         }
  1083.         if ($warehouseId != null && $warehouseId != 0) {
  1084.             $qb->andWhere(
  1085.                 $qb->expr()->eq('w.id', $warehouseId)
  1086.             );
  1087.         }
  1089.         $result = $qb->getQuery()->getResult();
  1090.         $array = [];
  1092.         /**
  1093.          * @var User $user
  1094.          */
  1095.         foreach ($result as $user) {
  1096.             $totalPurchasePrice = 0.00;
  1097.             $totalProfit = 0.00;
  1098.             foreach ($user->getSales() as $sale) {
  1099.                 if (!$canSeeHidden && !$sale->isVisible()) {
  1100.                     continue;
  1101.                 }
  1102.                 if ($sale->getSalesDate() >= $startDate && $sale->getSalesDate() <= $finishDate) {
  1103.                     foreach ($sale->getProductsSolds() as $productsSold) {
  1104.                         $totalProfit += $this->salesProductsServiceImpl->calculateProfitByProductSold($productsSold);
  1105.                         $totalPurchasePrice += $productsSold->getTotalPuchasePrice();
  1106.                     }
  1107.                 }
  1108.             }
  1109.             $array[] = [
  1110.                 'userId' => $user->getId(),
  1111.                 'startDate' => $startDate->format('d-m-Y'),
  1112.                 'finishDate' => $finishDate->format('d-m-Y'),
  1113.                 'username' => $user->getUsername(),
  1114.                 'email' => $user->getEmail(),
  1115.                 'totalPurchasePrice' => $totalPurchasePrice,
  1116.                 'totalProfit' => $this->salesServiceImpl->getTotalSalesProfitBetweenTwoDate(
  1117.                     $startDate,
  1118.                     $finishDate,
  1119.                     $warehouseId,
  1120.                     $user->getId()
  1121.                 )
  1122.             ];
  1123.         }
  1125.         return $array;
  1126.     }
  1128.     #[Route('/get-product-by-productname', name: 'get_product_by_product_name')]
  1129.     public function getProductByProductName(Request $request)
  1130.     {
  1131.         $search = $request->get('search');
  1132.         $qb = $this->entityManager->getRepository(Product::class)
  1133.             ->createQueryBuilder('p')
  1134.             ->where('p.name LIKE :s')
  1135.             ->setParameter('s', '%' . $search . '%')
  1136.             ->getQuery()
  1137.             ->getResult();
  1138.         return $this->json($qb);
  1139.     }
  1141.     #[Route('/dashboard/weeaks-earning/{warehouseId}', name: 'dashboard_week_earning')]
  1142.     public function getWeekEarningByWeek(Request $request, EntityManagerInterface $entityManager, $warehouseId)
  1143.     {
  1144.         $firstDayOfWeek = trim(explode('*', $request->get('week'))[0]);
  1145.         $lastDayOfWeek = trim(explode('*', $request->get('week'))[1]);
  1147.         $firstDayOfWeek = \DateTimeImmutable::createFromFormat('Y-m-d', $firstDayOfWeek);
  1148.         $lastDayOfWeek = \DateTimeImmutable::createFromFormat('Y-m-d', $lastDayOfWeek);
  1150.         $productsSoldRepo = $entityManager->getRepository(ProductsSold::class);
  1151.         $canSeeHidden = $this->canCurrentUserSeeHiddenSales();
  1152.         $qb = $productsSoldRepo->createQueryBuilder('c')
  1153.             ->leftJoin('c.sales', 'sales')
  1154.             ->leftJoin('c.product', 'product')
  1155.             ->where('sales.salesDate >= :firstDayOfWeek')
  1156.             ->andWhere('sales.salesDate <= :lastDayOfWeek')
  1157.             ->setParameters(
  1158.                 [
  1159.                     'firstDayOfWeek' => $firstDayOfWeek,
  1160.                     'lastDayOfWeek' => $lastDayOfWeek
  1161.                 ]
  1162.             );
  1164.         if (!$canSeeHidden) {
  1165.             $qb->andWhere('sales.visible = :visible')
  1166.                 ->setParameter('visible', true);
  1167.         }
  1169.         $qb = $qb->getQuery()->getResult();
  1171.         $period = new DatePeriod(
  1172.             date_create_from_format('Y-m-d', $firstDayOfWeek->format('Y-m-d')),
  1173.             new DateInterval('P1D'),
  1174.             date_create_from_format('Y-m-d', $lastDayOfWeek->format('Y-m-d'))->add(new DateInterval('P1D'))
  1175.         );
  1177.         $days = [];
  1178.         foreach ($period as $key => $value) {
  1179.             $days[] = $value->format('Y-m-d');
  1180.         }
  1182.         if ($warehouseId == 0)
  1183.             $warehouseId = null;
  1186.         return new JsonResponse(
  1187.             [
  1188.                 'totalEarning' => $this->salesServiceImpl->getTotalSalesPriceBetweenTwoDate(
  1189.                     $firstDayOfWeek,
  1190.                     $lastDayOfWeek,
  1191.                     $warehouseId,
  1192.                 ),
  1193.                 'totalProfit' => $this->salesServiceImpl->getTotalSalesProfitBetweenTwoDate(
  1194.                     $firstDayOfWeek,
  1195.                     $lastDayOfWeek,
  1196.                     $warehouseId,
  1197.                 ),
  1198.                 'days' => $days,
  1199.             ]
  1200.         );
  1201.     }
  1203.     #[Route('/dashboard/day-earning/{warehouseId}', name: 'dashboard_day_earning', methods: ['GET', 'POST'])]
  1204.     public function getEarningByDay(Request $request, EntityManagerInterface $entityManager, $warehouseId)
  1205.     {
  1206.         $day = $request->get('day');
  1207.         $day = \DateTimeImmutable::createFromFormat('Y-m-d', $day);
  1208.         $productsSoldRepo = $entityManager->getRepository(ProductsSold::class);
  1209.         $canSeeHidden = $this->canCurrentUserSeeHiddenSales();
  1210.         $qb = $productsSoldRepo->createQueryBuilder('c')
  1211.             ->leftJoin('c.sales', 'sales')
  1212.             ->leftJoin('c.product', 'product')
  1213.             ->where('sales.salesDate = :day')
  1214.             ->setParameter('day', $day->format('Y-m-d'));
  1216.         if (!$canSeeHidden) {
  1217.             $qb->andWhere('sales.visible = :visible')
  1218.                 ->setParameter('visible', true);
  1219.         }
  1221.         $qb = $qb->getQuery()->getResult();
  1223.         if ($warehouseId == 0)
  1224.             $warehouseId = null;
  1227.         return new JsonResponse(
  1228.             [
  1229.                 'totalEarning' => $this->salesServiceImpl->getTotalSalesPriceBetweenTwoDate(
  1230.                     $day,
  1231.                     $day,
  1232.                     $warehouseId
  1233.                 ),
  1234.                 'totalProfit' => $this->salesServiceImpl->getTotalSalesProfitBetweenTwoDate(
  1235.                     $day,
  1236.                     $day,
  1237.                     $warehouseId
  1238.                 ),
  1239.             ]
  1240.         );
  1241.     }
  1243.     #[Route('/dashboard/year-earning/{warehouseId}', name: 'dashboard_year_earning')]
  1244.     public function getEarningByYear(Request $request, EntityManagerInterface $entityManager, $warehouseId)
  1245.     {
  1246.         $year = $request->get('year');
  1248.         $firstDayOfYear = new \DateTimeImmutable('first day of january ' . $year);
  1249.         $lastDayOfYear = new \DateTimeImmutable('last day of december ' . $year . ' 23:59:59');
  1252.         //        $productsSoldRepo = $entityManager->getRepository(ProductsSold::class);
  1253. //        $qb = $productsSoldRepo->createQueryBuilder('c')
  1254. //            ->leftJoin('c.sales', 'sales')
  1255. //            ->leftJoin('c.product', 'product')
  1256. //            ->where('sales.salesDate >= :firstDayOfYear')
  1257. //            ->setParameter('firstDayOfYear',$firstDayOfYear)
  1258. //            ->andWhere('sales.salesDate <= :lastDayOfYear')
  1259. //            ->setParameter('lastDayOfYear', $lastDayOfYear);
  1260. //
  1261. //        if($request->get('all-warehouses') == null){
  1262. //
  1263. //            $qb->andWhere('sales.warehouse = :warehouse')
  1264. //                ->setParameter('warehouse',$this->warehouseService->getMainWarehouse());
  1265. //        }
  1266. //
  1267. //        $qb = $qb->getQuery()->getResult();
  1268. //
  1269. //        $totalEarningsArr = array_map(function ($val){
  1270. //            return $val->getTotalPuchasePrice();
  1271. //        }, $qb);
  1272. //
  1273. //        $totalEarning = 0.00;
  1274. //        foreach ($totalEarningsArr as $totalEarn){
  1275. //            $totalEarning += $totalEarn;
  1276. //        }
  1277. //
  1278. //        $profits = array_map(function ($val){
  1279. //            return $val->getTotalPuchasePrice() - $val->getTotalPrice();
  1280. //        },$qb);
  1281. //
  1282. //
  1283. //        $totalProfit = 0.00;
  1284. //
  1285. //        foreach ($profits as $profit){
  1286. //            $totalProfit += $profit;
  1287. //        }
  1291.         return new JsonResponse(
  1292.             [
  1293.                 'totalEarning' => $this->salesServiceImpl->getTotalSalesPriceBetweenTwoDateAndByWarehouse(
  1294.                     $firstDayOfYear,
  1295.                     $lastDayOfYear,
  1296.                     $warehouseId == 0 ? null : $warehouseId,
  1297.                 ),
  1298.                 'totalProfit' => $this->salesServiceImpl->getTotalSalesProfitBetweenTwoDate(
  1299.                     $firstDayOfYear,
  1300.                     $lastDayOfYear,
  1301.                     $warehouseId == 0 ? null : $warehouseId,
  1302.                 ),
  1303.             ]
  1304.         );
  1305.     }
  1307.     #[Route('/dashboard/month-earning/{warehouseId}', name: 'dashboard_month_earning')]
  1308.     public function getEarningByMonth(Request $request, EntityManagerInterface $entityManager, $warehouseId)
  1309.     {
  1310.         if ($request->get('year') != null) {
  1311.             $year = $request->get('year');
  1312.         } else {
  1313.             $year = date('Y');
  1314.         }
  1315.         $months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
  1316.         $month = $request->get('month');
  1318.         $firstDayOfMounth = (new \DateTimeImmutable('first day of ' . $months[$month - 1] . ' ' . $year))->format('Y-m-d');
  1319.         $lastDayOfMount = (new \DateTimeImmutable('last day of ' . $months[$month - 1] . ' ' . $year))->format('Y-m-d');
  1322.         $firstWeekStartDay = $firstDayOfMounth;
  1323.         $firstWeekFinishDay = (new \DateTime('+6 days ' . $firstDayOfMounth . ' ' . $year))->format('Y-m-d');
  1325.         $secondWeekStartDay = (new \DateTime('+1 days ' . $firstWeekFinishDay . ' ' . $year))->format('Y-m-d');
  1326.         $secondWeekFinishDay = (new \DateTime('+6 days ' . $secondWeekStartDay . ' ' . $year))->format('Y-m-d');
  1328.         $thirdWeekStartDay = (new \DateTime('+1 days ' . $secondWeekFinishDay . ' ' . $year))->format('Y-m-d');
  1329.         $thirdWeekFinishDay = (new \DateTime('+6 days ' . $thirdWeekStartDay . ' ' . $year))->format('Y-m-d');
  1331.         $fourthWeekStartDate = (new \DateTime('+1 days ' . $thirdWeekFinishDay . ' ' . $year))->format('Y-m-d');
  1332.         $fourthWeekFinishDate = $lastDayOfMount;
  1335.         $firstWeek = $firstWeekStartDay . " * " . $firstWeekFinishDay;
  1336.         $secondWeek = $secondWeekStartDay . " * " . $secondWeekFinishDay;
  1337.         $thirdWeek = $thirdWeekStartDay . " * " . $thirdWeekFinishDay;
  1338.         $fourthWeek = $fourthWeekStartDate . " * " . $fourthWeekFinishDate;
  1341.         $productsSoldRepo = $entityManager->getRepository(ProductsSold::class);
  1342.         $canSeeHidden = $this->canCurrentUserSeeHiddenSales();
  1343.         $qb = $productsSoldRepo->createQueryBuilder('c')
  1344.             ->leftJoin('c.sales', 'sales')
  1345.             ->leftJoin('c.product', 'product')
  1346.             ->where('sales.salesDate >= :firstDayOfMonth')
  1347.             ->andWhere('sales.salesDate <= :lastDayOfMonth')
  1348.             ->setParameters(
  1349.                 [
  1350.                     'firstDayOfMonth' => $firstDayOfMounth,
  1351.                     'lastDayOfMonth' => $lastDayOfMount
  1352.                 ]
  1353.             )
  1354.             ->orderBy('sales.salesDate', 'DESC');
  1356.         if (!$canSeeHidden) {
  1357.             $qb->andWhere('sales.visible = :visible')
  1358.                 ->setParameter('visible', true);
  1359.         }
  1361.         $qb = $qb->getQuery()->getResult();
  1363.         $data = [];
  1365.         foreach ($qb as $val) {
  1366.             $data[] = [
  1367.                 $val->getProduct()->getCode(),
  1368.                 $val->getProductName(),
  1369.                 $val->getQuantity(),
  1370.                 $val->getUnitPriceFob(),
  1371.                 $val->getUnitPriceNavlun(),
  1372.                 $val->getTotalUnitPrice(),
  1373.                 $val->getTotalPrice(),
  1374.                 $val->getTotalPuchasePrice()
  1375.             ];
  1376.         }
  1379.         $startDate = (new \DateTimeImmutable('first day of ' . $months[$month - 1] . ' ' . $year));
  1380.         $finishDate = (new \DateTimeImmutable('last day of ' . $months[$month - 1] . ' ' . $year));
  1382.         if ($warehouseId == 0)
  1383.             $warehouseId = null;
  1385.         return new JsonResponse(
  1386.             [
  1387.                 'profit' => $this->salesServiceImpl->getTotalSalesProfitBetweenTwoDate($startDate, $finishDate, $warehouseId),
  1388.                 'totalPrices' => $this->salesServiceImpl->getTotalSalesPriceBetweenTwoDate($startDate, $finishDate, $warehouseId),
  1389.                 'data' => $data,
  1390.                 'firstWeek' => $firstWeek,
  1391.                 'secondWeek' => $secondWeek,
  1392.                 'thirdWeek' => $thirdWeek,
  1393.                 'fourthWeek' => $fourthWeek
  1394.             ]
  1395.         );
  1396.     }
  1398.     private function getProductsByPeriot($startdate, $finishDate, $product, $warehouse, $seller)
  1399.     {
  1400.         $repo = $this->entityManager->getRepository(Sales::class);
  1401.         $canSeeHidden = $this->canCurrentUserSeeHiddenSales();
  1402.         $result = $repo->createQueryBuilder('c')
  1403.             ->leftJoin('c.productsSolds', 'productsSolds')
  1404.             ->leftJoin('productsSolds.product', 'product')
  1405.             ->leftJoin('c.warehouse', 'warehouse');
  1406.         if ($startdate != null) {
  1407.             $result->where('c.salesDate >= :startDate')
  1408.                 ->setParameter('startDate', $startdate);
  1409.         }
  1410.         if ($finishDate != null) {
  1411.             $result->andWhere('c.salesDate <= :finishDate')
  1412.                 ->setParameter('finishDate', $finishDate);
  1413.         }
  1414.         if ($product != 0) {
  1415.             $result->andWhere('product.id = :product')
  1416.                 ->setParameter('product', $product);
  1417.         }
  1418.         if ($warehouse != null) {
  1419.             $result->andWhere('warehouse.id = :warehouseId')
  1420.                 ->setParameter('warehouseId', $warehouse);
  1421.         }
  1422.         if ($seller != 0) {
  1423.             $result->andWhere('c.seller = :seller')
  1424.                 ->setParameter('seller', $seller);
  1425.         }
  1426.         if (!$canSeeHidden) {
  1427.             $result->andWhere('c.visible = :visible')
  1428.                 ->setParameter('visible', true);
  1429.         }
  1430.         $result
  1431.             ->select(['product.name as productName', 'sum(c.totalPurchasePrice) totalAmount']);
  1432.         return $result->getQuery()->getResult();
  1433.     }
  1435.     private function canCurrentUserSeeHiddenSales(): bool
  1436.     {
  1437.         $user = $this->getUser();
  1439.         if (!$user) {
  1440.             return false;
  1441.         }
  1443.         $identifier = null;
  1444.         if (method_exists($user, 'getUserIdentifier')) {
  1445.             $identifier = $user->getUserIdentifier();
  1446.         } elseif (method_exists($user, 'getUsername')) {
  1447.             $identifier = $user->getUsername();
  1448.         }
  1450.         if ($identifier === null) {
  1451.             return false;
  1452.         }
  1454.         return in_array(strtolower((string) $identifier), ['gizli@kullanici.com', 'azad@azad.com']);
  1455.     }
  1457.     #[Route('/{locale}', name: 'app_change_locale', priority: -10)]
  1458.     public function changeLocale(Request $request, $locale, RouterInterface $router)
  1459.     {
  1460.         $params = $this->getRefererParams($request, $router);
  1462.         $locales = $this->getParameter('kernel.enabled_locales');
  1463.         if (in_array($locale, $locales)) {
  1464.             if ($this->getUser())
  1465.                 $this->userService->changeLocale($this->getUser(), $locale);
  1466.             $request->getSession()->set('_locale', $locale);
  1467.             return $this->redirect($params);
  1468.         }
  1469.         $this->createNotFoundException(printf('%s locale is not avaible', $locale));
  1470.         return $this->redirectToRoute('app_panel_dashboard');
  1471.     }
  1477.     #[Route('/dashboard/product-sales-2025-ajax', name: 'get_product_sales_2025_ajax')]
  1478.     public function getProductSales2025Ajax(Request $request, ProductRepository $productRepository, ProductMonthlyStatsRepository $statsRepo, \App\Service\Analysis\SalesSeasonalityService $seasonalityService, \App\Repository\SettingsRepository $settingsRepository, \App\Service\Analysis\StrategicForecastingService $forecastingService): JsonResponse
  1479.     {
  1480.         // Client-side DataTable - tüm veriyi döndürüyoruz (pagination yok)
  1481.         $searchParams = $_GET['search'] ?? [];
  1482.         $searchValue = $searchParams['value'] ?? null;
  1484.         $qb = $productRepository->createQueryBuilder('p')
  1485.             ->leftJoin(\App\Entity\ProductMonthlyStats::class, 's', \Doctrine\ORM\Query\Expr\Join::WITH, 's.product = p.id AND s.year = 2025')
  1486.             ->leftJoin('p.measurementUnit', 'mu')
  1487.             ->groupBy('p.id')
  1488.             ->select('p.id', 'p.name', 'p.code', 'mu.symbol as unitSymbol')
  1489.             ->addSelect('SUM(CASE WHEN s.month = 1 THEN s.totalSalesQty ELSE 0 END) as m1')
  1490.             ->addSelect('SUM(CASE WHEN s.month = 2 THEN s.totalSalesQty ELSE 0 END) as m2')
  1491.             ->addSelect('SUM(CASE WHEN s.month = 3 THEN s.totalSalesQty ELSE 0 END) as m3')
  1492.             ->addSelect('SUM(CASE WHEN s.month = 4 THEN s.totalSalesQty ELSE 0 END) as m4')
  1493.             ->addSelect('SUM(CASE WHEN s.month = 5 THEN s.totalSalesQty ELSE 0 END) as m5')
  1494.             ->addSelect('SUM(CASE WHEN s.month = 6 THEN s.totalSalesQty ELSE 0 END) as m6')
  1495.             ->addSelect('SUM(CASE WHEN s.month = 7 THEN s.totalSalesQty ELSE 0 END) as m7')
  1496.             ->addSelect('SUM(CASE WHEN s.month = 8 THEN s.totalSalesQty ELSE 0 END) as m8')
  1497.             ->addSelect('SUM(CASE WHEN s.month = 9 THEN s.totalSalesQty ELSE 0 END) as m9')
  1498.             ->addSelect('SUM(CASE WHEN s.month = 10 THEN s.totalSalesQty ELSE 0 END) as m10')
  1499.             ->addSelect('SUM(CASE WHEN s.month = 11 THEN s.totalSalesQty ELSE 0 END) as m11')
  1500.             ->addSelect('SUM(CASE WHEN s.month = 12 THEN s.totalSalesQty ELSE 0 END) as m12')
  1501.             ->addSelect('SUM(s.totalSalesQty) as total');
  1503.         // Arama Filtresi (opsiyonel - client-side yapıyor ama server-side de filtre olabilir)
  1504.         if ($searchValue) {
  1505.             $qb->where('p.name LIKE :search OR p.code LIKE :search')
  1506.                 ->setParameter('search', '%' . $searchValue . '%');
  1507.         }
  1509.         // Varsayılan sıralama
  1510.         $qb->orderBy('total', 'DESC');
  1512.         // TÜM VERİYİ ÇEK (Client-side için pagination yok)
  1513.         $dbResults = $qb->getQuery()->getResult();
  1515.         // --- STOK VERİSİNİ OPTİMİZE EDEREK ÇEKME (Bulk Fetch) ---
  1516.         $productIds = [];
  1517.         foreach ($dbResults as $r) {
  1518.             $productIds[] = $r['id'];
  1519.         }
  1521.         $stockMap = [];
  1522.         if (!empty($productIds)) {
  1523.             $stockResults = $this->entityManager->getRepository(\App\Entity\StockInfo::class)->createQueryBuilder('si')
  1524.                 ->select('IDENTITY(si.product) as pid, SUM(si.totalQuantity) as totalStock')
  1525.                 ->where('si.product IN (:pids)')
  1526.                 ->setParameter('pids', $productIds)
  1527.                 ->groupBy('si.product')
  1528.                 ->getQuery()
  1529.                 ->getResult();
  1531.             foreach ($stockResults as $sr) {
  1532.                 $stockMap[$sr['pid']] = (float) $sr['totalStock'];
  1533.             }
  1534.         }
  1535.         // --------------------------------------------------------
  1537.         // Para Birimi Ayarlarını Çek
  1538.         $settings = $settingsRepository->findOneBy([]);
  1539.         $currencyCode = $settings ? $settings->getCurrency() : 'EUR';
  1540.         $currencySymbol = match ($currencyCode) {
  1541.             'EUR' => '€',
  1542.             'USD' => '$',
  1543.             'TRY', 'TL' => '₺',
  1544.             'GBP' => '£',
  1545.             default => $currencyCode
  1546.         };
  1548.         // Verileri İşle ve Ham Haliyle Hazırla
  1549.         $processedRows = [];
  1550.         $stockRepo = $this->entityManager->getRepository(\App\Entity\Stock::class);
  1552.         foreach ($dbResults as $row) {
  1553.             $currentStock = $stockMap[$row['id']] ?? 0;
  1555.             // --- UNIT PRICE HESAPLAMA (Son 6 Girişin Ortalaması) ---
  1556.             // N+1 olacak ama şimdilik en güvenilir yöntem.
  1557.             // İleride performans sorunu olursa Native SQL ile optimize edilebilir.
  1558.             $lastStocks = $stockRepo->findBy(
  1559.                 ['product' => $row['id']],
  1560.                 ['buyingDate' => 'DESC'],
  1561.                 6
  1562.             );
  1564.             $averageUnitPrice = 0;
  1565.             if (count($lastStocks) > 0) {
  1566.                 $totalPriceSum = 0;
  1567.                 foreach ($lastStocks as $stockItem) {
  1568.                     $totalPriceSum += $stockItem->getTotalUnitPrice();
  1569.                 }
  1570.                 $averageUnitPrice = $totalPriceSum / count($lastStocks);
  1571.             }
  1572.             $row['unitPrice'] = $averageUnitPrice;
  1573.             // -------------------------------------------------------
  1575.             // Mevsimsellik Analizi Verileri
  1576.             $monthlySalesVars = [];
  1577.             for ($k = 1; $k <= 12; $k++) {
  1578.                 $monthlySalesVars[$k] = (float) $row['m' . $k];
  1579.             }
  1581.             // Stok Ömrü Hesaplama
  1582.             $stockDurationDays = 0;
  1583.             if ($currentStock <= 0) {
  1584.                 $stockDurationDays = -1; // Tükendi
  1585.             } else {
  1586.                 $totalAnnualSales = array_sum($monthlySalesVars);
  1587.                 if ($totalAnnualSales <= 0) {
  1588.                     $stockDurationDays = 99999; // Sonsuz
  1589.                 } else {
  1590.                     $tempStock = $currentStock;
  1591.                     $daysAccumulated = 0;
  1592.                     $calcMonthIndex = (int) date('n');
  1593.                     $calcCurrentDay = (int) date('j');
  1594.                     $safetyBreak = 730;
  1596.                     while ($tempStock > 0 && $daysAccumulated < $safetyBreak) {
  1597.                         $monthlySales = $monthlySalesVars[$calcMonthIndex];
  1598.                         $daysInMonth = 30;
  1600.                         if ($daysAccumulated == 0) {
  1601.                             $daysRemaining = max(0, $daysInMonth - $calcCurrentDay);
  1602.                         } else {
  1603.                             $daysRemaining = $daysInMonth;
  1604.                         }
  1606.                         $dailyRate = $monthlySales / $daysInMonth;
  1607.                         $needed = $dailyRate * $daysRemaining;
  1609.                         if ($needed <= 0) {
  1610.                             $daysAccumulated += $daysRemaining;
  1611.                         } else {
  1612.                             if ($tempStock >= $needed) {
  1613.                                 $tempStock -= $needed;
  1614.                                 $daysAccumulated += $daysRemaining;
  1615.                             } else {
  1616.                                 $daysLasted = ($dailyRate > 0) ? ($tempStock / $dailyRate) : 0;
  1617.                                 $daysAccumulated += $daysLasted;
  1618.                                 $tempStock = 0;
  1619.                                 break;
  1620.                             }
  1621.                         }
  1622.                         $calcMonthIndex++;
  1623.                         if ($calcMonthIndex > 12)
  1624.                             $calcMonthIndex = 1;
  1625.                     }
  1626.                     $stockDurationDays = $daysAccumulated;
  1627.                 }
  1628.             }
  1630.             $processedRows[] = [
  1631.                 'dbRow' => $row,
  1632.                 'currentStock' => $currentStock,
  1633.                 'stockDurationDays' => $stockDurationDays,
  1634.                 'indices' => $seasonalityService->calculateSeasonalityIndices($monthlySalesVars),
  1635.                 'monthlySalesVars' => $monthlySalesVars
  1636.             ];
  1637.         }
  1639.         // Client-side DataTable - PHP tarafında sıralama veya pagination yok
  1640.         // Tüm veri işlenip döndürülüyor
  1642.         $data = [];
  1643.         $currentMonth = (int) date('n');
  1645.         foreach ($processedRows as $pRow) {
  1646.             $row = $pRow['dbRow'];
  1647.             $currentStock = $pRow['currentStock'];
  1648.             $stockDurationDays = $pRow['stockDurationDays'];
  1649.             $indices = $pRow['indices'];
  1650.             $monthlySalesVars = $pRow['monthlySalesVars'];
  1652.             $unitSymbol = $row['unitSymbol'] ?? '';
  1654.             // Client-side sorting için orthogonal data formatı: { display: HTML, sort: numeric }
  1655.             $item = [
  1656.                 'name' => [
  1657.                     'display' => '<strong>' . htmlspecialchars($row['name']) . '</strong><br><small class="text-muted">' . htmlspecialchars($row['code']) . '</small>',
  1658.                     'sort' => $row['name']
  1659.                 ],
  1660.             ];
  1662.             $item['currentStock'] = [
  1663.                 'display' => '<span class="badge badge-info" style="font-size: 0.9rem;">' . number_format($currentStock, 0, ',', '.') . ' ' . $unitSymbol . '</span>',
  1664.                 'sort' => (int) $currentStock
  1665.             ];
  1667.             // Stok Süresi Görselleştirme
  1668.             $stockDurationHtml = '';
  1669.             $stockStatus = 'success'; // default: yeşil (iyi durum)
  1671.             if ($stockDurationDays == -1) {
  1672.                 $stockDurationHtml = '<span class="badge badge-secondary" style="background-color: #333;">Tükendi</span>';
  1673.                 $stockStatus = 'empty';
  1674.             } elseif ($stockDurationDays == 99999) {
  1675.                 $stockDurationHtml = '<span class="badge badge-secondary">∞ (Satış Yok)</span>';
  1676.                 $stockStatus = 'noSales';
  1677.             } else {
  1678.                 $badgeClass = 'badge-success'; // > 90 gün
  1679.                 if ($stockDurationDays < 45) { // < 45 gün KIRMIZI
  1680.                     $badgeClass = 'badge-danger';
  1681.                     $stockStatus = 'danger';
  1682.                 } elseif ($stockDurationDays < 90) { // 45-90 gün SARI
  1683.                     $badgeClass = 'badge-warning';
  1684.                     $stockStatus = 'warning';
  1685.                 }
  1687.                 $displayDays = $stockDurationDays >= 730 ? '> 2 Yıl' : number_format($stockDurationDays, 0) . ' Gün';
  1688.                 $stockDurationHtml = '<span class="badge ' . $badgeClass . '">' . $displayDays . '</span>';
  1689.             }
  1691.             // Sıralama için mantıklı değerler:
  1692.             // Tükendi (-1) → 0 (en kritik, en üstte olmalı)
  1693.             // Normal değerler → gerçek gün sayısı
  1694.             // Satış Yok (99999) → 999999 (sonsuz, en altta olmalı)
  1695.             $sortValue = $stockDurationDays;
  1696.             if ($stockDurationDays == -1) {
  1697.                 $sortValue = 0; // Tükendi = en kritik
  1698.             } elseif ($stockDurationDays == 99999) {
  1699.                 $sortValue = 999999; // Satış yok = pratik olarak sonsuz
  1700.             }
  1702.             $item['stockDuration'] = [
  1703.                 'display' => $stockDurationHtml,
  1704.                 'sort' => $sortValue,
  1705.                 'status' => $stockStatus // Filtreleme için: empty, noSales, danger, warning, success
  1706.             ];
  1708.             // Filtreleme için ek metadata
  1709.             $item['_meta'] = [
  1710.                 'stockStatus' => $stockStatus,
  1711.                 'stockValue' => (int) $currentStock,
  1712.                 'productName' => $row['name'],
  1713.                 'productCode' => $row['code']
  1714.             ];
  1716.             // Ayları ekle
  1717.             for ($i = 1; $i <= 12; $i++) {
  1718.                 $val = $monthlySalesVars[$i];
  1719.                 $idx = $indices[$i];
  1721.                 $style = '';
  1722.                 if ($i < $currentMonth) {
  1723.                     $style = 'background-color: #ffebee; color: #c62828;';
  1724.                 } elseif ($i === $currentMonth) {
  1725.                     $style = 'background-color: #e8f5e9; color: #2e7d32;';
  1726.                 }
  1728.                 if ($val > 0) {
  1729.                     $formattedVal = number_format($val, 0, ',', '.');
  1730.                     $formattedIdx = number_format($idx, 2);
  1731.                     $content = $formattedVal . ' <small style="font-size: 0.7em; opacity: 0.8;">/ ' . $formattedIdx . 'x</small>';
  1732.                 } else {
  1733.                     $content = '<span style="opacity: 0.5;">-</span>';
  1734.                 }
  1736.                 if ($style !== '') {
  1737.                     $displayContent = '<div style="' . $style . ' border-radius: 5px; padding: 6px 0;">' . $content . '</div>';
  1738.                 } else {
  1739.                     $displayContent = $content;
  1740.                 }
  1742.                 $item['m' . $i] = [
  1743.                     'display' => $displayContent,
  1744.                     'sort' => (float) $val
  1745.                 ];
  1746.             }
  1748.             // Toplam
  1749.             $total = (float) $row['total'];
  1750.             $item['total'] = [
  1751.                 'display' => '<span class="font-weight-bold text-primary">' . number_format($total, 0, ',', '.') . '</span>',
  1752.                 'sort' => $total
  1753.             ];
  1755.             // --- TAVSİYE EDİLEN STOK ALIMI ve MALİYETİ ---
  1756.             // --- TAVSİYE EDİLEN STOK ALIMI ve MALİYETİ (Merkezi Mantık) ---
  1757.             $unitPrice = (float) $row['unitPrice'];
  1759.             // Mevcut ay ve sonraki 2 ayın taleplerini al (Döngüsel)
  1760.             $getDemand = function ($m) use ($monthlySalesVars) {
  1761.                 $idx = (($m - 1) % 12) + 1;
  1762.                 return $monthlySalesVars[$idx] ?? 0;
  1763.             };
  1765.             $d1 = $getDemand($currentMonth);
  1766.             $d2 = $getDemand($currentMonth + 1);
  1767.             $d3 = $getDemand($currentMonth + 2);
  1769.             // Merkezi Servis ile Analiz
  1770.             $stockAnalysis = $forecastingService->checkStockStatus((float) $currentStock, $d1, $d2, $d3, $unitPrice);
  1772.             $suggestedOrderQty = $stockAnalysis['order_qty'];
  1773.             $suggestedOrderCost = $stockAnalysis['order_cost'];
  1774.             $coverageDateStr = '';
  1776.             if ($suggestedOrderQty > 0) {
  1777.                 // Tooltip için tarih hesapla: Bugün + 3 ay
  1778.                 $targetDate = new \DateTime();
  1779.                 $targetDate->modify('+3 months');
  1780.                 $coverageDateStr = $targetDate->format('d.m.Y');
  1781.             }
  1783.             // 1. Tavsiye Edilen Stok Alımı (Tooltip ile)
  1784.             $tooltipAttr = $suggestedOrderQty > 0 ? 'data-toggle="tooltip" title="' . $coverageDateStr . ' tarihine kadar yeterli"' : '';
  1785.             $style = $suggestedOrderQty > 0 ? 'color: #e74a3b; font-size:1.1em; cursor:help;' : 'text-muted';
  1786.             $valInfo = $suggestedOrderQty > 0 ? number_format($suggestedOrderQty, 0, ',', '.') : '-';
  1788.             $item['suggestedOrderQty'] = [
  1789.                 'display' => '<span class="font-weight-bold" ' . $tooltipAttr . ' style="' . $style . '">' . $valInfo . '</span>',
  1790.                 'sort' => $suggestedOrderQty
  1791.             ];
  1793.             // 2. Tavsiye Edilen Stok Maliyeti (Yeni Sütun)
  1794.             $item['suggestedOrderCost'] = [
  1795.                 'display' => $suggestedOrderCost > 0 ? '<span class="text-danger">' . number_format($suggestedOrderCost, 2, ',', '.') . ' ' . $currencySymbol . '</span>' : '-',
  1796.                 'sort' => $suggestedOrderCost
  1797.             ];
  1799.             // 3. Birim Maliyet (Yeni Sütun)
  1800.             $item['unitPrice'] = [
  1801.                 'display' => number_format($unitPrice, 2, ',', '.') . ' ' . $currencySymbol,
  1802.                 'sort' => $unitPrice
  1803.             ];
  1805.             $data[] = $item;
  1806.         }
  1808.         // Client-side DataTable için sadece data array döndürülüyor
  1809.         return new JsonResponse([
  1810.             'data' => $data
  1811.         ]);
  1812.     }
  1814.     /**
  1815.      * AJAX endpoint for monthly stock purchase detail (used in budget planning info popup)
  1816.      */
  1817.     #[Route('/admin/dashboard/stock-purchase-detail/{month}', name: 'admin_dashboard_stock_purchase_detail', methods: ['GET'])]
  1818.     public function getStockPurchaseDetail(int $month, FinancialForecastingService $financialService): JsonResponse
  1819.     {
  1820.         // Validate month
  1821.         if ($month < 1 || $month > 12) {
  1822.             return new JsonResponse(['error' => 'Invalid month'], 400);
  1823.         }
  1825.         $detail = $financialService->getMonthlyStockPurchaseDetail(2025, 2026, $month, true);
  1827.         return new JsonResponse($detail);
  1828.     }
  1830.     /**
  1831.      * AJAX endpoint for 2026 Stock & Order Simulation data (for DataTables on Dashboard)
  1832.      */
  1833.     #[Route('/admin/api/stock-simulation-data', name: 'app_dashboard_stock_simulation_data', methods: ['GET'])]
  1834.     public function getStockSimulationData(\App\Service\Analysis\StrategicForecastingService $forecastingService): JsonResponse
  1835.     {
  1836.         // Generate forecast data
  1837.         $forecastData = $forecastingService->generateForecast(2025, 2026);
  1838.         $forecasts = $forecastData['product_forecasts'];
  1840.         $data = [];
  1842.         foreach ($forecasts as $pid => $product) {
  1843.             $row = [
  1844.                 'product_code' => $product['code'],
  1845.                 'product_name' => $product['name'],
  1846.             ];
  1848.             // Add monthly data
  1849.             $totalSales2025 = 0;
  1850.             for ($month = 1; $month <= 12; $month++) {
  1851.                 $plan = $product['plan'][$month] ?? [];
  1852.                 $demand = (int) ($plan['demand'] ?? 0);
  1853.                 $row['month_' . $month . '_stock'] = (int) ($plan['stock_end'] ?? 0);
  1854.                 $row['month_' . $month . '_demand'] = $demand;
  1855.                 $row['month_' . $month . '_order'] = (int) ($plan['order_qty'] ?? 0);
  1856.                 $row['month_' . $month . '_status'] = $plan['status'] ?? 'secure';
  1858.                 $totalSales2025 += $demand;
  1859.             }
  1861.             $row['total_sales_2025'] = $totalSales2025;
  1863.             $data[] = $row;
  1864.         }
  1866.         return new JsonResponse(['data' => $data]);
  1867.     }
  1869.     /**
  1870.      * AJAX endpoint for Yearly Plan Table data
  1871.      * Veri Kaynakları:
  1872.      * - Yıllık Satılan: product_monthly_stats.total_sales_qty (SUM for year)
  1873.      * - Mevcut Stok: stock_info.total_quantity (SUM)
  1874.      * - Birim Fiyat: product_monthly_stats.avg_cost_price (Ağırlıklı ortalama)
  1875.      */
  1876.     #[Route('/admin/api/yearly-plan-data', name: 'app_dashboard_yearly_plan_data', methods: ['GET'])]
  1877.     public function getYearlyPlanData(ProductMonthlyStatsRepository $statsRepository): JsonResponse
  1878.     {
  1879.         // 2025 yılı için tüm ürünlerin aylık istatistiklerini al
  1880.         $allStats = $statsRepository->findBy(['year' => 2025]);
  1882.         // Ürün bazlı verileri topla
  1883.         $productData = [];
  1885.         foreach ($allStats as $stat) {
  1886.             $product = $stat->getProduct();
  1887.             if ($product === null) {
  1888.                 continue;
  1889.             }
  1891.             $pId = $product->getId();
  1893.             if (!isset($productData[$pId])) {
  1894.                 // Mevcut stok: StockInfo tablosundan
  1895.                 $currentStock = 0;
  1896.                 foreach ($product->getStockInfos() as $stockInfo) {
  1897.                     $currentStock += $stockInfo->getTotalQuantity();
  1898.                 }
  1900.                 $productData[$pId] = [
  1901.                     'id' => $pId,
  1902.                     'name' => $product->getName(),
  1903.                     'code' => $product->getCode(),
  1904.                     'currentStock' => (float) $currentStock,
  1905.                     'totalSales' => 0,
  1906.                     'totalCostSum' => 0,
  1907.                     'totalQtyForCost' => 0,
  1908.                 ];
  1909.             }
  1911.             $m = $stat->getMonth();
  1912.             if ($m >= 1 && $m <= 12) {
  1913.                 $qty = (float) $stat->getTotalSalesQty();
  1914.                 $avgCostPrice = (float) $stat->getAvgCostPrice();
  1916.                 $productData[$pId]['totalSales'] += $qty;
  1918.                 // Ağırlıklı ortalama maliyet hesabı için
  1919.                 if ($qty > 0 && $avgCostPrice > 0) {
  1920.                     $productData[$pId]['totalCostSum'] += ($qty * $avgCostPrice);
  1921.                     $productData[$pId]['totalQtyForCost'] += $qty;
  1922.                 }
  1923.             }
  1924.         }
  1926.         // Hesaplamaları yap ve sonuç dizisini oluştur
  1927.         $result = [];
  1929.         foreach ($productData as $pId => $data) {
  1930.             $yearlySales = $data['totalSales'];
  1931.             $currentStock = $data['currentStock'];
  1933.             // Birim Fiyat: Ağırlıklı ortalama
  1934.             $unitPrice = 0;
  1935.             if ($data['totalQtyForCost'] > 0) {
  1936.                 $unitPrice = $data['totalCostSum'] / $data['totalQtyForCost'];
  1937.             }
  1939.             // Hesaplamalar
  1940.             $salesMinusStock = $yearlySales - $currentStock;
  1941.             $orderQty = max(0, ceil($salesMinusStock));
  1942.             $totalCost = $orderQty * $unitPrice;
  1944.             $result[] = [
  1945.                 'id' => $pId,
  1946.                 'name' => $data['name'],
  1947.                 'code' => $data['code'],
  1948.                 'yearlySales' => ceil($yearlySales),        // Yıllık Satılan
  1949.                 'currentStock' => $currentStock,             // Mevcut Stok
  1950.                 'salesMinusStock' => ceil($salesMinusStock), // Satılan - Stok
  1951.                 'orderQty' => $orderQty,                     // Sipariş Miktarı
  1952.                 'unitPrice' => round($unitPrice, 2),         // Birim Fiyat
  1953.                 'totalCost' => round($totalCost, 2),         // Toplam
  1954.             ];
  1955.         }
  1957.         // Yıllık satışa göre sırala (çoktan aza)
  1958.         usort($result, function ($a, $b) {
  1959.             return $b['yearlySales'] <=> $a['yearlySales'];
  1960.         });
  1962.         return new JsonResponse(['data' => $result]);
  1963.     }
  1965.     /**
  1966.      * AJAX endpoint for Monthly Plan Table data
  1967.      * Seçilen ay için ürün bazlı satış ve sipariş planı
  1968.      * Yıllık satışa göre sıralanır (en çoktan en aza)
  1969.      */
  1970.     #[Route('/admin/api/monthly-plan-data/{month}', name: 'app_dashboard_monthly_plan_data', methods: ['GET'])]
  1971.     public function getMonthlyPlanData(int $month, ProductMonthlyStatsRepository $statsRepository): JsonResponse
  1972.     {
  1973.         // Validate month
  1974.         if ($month < 1 || $month > 12) {
  1975.             return new JsonResponse(['error' => 'Invalid month'], 400);
  1976.         }
  1978.         // 2025 yılı için tüm ürünlerin aylık istatistiklerini al
  1979.         $allStats = $statsRepository->findBy(['year' => 2025]);
  1981.         // Ürün bazlı verileri topla
  1982.         $productData = [];
  1984.         foreach ($allStats as $stat) {
  1985.             $product = $stat->getProduct();
  1986.             if ($product === null) {
  1987.                 continue;
  1988.             }
  1990.             $pId = $product->getId();
  1992.             if (!isset($productData[$pId])) {
  1993.                 // Mevcut stok: StockInfo tablosundan
  1994.                 $currentStock = 0;
  1995.                 foreach ($product->getStockInfos() as $stockInfo) {
  1996.                     $currentStock += $stockInfo->getTotalQuantity();
  1997.                 }
  1999.                 $productData[$pId] = [
  2000.                     'id' => $pId,
  2001.                     'name' => $product->getName(),
  2002.                     'code' => $product->getCode(),
  2003.                     'currentStock' => (float) $currentStock,
  2004.                     'yearlySales' => 0,
  2005.                     'monthlySales' => 0,
  2006.                     'monthlyUnitPrice' => 0,
  2007.                 ];
  2008.             }
  2010.             $m = $stat->getMonth();
  2011.             $qty = (float) $stat->getTotalSalesQty();
  2012.             $avgCostPrice = (float) $stat->getAvgCostPrice();
  2014.             // Yıllık toplam satış
  2015.             if ($m >= 1 && $m <= 12) {
  2016.                 $productData[$pId]['yearlySales'] += $qty;
  2017.             }
  2019.             // Seçilen ay için satış
  2020.             if ($m === $month) {
  2021.                 $productData[$pId]['monthlySales'] = $qty;
  2022.                 $productData[$pId]['monthlyUnitPrice'] = $avgCostPrice;
  2023.             }
  2024.         }
  2026.         // Hesaplamaları yap ve sonuç dizisini oluştur
  2027.         $result = [];
  2029.         foreach ($productData as $pId => $data) {
  2030.             $monthlySales = $data['monthlySales'];
  2031.             $currentStock = $data['currentStock'];
  2032.             $unitPrice = $data['monthlyUnitPrice'];
  2034.             // Hesaplamalar
  2035.             $stockMinusSales = $currentStock - $monthlySales;
  2036.             $orderQty = max(0, ceil($monthlySales - $currentStock));
  2037.             $totalCost = $orderQty * $unitPrice;
  2039.             $result[] = [
  2040.                 'id' => $pId,
  2041.                 'name' => $data['name'],
  2042.                 'code' => $data['code'],
  2043.                 'currentStock' => $currentStock,             // Mevcut Stok
  2044.                 'monthlySales' => ceil($monthlySales),       // Aylık Satılan
  2045.                 'stockMinusSales' => ceil($stockMinusSales), // Stok - Satılan
  2046.                 'unitPrice' => round($unitPrice, 2),         // Birim Fiyat
  2047.                 'orderQty' => $orderQty,                     // Sipariş Miktarı
  2048.                 'totalCost' => round($totalCost, 2),         // Toplam
  2049.                 'yearlySales' => ceil($data['yearlySales']), // Sıralama için
  2050.             ];
  2051.         }
  2053.         // Yıllık satışa göre sırala (çoktan aza)
  2054.         usort($result, function ($a, $b) {
  2055.             return $b['yearlySales'] <=> $a['yearlySales'];
  2056.         });
  2058.         return new JsonResponse(['data' => $result]);
  2059.     }
  2061.     #[Route('/monthly-plan/{month}', name: 'app_dashboard_monthly_plan_data', methods: ['GET'])]
  2062.     public function getMonthlyOrderPlan(int $month, ProductMonthlyStatsRepository $statsRepository, \Symfony\Component\HttpFoundation\Request $request): JsonResponse
  2063.     {
  2064.         $filterName = $request->query->get('name');
  2065.         $filterCodes = $request->query->all()['codes'] ?? [];
  2066.         $filterMeasurements = $request->query->all()['measurements'] ?? [];
  2067.         $filterUnits = $request->query->all()['units'] ?? [];
  2069.         // 1. Fetch all 2025 stats
  2070.         $allStats2025 = $statsRepository->findBy(['year' => 2025]);
  2072.         // 2. Group by Product
  2073.         $productData = [];
  2075.         foreach ($allStats2025 as $stat) {
  2076.             $product = $stat->getProduct();
  2077.             // Skip if product is null OR if it has no measurement unit
  2078.             if ($product === null || $product->getMeasurementUnit() === null) {
  2079.                 continue;
  2080.             }
  2082.             $code = $product->getCode();
  2083.             $key = $code ? strtoupper(trim($code)) : $product->getId();
  2085.             if (!isset($productData[$key])) {
  2086.                 $productData[$key] = [
  2087.                     'name' => $product->getName(),
  2088.                     'code' => $product->getCode(),
  2089.                     'currentStock' => 0,
  2090.                     'total2025' => 0,
  2091.                     'monthlySales' => 0, // Sales for the requested month
  2093.                     'totalCostSum' => 0,
  2094.                     'totalQtyForCost' => 0,
  2095.                     'seen_pids' => [],
  2096.                     'measurement' => $product->getMeasurement() ? $product->getMeasurement()->getMeasurement() : '',
  2097.                     'measurementId' => $product->getMeasurement() ? $product->getMeasurement()->getId() : null,
  2098.                     'unitId' => $product->getMeasurementUnit() ? $product->getMeasurementUnit()->getId() : null,
  2099.                     'unitSymbol' => $product->getMeasurementUnit() ? $product->getMeasurementUnit()->getSymbol() : ''
  2100.                 ];
  2101.             }
  2103.             $pId = $product->getId();
  2104.             if (!in_array($pId, $productData[$key]['seen_pids'])) {
  2105.                 $thisStock = array_reduce($product->getStockInfos()->toArray(), function ($sum, $item) {
  2106.                     return $sum + $item->getTotalQuantity();
  2107.                 }, 0);
  2108.                 $productData[$key]['currentStock'] += $thisStock;
  2109.                 $productData[$key]['seen_pids'][] = $pId;
  2110.             }
  2112.             $m = $stat->getMonth();
  2113.             $qty = (float) $stat->getTotalSalesQty();
  2114.             $avgCost = (float) $stat->getAvgCostPrice();
  2116.             // Total 2025 Sales
  2117.             if ($m >= 1 && $m <= 12) {
  2118.                 $productData[$key]['total2025'] += $qty;
  2120.                 // For Unit Cost Calculation
  2121.                 if ($qty > 0 && $avgCost > 0) {
  2122.                     $productData[$key]['totalCostSum'] += ($qty * $avgCost);
  2123.                     $productData[$key]['totalQtyForCost'] += $qty;
  2124.                 }
  2125.             }
  2127.             // Month specific sales
  2128.             if ($m == $month) {
  2129.                 $productData[$key]['monthlySales'] += $qty;
  2130.             }
  2133.         }
  2135.         // 3. Format result and Calculate Totals
  2136.         $result = [];
  2137.         $totalS1Order = 0;
  2138.         $totalS1Cost = 0;
  2139.         $totalS2Order = 0;
  2140.         $totalS2Cost = 0;
  2142.         foreach ($productData as $key => $data) {
  2143.             // Server-side filtering
  2144.             if ($filterName && stripos($data['name'], $filterName) === false)
  2145.                 continue;
  2146.             if (!empty($filterCodes) && !in_array($data['code'], $filterCodes))
  2147.                 continue;
  2148.             if (!empty($filterMeasurements) && !in_array($data['measurementId'], $filterMeasurements))
  2149.                 continue;
  2150.             if (!empty($filterUnits) && !in_array($data['unitId'], $filterUnits))
  2151.                 continue;
  2153.             // Unit Price (Weighted Average)
  2154.             $unitPrice = 0;
  2155.             if ($data['totalQtyForCost'] > 0) {
  2156.                 $unitPrice = $data['totalCostSum'] / $data['totalQtyForCost'];
  2157.             }
  2159.             $currentStock = $data['currentStock'];
  2160.             $monthSales = ceil($data['monthlySales']);
  2161.             $total2025 = ceil($data['total2025']);
  2163.             // Scenario 1: Equal Distribution (Stock / 12)
  2164.             $allocatedEqual = $currentStock / 12;
  2165.             $orderEqual = 0;
  2166.             // Order amount is difference between Demand (monthSales) and Allocated Stock
  2167.             // 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."
  2168.             // So: monthSales - allocatedEqual
  2169.             if ($monthSales > $allocatedEqual) {
  2170.                 $orderEqual = $monthSales - $allocatedEqual;
  2171.             }
  2172.             $costEqual = $orderEqual * $unitPrice;
  2174.             // Scenario 2: Weighted Distribution (Stock * (MonthSale / YearSale))
  2175.             $allocatedWeighted = 0;
  2176.             if ($total2025 > 0) {
  2177.                 $ratio = $monthSales / $total2025;
  2178.                 $allocatedWeighted = $currentStock * $ratio;
  2179.             }
  2180.             $orderWeighted = 0;
  2181.             if ($monthSales > $allocatedWeighted) {
  2182.                 $orderWeighted = $monthSales - $allocatedWeighted;
  2183.             }
  2184.             $costWeighted = $orderWeighted * $unitPrice;
  2186.             // Add to totals
  2187.             $totalS1Order += ceil($orderEqual);
  2188.             $totalS1Cost += $costEqual;
  2189.             $totalS2Order += ceil($orderWeighted);
  2190.             $totalS2Cost += $costWeighted;
  2192.             $result[] = [
  2193.                 'name' => $data['name'],
  2194.                 'code' => $data['code'],
  2195.                 'currentStock' => $currentStock,
  2196.                 'sales2025' => $total2025,
  2197.                 'monthSales' => $monthSales, // Demand
  2198.                 'unitPrice' => round($unitPrice, 2),
  2200.                 // Scenario 1
  2201.                 'allocatedEqual' => floor($allocatedEqual),
  2202.                 'orderEqual' => ceil($orderEqual),
  2203.                 'costEqual' => round($costEqual, 2),
  2205.                 // Scenario 2
  2206.                 'allocatedWeighted' => floor($allocatedWeighted),
  2207.                 'orderWeighted' => ceil($orderWeighted),
  2208.                 'costWeighted' => round($costWeighted, 2),
  2209.                 'measurement' => $data['measurement'],
  2210.                 'measurementId' => $data['measurementId'],
  2211.                 'unitId' => $data['unitId'],
  2212.                 'unitSymbol' => $data['unitSymbol']
  2213.             ];
  2214.         }
  2216.         // Sort by Monthly Sales Descending (Primary focus) or Order Cost
  2217.         usort($result, function ($a, $b) {
  2218.             return $b['monthSales'] <=> $a['monthSales'];
  2219.         });
  2221.         return new JsonResponse([
  2222.             'data' => $result,
  2223.             'totals' => [
  2224.                 's1Order' => $totalS1Order,
  2225.                 's1Cost' => round($totalS1Cost, 2),
  2226.                 's2Order' => $totalS2Order,
  2227.                 's2Cost' => round($totalS2Cost, 2)
  2228.             ]
  2229.         ]);
  2230.     }
  2232.     /**
  2233.      * AJAX endpoint for detailed sales view (Sleeping Stock)
  2234.      * Combines detailed system sales with legacy aggregate data
  2235.      */
  2236.     #[Route('/admin/dashboard/product-sales-details/{id}', name: 'admin_dashboard_product_sales_details', methods: ['GET'])]
  2237.     public function getProductSalesDetails(int $id, ProductRepository $productRepository, SalesRepository $salesRepository, ProductMonthlyStatsRepository $statsRepository): JsonResponse
  2238.     {
  2239.         $product = $productRepository->find($id);
  2240.         if (!$product) {
  2241.             return new JsonResponse(['error' => 'Product not found'], 404);
  2242.         }
  2244.         // 1. Fetch System Sales (Detailed)
  2245.         $sales = $salesRepository->createQueryBuilder('s')
  2246.             ->join('s.productsSolds', 'ps')
  2247.             ->where('ps.product = :product')
  2248.             ->andWhere('s.deleted = :deleted')
  2249.             ->setParameter('product', $product)
  2250.             ->setParameter('deleted', false)
  2251.             ->orderBy('s.salesDate', 'DESC')
  2252.             ->getQuery()
  2253.             ->getResult();
  2255.         $detailedSales = [];
  2256.         $salesByMonth = []; // Key: 'Y-m', Value: quantity sum
  2258.         /** @var Sales $sale */
  2259.         foreach ($sales as $sale) {
  2260.             foreach ($sale->getProductsSolds() as $ps) {
  2261.                 if ($ps->getProduct()->getId() === $id) {
  2262.                     $date = $sale->getSalesDate();
  2263.                     $monthKey = $date ? $date->format('Y-m') : 'Unknown';
  2265.                     if (!isset($salesByMonth[$monthKey])) {
  2266.                         $salesByMonth[$monthKey] = 0;
  2267.                     }
  2268.                     $salesByMonth[$monthKey] += $ps->getQuantity();
  2270.                     $customerName = $sale->getCustomer() ? $sale->getCustomer()->getFullName() : 'Unknown';
  2271.                     // Check if customer name might be hidden/empty
  2272.                     if (trim($customerName) === '')
  2273.                         $customerName = 'Unknown';
  2275.                     $detailedSales[] = [
  2276.                         'type' => 'system',
  2277.                         'date' => $date ? $date->format('d.m.Y') : '-',
  2278.                         'customer' => $customerName,
  2279.                         'quantity' => (float) $ps->getQuantity(),
  2280.                         'price' => number_format((float) $ps->getTotalUnitPrice(), 2),
  2281.                         'total' => number_format((float) $ps->getTotalPrice(), 2),
  2282.                         'currency' => 'EUR', // Defaulting to EUR as per potential settings
  2283.                         'invoice' => $sale->getInvoiceNumber() ?: '-'
  2284.                     ];
  2285.                 }
  2286.             }
  2287.         }
  2289.         // 2. Fetch Monthly Stats (Aggregate) to find gaps
  2290.         // We look at the last 2 years for sleeping stock analysis usually
  2291.         $stats = $statsRepository->findBy(['product' => $product], ['year' => 'DESC', 'month' => 'DESC']);
  2293.         $finalList = $detailedSales;
  2295.         // Iterate stats to find "missing" sales (Legacy/Manual)
  2296.         foreach ($stats as $stat) {
  2297.             $year = $stat->getYear();
  2298.             $month = $stat->getMonth();
  2299.             $monthKey = sprintf('%04d-%02d', $year, $month);
  2301.             $statQty = (float) $stat->getTotalSalesQty();
  2302.             $systemQty = $salesByMonth[$monthKey] ?? 0;
  2304.             // If aggregate is significantly higher than system sales, show the difference as legacy
  2305.             if ($statQty > $systemQty + 0.01) {
  2306.                 $diff = $statQty - $systemQty;
  2307.                 // Add a "Legacy/Aggregate" row
  2308.                 $finalList[] = [
  2309.                     'type' => 'legacy',
  2310.                     'date' => sprintf('%02d.%04d', $month, $year), // Monthly precision
  2311.                     'customer' => '<em>Geçmiş Satış Kaydı (Detaysız)</em>',
  2312.                     'quantity' => $diff,
  2313.                     'price' => number_format((float) $stat->getAvgSalesPrice(), 2),
  2314.                     'total' => number_format($diff * (float) $stat->getAvgSalesPrice(), 2),
  2315.                     'currency' => 'EUR',
  2316.                     'invoice' => '-'
  2317.                 ];
  2318.             }
  2319.         }
  2321.         // Sort by date (parsing might be tricky mixed formats, but we can standardize sort key)
  2322.         usort($finalList, function ($a, $b) {
  2323.             // Helper to get timestamp
  2324.             $getTime = function ($item) {
  2325.                 if ($item['type'] === 'system') {
  2326.                     $d = \DateTime::createFromFormat('d.m.Y', $item['date']);
  2327.                     return $d ? $d->getTimestamp() : 0;
  2328.                 } else {
  2329.                     // Legacy date is 'm.Y', treat as start of month
  2330.                     $d = \DateTime::createFromFormat('m.Y', $item['date']);
  2331.                     return $d ? $d->getTimestamp() : 0;
  2332.                 }
  2333.             };
  2335.             return $getTime($b) <=> $getTime($a); // DESC
  2336.         });
  2338.         return new JsonResponse([
  2339.             'product' => [
  2340.                 'name' => $product->getName(),
  2341.                 'code' => $product->getCode()
  2342.             ],
  2343.             'sales' => $finalList
  2344.         ]);
  2345.     }
  2346. }