src/Controller/Admin/Sales/SalesController.php line 1430

Open in your IDE?
  1. <?php
  3. namespace App\Controller\Admin\Sales;
  5. use App\Dto\CalculatorProductsCostsDTO;
  6. use App\Dto\NewStockDto\SalesProductsDto;
  7. use App\Dto\PaginationDTO;
  8. use App\Dto\SalesProductsDtoBuilder;
  9. use App\Entity\Customer;
  10. use App\Entity\MeasurementUnits;
  11. use App\Entity\Payment;
  12. use App\Entity\ProductsSold;
  13. use App\Entity\Sales;
  14. use App\Entity\SalesHistory;
  15. use App\Entity\Stock;
  16. use App\Entity\StockTransaction;
  17. use App\Entity\User;
  18. use App\Entity\Warehouse;
  19. use App\Enum\SalesHistoryEventType;
  20. use App\Enum\SalesStatus;
  21. use App\Enum\SalesType;
  22. use App\Exception\IncorrectAmountException;
  23. use App\Exception\StockNotAvaibleException;
  24. use App\Exception\StockNotFoundException;
  25. use App\Form\CustomerType;
  26. use App\Form\PaymentType;
  27. use App\Form\ProductsSoldType;
  28. use App\Form\SalesFormType;
  29. use App\Repository\SalesRepository;
  30. use App\Repository\StockRepository;
  31. use App\Services\Customer\CustomerService;
  32. use App\Services\MailService;
  33. use App\Services\MeasurementConversions\MeasurementConversionsService;
  34. use App\Services\PDFService;
  35. use App\Services\LogService;
  36. use App\Services\Payment\PaymentMethodService;
  37. use App\Services\Payment\PaymentReminderService;
  38. use App\Services\Payment\PaymentService;
  39. use App\Services\Product\ProductService;
  40. use App\Services\Sales\Impl\SalesProductsServiceImpl;
  41. use App\Services\Sales\Impl\SalesServiceImpl;
  42. use App\Services\Sales\InvoiceService;
  43. use App\Services\Sales\SalesHistoryService;
  44. use App\Services\Sales\SalesService;
  45. use App\Repository\SalesReturnRepository;
  46. use App\Services\Stock\StockInfoService;
  47. use App\Services\Stock\StockService;
  48. use App\Services\Stock\StockTransferService;
  49. use App\Services\StockTransactionService;
  50. use App\Services\Warehouse\WarehouseService;
  51. use App\Utils\CurrencyHelper;
  52. use App\Utils\MailTemplateHelper;
  53. use Doctrine\DBAL\LockMode;
  54. use Doctrine\Common\Collections\ArrayCollection;
  55. use Doctrine\ORM\EntityManagerInterface;
  56. use Doctrine\ORM\NonUniqueResultException;
  57. use Doctrine\ORM\NoResultException;
  58. use Exception;
  59. use Knp\Bundle\SnappyBundle\Snappy\Response\PdfResponse;
  60. use Knp\Snappy\Pdf;
  61. use PhpOffice\PhpSpreadsheet\IOFactory;
  62. use Psr\Log\LoggerInterface;
  63. use Symfony\Bridge\Twig\Mime\TemplatedEmail;
  64. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  65. use Symfony\Component\HttpFoundation\BinaryFileResponse;
  66. use Symfony\Component\HttpFoundation\JsonResponse;
  67. use Symfony\Component\HttpFoundation\Request;
  68. use Symfony\Component\HttpFoundation\Response;
  69. use Symfony\Component\HttpFoundation\ResponseHeaderBag;
  70. use Symfony\Component\HttpKernel\KernelInterface;
  71. use Symfony\Component\Mailer\Exception\TransportExceptionInterface;
  72. use Symfony\Component\Mailer\Mailer;
  73. use Symfony\Component\Mailer\MailerInterface;
  74. use Symfony\Component\Mailer\Transport;
  75. use Symfony\Component\Mime\Address;
  76. use Symfony\Component\Mime\Email;
  77. use Symfony\Component\Routing\Annotation\Route;
  78. use Symfony\Component\Security\Core\User\UserInterface;
  79. use Symfony\Component\Serializer\SerializerInterface;
  80. use Symfony\Contracts\Translation\TranslatorInterface;
  82. class SalesController extends AbstractController
  83. {
  84.     private const STOCK_EXEMPT_PRODUCT_TYPES = ['INSTALLATION_SERVICE', 'MAINTENANCE_SERVICE', 'CONSULTATION_SERVICE', 'TREE'];
  85.     private const NEGATIVE_PRICE_ALLOWED_PRODUCT_TYPES = [];
  86.     private const MONEY_SCALE = 2;
  88.     private StockService $stockService;
  89.     private SerializerInterface $serializer;
  90.     private WarehouseService $warehouseService;
  91.     private SalesService $salesService;
  93.     private $projectDir;
  94.     private StockTransferService $stockTransferService;
  95.     private ProductService $productService;
  96.     private StockInfoService $stockInfoService;
  97.     private EntityManagerInterface $entityManager;
  98.     private StockRepository $stockRepository;
  99.     private CustomerService $customerService;
  100.     private PaymentMethodService $paymentMethodService;
  102.     private PaymentService $paymentService;
  103.     private PaymentReminderService $paymentReminderService;
  104.     private LogService $logService;
  105.     private StockTransactionService $stockTransactionService;
  106.     private LoggerInterface $logger;
  107.     private SalesProductsServiceImpl $salesProductsServiceImpl;
  108.     private SalesHistoryService $salesHistoryService;
  109.     private SalesReturnRepository $salesReturnRepository;
  110.     private \App\Services\GiftVoucherService $giftVoucherService;
  112.     private TranslatorInterface $translator;
  113.     private SalesServiceImpl $salesServiceImpl;
  114.     private Pdf $knpSnappyPdf;
  115.     private InvoiceService $invoiceService;
  117.     private PDFService $pdfService;
  118.     private MeasurementConversionsService $measurementConversionsService;
  120.     /**
  121.      * @param KernelInterface $kernel
  122.      * @param StockService $stockService
  123.      * @param SerializerInterface $serializer
  124.      * @param WarehouseService $warehouseService
  125.      * @param SalesService $salesService
  126.      * @param StockTransferService $stockTransferService
  127.      * @param ProductService $productService
  128.      * @param StockInfoService $stockInfoService
  129.      * @param EntityManagerInterface $entityManager
  130.      * @param StockRepository $stockRepository
  131.      * @param CustomerService $customerService
  132.      * @param PaymentMethodService $paymentMethodService
  133.      * @param PaymentService $paymentService
  134.      * @param PaymentReminderService $paymentReminderService
  135.      * @param LogService $logService
  136.      * @param StockTransactionService $stockTransactionService
  137.      * @param LoggerInterface $logger
  138.      * @param SalesProductsServiceImpl $salesProductsServiceImpl
  139.      * @param TranslatorInterface $translator
  140.      * @param SalesServiceImpl $salesServiceImpl
  141.      * @param Pdf $knpSnappyPdf
  142.      * @param InvoiceService $invoiceService
  143.      * @param PDFService $pdfService
  144.      * @param MeasurementConversionsService $measurementConversionsService
  145.      */
  146.     public function __construct(
  147.         KernelInterface $kernel,
  148.         StockService $stockService,
  149.         SerializerInterface $serializer,
  150.         WarehouseService $warehouseService,
  151.         SalesService $salesService,
  152.         StockTransferService $stockTransferService,
  153.         ProductService $productService,
  154.         StockInfoService $stockInfoService,
  155.         EntityManagerInterface $entityManager,
  156.         StockRepository $stockRepository,
  157.         CustomerService $customerService,
  158.         PaymentMethodService $paymentMethodService,
  159.         PaymentService $paymentService,
  160.         PaymentReminderService $paymentReminderService,
  161.         LogService $logService,
  162.         StockTransactionService $stockTransactionService,
  163.         LoggerInterface $logger,
  164.         SalesProductsServiceImpl $salesProductsServiceImpl,
  165.         SalesHistoryService $salesHistoryService,
  166.         SalesReturnRepository $salesReturnRepository,
  167.         TranslatorInterface $translator,
  168.         SalesServiceImpl $salesServiceImpl,
  169.         Pdf $knpSnappyPdf,
  170.         InvoiceService $invoiceService,
  171.         PDFService $pdfService,
  172.         MeasurementConversionsService $measurementConversionsService,
  173.         \App\Services\GiftVoucherService $giftVoucherService
  174.     ) {
  175.         $this->stockService = $stockService;
  176.         $this->serializer = $serializer;
  177.         $this->warehouseService = $warehouseService;
  178.         $this->salesService = $salesService;
  179.         $this->stockTransferService = $stockTransferService;
  180.         $this->productService = $productService;
  181.         $this->stockInfoService = $stockInfoService;
  182.         $this->entityManager = $entityManager;
  183.         $this->stockRepository = $stockRepository;
  184.         $this->customerService = $customerService;
  185.         $this->paymentMethodService = $paymentMethodService;
  186.         $this->paymentService = $paymentService;
  187.         $this->paymentReminderService = $paymentReminderService;
  188.         $this->logService = $logService;
  189.         $this->stockTransactionService = $stockTransactionService;
  190.         $this->logger = $logger;
  191.         $this->salesProductsServiceImpl = $salesProductsServiceImpl;
  192.         $this->salesHistoryService = $salesHistoryService;
  193.         $this->salesReturnRepository = $salesReturnRepository;
  194.         $this->translator = $translator;
  195.         $this->salesServiceImpl = $salesServiceImpl;
  196.         $this->projectDir = $kernel->getProjectDir();
  197.         $this->knpSnappyPdf = $knpSnappyPdf;
  198.         $this->invoiceService = $invoiceService;
  199.         $this->pdfService = $pdfService;
  200.         $this->measurementConversionsService = $measurementConversionsService;
  201.         $this->giftVoucherService = $giftVoucherService;
  202.     }
  205.     /**
  206.      * @throws StockNotAvaibleException
  207.      * @throws StockNotFoundException
  208.      */
  209.     #[Route('/sales', name: 'app_admin_sales')]
  210.     public function index(Request $request, SalesServiceImpl $salesServiceImpl, TranslatorInterface $translator): Response
  211.     {
  213.         $paymentMethods = $this->paymentMethodService->getPaymentMethods();
  215.         $sales = new Sales();
  216.         $sales->setInvoiceNumber($translator->trans('willBeCreatedAutomatically'));
  217.         $form = $this->createForm(SalesFormType::class, $sales);
  218.         $form->handleRequest($request);
  220.         $soldProducts = new ProductsSold();
  221.         $soldProductsFrom = $this->createForm(ProductsSoldType::class, $soldProducts);
  223.         $customer = new Customer();
  224.         $customer->setCode($this->customerService->createCustomerCode());
  225.         $customerForm = $this->createForm(CustomerType::class, $customer);
  226.         $customerForm->handleRequest($request);
  228.         $payment = new Payment();
  229.         $paymentForm = $this->createForm(PaymentType::class, $payment);
  230.         $paymentForm->handleRequest($request);
  232.         $stocks = $this->stockService->getAll();
  233.         $warehouses = $this->warehouseService->getAll();
  235.         if ($customerForm->isSubmitted() && $customerForm->isValid()) {
  236.             $customer = $customerForm->getData();
  237.             $customers = $this->customerService->findByFullName($customer->getFullName());
  239.             $this->addFlash('success', 'Müşteri başarıyla eklendi. Listeden seçebilirsiniz.');
  240.             $email = $customer->getEmail();
  241.             $customer->setEmail(mb_strtolower($email, 'UTF-8'));
  242.             $this->customerService->save($customerForm->getData());
  244.         }
  246.         return $this->render('admin/sales/index.html.twig', [
  247.             'controller_name' => 'SalesController',
  248.             'form' => $form->createView(),
  249.             'productsSoldForm' => $soldProductsFrom->createView(),
  250.             'customerForm' => $customerForm->createView(),
  251.             'paymentForm' => $paymentForm->createView(),
  252.             'warehouses' => $warehouses,
  253.             'paymentMethods' => $paymentMethods,
  254.         ]);
  255.     }
  258.     // Duplicate proforma
  259.     #[Route('/sales/duplicate/{id}', name: 'app_admin_sales_duplicate')]
  260.     public function duplicateProforma(Request $request, SalesServiceImpl $salesServiceImpl, TranslatorInterface $translator)
  261.     {
  263.         $paymentMethods = $this->paymentMethodService->getPaymentMethods();
  265.         $sales = $this->salesService->getEntityById($request->get('id'));
  266.         //        dd($sales->getProductsSolds()->get(0));
  267.         $sales->setInvoiceNumber($translator->trans('willBeCreatedAutomatically'));
  268.         $form = $this->createForm(SalesFormType::class, $sales);
  269.         $form->handleRequest($request);
  271.         $soldProducts = new ProductsSold();
  272.         $soldProductsFrom = $this->createForm(ProductsSoldType::class, $soldProducts);
  274.         $customer = new Customer();
  275.         $customer->setCode($this->customerService->createCustomerCode());
  276.         $customerForm = $this->createForm(CustomerType::class, $customer);
  277.         $customerForm->handleRequest($request);
  279.         $payment = new Payment();
  280.         $paymentForm = $this->createForm(PaymentType::class, $payment);
  281.         $paymentForm->handleRequest($request);
  283.         $stocks = $this->stockService->getAll();
  284.         $warehouses = $this->warehouseService->getAll();
  286.         if ($customerForm->isSubmitted() && $customerForm->isValid()) {
  287.             $customer = $customerForm->getData();
  288.             $customers = $this->customerService->findByFullName($customer->getFullName());
  289.             if (count($customers) > 0) {
  290.                 $this->addFlash('error', 'Bu müşteri kaydı zaten var ! Listeden seçip devam edebilirsiniz.');
  291.             } else {
  292.                 $this->addFlash('success', 'Müşteri başarıyla eklendi. Listeden seçebilirsiniz.');
  293.                 $email = $customer->getEmail();
  294.                 $customer->setEmail(mb_strtolower($email, 'UTF-8'));
  295.                 $this->customerService->save($customerForm->getData());
  296.             }
  297.         }
  299.         return $this->render('admin/sales/index.html.twig', [
  300.             'sales' => $sales,
  301.             'controller_name' => 'SalesController',
  302.             'form' => $form->createView(),
  303.             'productsSoldForm' => $soldProductsFrom->createView(),
  304.             'customerForm' => $customerForm->createView(),
  305.             'paymentForm' => $paymentForm->createView(),
  306.             'warehouses' => $warehouses,
  307.             'paymentMethods' => $paymentMethods,
  308.             'sales'
  309.         ]);
  311.     }
  313.     #[Route('/sales/create', name: 'app_admin_sales_create')]
  314.     public function create(Request $request, SalesServiceImpl $salesServiceImpl): Response
  315.     {
  317.         $this->logger->info("sales", [
  318.             'title' => 'Satış işlemi başlatıldı',
  319.             'request' => $request->request->all(),
  320.         ]);
  321.         $this->entityManager->beginTransaction();
  323.         $products = $request->get('products');
  324.         $payments = $request->get('payments');
  325.         $soldList = $request->get('soldList');
  326.         $invoice = $request->get('invoice');
  327.         $warehouseId = $soldList[0]['warehouse'];
  328.         $salesType = $invoice['salesType'] ?? 'proforma';
  330.         $intendedStatus = $this->resolveSalesStatus($invoice['salesStatus'] ?? null);
  331.         try {
  332.             // Stok kontrolü: yalnızca COMPLETED veya PENDING_ITEMS durumunda yapılır
  333.             if ($this->shouldAffectStock($intendedStatus)) {
  334.                 $this->checkStocks($soldList);
  335.             }
  337.             // Ürün bazlı indirim kdv gibi işlemler yapılıp total fiyatların frontend ile aynı olup olmadığı kontrol ediliyor.
  338.             foreach ($soldList as $soldProduct) {
  339.                 $this->logger->info("sales", [
  340.                     'title' => 'Ürün bazlı indirim kdv hesaplanıyor...',
  341.                     'product' => $soldProduct,
  342.                 ]);
  343.                 $this->assertUnitPriceAllowed($soldProduct);
  344.                 $this->calculateTotalPrice($soldProduct);
  345.             }
  347.             // Ödeme planı ile ürünlerin toplam fiyatlarının eşitliği kontrol ediliyor.
  348.             $totalPrice = $this->checkPaymentAndAmountIsEqual($payments, $soldList);
  350.             $repo = $this->entityManager->getRepository(Sales::class);
  351.             $invoiceNumber = $salesServiceImpl->createProformaNumber();
  352.             $sale = $repo->findBy(['invoiceNumber' => $invoiceNumber]);
  353.             //            dd($request);
  354.             if ($sale != null) {
  355.                 throw new Exception(sprintf("%s fatura numarası ile kayıtlı bir fatura var. Lütfen kontrol ediniz.", $invoice['invoiceNumber']));
  356.             } else {
  357.                 $soldProductsArray = new ArrayCollection();
  358.                 for ($i = 0; $i < count($soldList); $i++) {
  359.                     $product = $this->productService->getEntityId($soldList[$i]['productid']);
  360.                     $calculatorDto = $this->stockRepository->calculateCost($soldList[$i]['productid'], $warehouseId);
  361.                     $builder = new SalesProductsDtoBuilder();
  362.                     $soldProductsArray->add(
  363.                         $builder
  364.                             ->setProductName($soldList[$i]['productName'])
  365.                             ->setMeasurement($product->getMeasurement()?->getMeasurement())
  366.                             ->setQuantity($soldList[$i]['quantity'])
  367.                             ->setUnitPriceFob($calculatorDto->getPriceFob())
  368.                             ->setUnitPriceNavlun($calculatorDto->getPriceNavlun())
  369.                             ->setTotalUnitPrice($calculatorDto->getAverageCostPrice())
  370.                             ->setTotalUnitPurchasePrice($soldList[$i]['totalPurchasePrice'])
  371.                             ->setProductId($product->getId())
  372.                             ->setTotalUnitPrice($soldList[$i]['unitPrice'])
  373.                             ->setWarehouseId($warehouseId)
  374.                             ->setTax($soldList[$i]['tax'])
  375.                             ->setTotalSalePrice($soldList[$i]['totalPurchasePrice'])
  376.                             ->setDiscount($soldList[$i]['discount'])
  377.                             ->setUnAllocatedQuantity($soldList[$i]['unAllocatedQuantity'])
  378.                             ->setSelectedUnitId($soldList[$i]['selectedUnitId'])
  379.                             ->build()
  380.                     );
  381.                 }
  383.                 $customer = $this->customerService->getCustomerById($invoice['customer']);
  384.                 $sales = new Sales();
  385.                 $sales->setSalesDate(new \DateTime($invoice['salesDate']));
  386.                 $sales->setDeliveryDate(!empty($invoice['deliveryDate']) ? new \DateTime($invoice['deliveryDate']) : null);
  387.                 $sales->setDueDate(!empty($invoice['dueDate']) ? new \DateTime($invoice['dueDate']) : null);
  388.                 $sales->setValidDate(!empty($invoice['validDate']) ? new \DateTime($invoice['validDate']) : null);
  389.                 $sales->setCustomer($customer);
  390.                 $sales->setStatus($intendedStatus);
  391.                 $userRepo = $this->entityManager->getRepository(User::class);
  392.                 $sales->setSeller($userRepo->find($invoice['seller']));
  393.                 $sales->setInvoiceNumber($invoice['invoiceNumber']);
  394.                 $sales->setTotalPurchasePrice($totalPrice);
  395.                 $sales->setDescription($invoice['description']);
  396.                 $sales->setShippingNotes($invoice['shippingNotes']);
  397.                 $sales->setPaymentNotes($invoice['paymentNotes']);
  399.                 $performedBy = $this->getUser();
  400.                 $sales = $this->salesService->create(
  401.                     $sales,
  402.                     $soldProductsArray,
  403.                     $salesType,
  404.                     $performedBy instanceof User ? $performedBy : null
  405.                 );
  407.                 $this->createPayments($payments, $customer, $sales);
  408.                 $this->entityManager->commit();
  409.                 return new JsonResponse(['success' => true, 'id' => $sales->getId()]);
  410.             }
  413.         } catch (Exception $e) {
  414.             $this->entityManager->rollback();
  415.             $message = $e->getMessage();
  416.             return new JsonResponse(['status' => 'error', 'message' => $message], 400);
  417.         }
  419.     }
  422.     #[Route('/sales/un-allocated-products', name: 'un_allocated_products_index')]
  423.     public function getUnAllocatedProducts(Request $request)
  424.     {
  426.         $warehouses = $this->warehouseService->getAll();
  428.         if ($request->getMethod() == 'POST') {
  430.             if (isset($request->get('search')['value']))
  431.                 $s = $request->get('search')['value'];
  432.             else
  433.                 $s = '';
  435.             if (isset($request->get('order')[0]['column']))
  436.                 $column = $request->get('order')[0]['column'];
  437.             else
  438.                 $column = 0;
  440.             if (isset($request->get('order')[0]['dir']))
  441.                 $dir = $request->get('order')[0]['dir'];
  442.             else
  443.                 $dir = 'ASC';
  445.             $startDate = $request->get('startDate');
  446.             $finishDate = $request->get('finishDate');
  448.             $limit = $request->get('length');
  449.             if ($request->get('start'))
  450.                 $page = 1 + ($request->get('start') / $limit);
  451.             else
  452.                 $page = 1;
  454.             $warehouseid = $request->get('warehouseid');
  456.             $result = $this->salesProductsServiceImpl->getAllUnAllocatedProductsPaginate(
  457.                 $s,
  458.                 $column,
  459.                 $dir,
  460.                 $page,
  461.                 $limit,
  462.                 $startDate,
  463.                 $finishDate,
  464.                 $warehouseid
  465.             );
  466.             return $this->json($result);
  467.         }
  470.         return $this->render('admin/sales/unallocated_products.html.twig', [
  471.             'warehouses' => $warehouses
  472.         ]);
  473.     }
  475.     /**
  476.      * @throws NonUniqueResultException
  477.      * @throws NoResultException
  478.      */
  479.     #[Route('/sales/un-allocated-products/allocate', name: 'un_allocated_products_allocate')]
  480.     public function allocateProduct(Request $request)
  481.     {
  482.         $content = $request->getContent();
  483.         $data = json_decode($content, true);
  485.         $id = $data["id"];
  486.         $allocatedQuantity = $data["allocatedQuantity"];
  487.         $customer = $data["customer"];
  488.         $measurement = $data["measurement"];
  489.         $measurementUnit = $data["measurementUnit"];
  490.         $productCode = $data["productCode"];
  491.         $productName = $data["productName"];
  492.         $salesDate = $data["salesDate"];
  493.         $sellerName = $data["sellerName"];
  494.         $stockInfo = $data["stockInfo"];
  495.         $totalSold = $data["totalSold"];
  496.         $unAllocatedQuantity = $data["unAllocatedQuantity"];
  497.         $warehouseName = $data["warehouseName"];
  499.         $productSold = $this->salesProductsServiceImpl->getEntityById($id);
  501.         $quantityToAllocate = $allocatedQuantity - $productSold->getQuantity();
  503.         $stock = $this->stockInfoService->getStockInfoByProductAndWarehouse(
  504.             $productSold->getProduct(),
  505.             $productSold->getSales()->getWarehouse()
  506.         );
  507.         if ($quantityToAllocate > $stock->getTotalQuantity()) {
  508.             return $this->json([
  509.                 'message' => sprintf('Stok miktarı yetersiz, depodaki stok miktarı = %s', $stock->getTotalQuantity())
  510.             ], 400);
  511.         }
  512.         //        dd($quantityToAllocate, CurrencyHelper::convertToFloat($productSold->getUnAllocatedQuantity()));
  513.         $unAllocatedQuantityFromProduct = round(CurrencyHelper::convertToFloat($productSold->getUnAllocatedQuantity()), 2);
  514.         $quantityToAllocate = round($quantityToAllocate, 2);
  516.         if ($quantityToAllocate > $unAllocatedQuantityFromProduct) {
  517.             return $this->json([
  518.                 'message' => sprintf(
  519.                     'Hatalı bilgi. Tahsis etmek istediğiniz miktar tahsis edilmemiş miktardan büyük olamaz. Tahsis edilmemiş miktar = %s',
  520.                     $productSold->getUnAllocatedQuantity()
  521.                 )
  522.             ], 400);
  523.         }
  526.         return $this->json(
  527.             ['message' => $this->salesProductsServiceImpl->allocateQuantity($productSold, $quantityToAllocate)]
  528.         );
  530.     }
  532.     #[Route('/sales/un-allocated-products/detail/ajax', name: 'un_allocated_products_detail_ajax')]
  533.     public function getUnAllocatedProduct(Request $request)
  534.     {
  535.         /**
  536.          * @var ProductsSold $entity
  537.          */
  538.         $entity = $this->salesProductsServiceImpl->getEntityById($request->get('productSoldId'));
  539.         return $this->json([
  540.             'id' => $entity->getId(),
  541.             'productName' => $entity->getProduct()->getName(),
  542.             'productCode' => $entity->getProduct()->getCode(),
  543.             'measurement' => $entity->getProduct()->getMeasurement()->getName(),
  544.             'measurementUnit' => $entity->getProduct()->getMeasurementUnit()->getSymbol(),
  545.             'customer' => $entity->getSales()->getCustomer()->getFullName(),
  546.             'allocatedQuantity' => $entity->getQuantity(),
  547.             'unAllocatedQuantity' => $entity->getUnAllocatedQuantity(),
  548.             'salesDate' => $entity->getSales()->getSalesDate()->format('d.m.Y'),
  549.             'warehouseName' => $entity->getSales()->getWarehouse()->getName(),
  550.             'stockInfo' => $this->stockInfoService->getStockInfoByProductAndWarehouse(
  551.                 $entity->getProduct(),
  552.                 $entity->getSales()->getWarehouse()
  553.             )->getTotalQuantity(),
  554.             'sellerName' => $entity->getSales()->getSeller()->getFullname(),
  555.             'totalSold' => CurrencyHelper::convertToCurrency($entity->getQuantity() + ($entity->getUnAllocatedQuantity() == null ? 0 : $entity->getUnAllocatedQuantity())),
  556.         ]);
  557.     }
  560.     #[Route('/proforma/index', name: 'proforma_index')]
  561.     public function getAllProformas(Request $request, EntityManagerInterface $entityManager)
  562.     {
  563.         $warehouses = $this->warehouseService->getAll();
  565.         return $this->render('admin/sales/proforma_index.html.twig', [
  566.             'controller_name' => 'StockController',
  567.             'warehouses' => $warehouses
  568.         ]);
  569.     }
  572.     #[Route('/proforma/ajax', name: 'proforma_ajax')]
  573.     public function getAllProformasAjax(Request $request, SalesServiceImpl $salesServiceImpl)
  574.     {
  576.         $user = $this->getUser();
  577.         if (isset($request->get('search')['value']))
  578.             $s = $request->get('search')['value'];
  579.         else
  580.             $s = '';
  582.         $id = $request->get('id');
  583.         if (isset($request->get('order')[0]['column']))
  584.             $column = $request->get('order')[0]['column'];
  585.         else
  586.             $column = 0;
  587.         if (isset($request->get('order')[0]['dir']))
  588.             $dir = $request->get('order')[0]['dir'];
  589.         else
  590.             $dir = 'ASC';
  591.         $startDate = $request->get('startDate');
  592.         $finishDate = $request->get('finishDate');
  594.         $limit = $request->get('length');
  595.         if ($request->get('start'))
  596.             $page = 1 + ($request->get('start') / $limit);
  597.         else
  598.             $page = 1;
  599.         $warehouseid = $request->get('warehouseid');
  600.         $stocks = $salesServiceImpl->getAllProformasPaginate($user, $page, $limit, $warehouseid, $column, $dir, $s, $startDate, $finishDate);
  601.         return new JsonResponse($this->createArrayForDataTable($stocks));
  602.     }
  605.     private function createPayments($payments, $customer, $sales)
  606.     {
  607.         foreach ($payments as $payment) {
  608.             $paymentMethod = $this->paymentMethodService->getPaymentMethodById($payment['paymentMethod']);
  609.             $paymentObj = $this->paymentService->createPayment($customer, $paymentMethod, $sales, $payment['paymentDate'], $payment['amount'], $payment['status'], $payment['paymentDueDate'], $payment['description']);
  610.             $a = 0;
  611.             if ($paymentObj->getPaymentStatus() == 2) {
  612.                 $paymentReminder = $this->paymentReminderService->create($paymentObj, $payment['paymentDate'], $payment['status'], $payment['paymentMethod']);
  613.             }
  615.             // Hediye Çeki Entegrasyonu
  616.             if ($paymentMethod->getName() === 'Hediye Çeki' || $paymentMethod->getName() === 'Gift Voucher') {
  617.                 if (!empty($payment['voucherCode'])) {
  618.                     // Özel durum: AUTO_DEDUCT_FROM_BALANCE - Müşterinin bakiyesinden otomatik düş
  619.                     if ($payment['voucherCode'] === 'AUTO_DEDUCT_FROM_BALANCE') {
  620.                         // Müşterinin aktif hediye sertifikalarından otomatik mahsup yap
  621.                         $this->giftVoucherService->deductFromCustomerBalance(
  622.                             $customer,
  623.                             (float) $payment['amount'],
  624.                             $sales,
  625.                             $paymentObj
  626.                         );
  627.                     } else {
  628.                         // Normal hediye çeki kodu kullanımı
  629.                         $this->giftVoucherService->useVoucher(
  630.                             $payment['voucherCode'],
  631.                             (float) $payment['amount'],
  632.                             $sales,
  633.                             $paymentObj
  634.                         );
  635.                     }
  636.                 }
  637.             }
  638.         }
  639.     }
  641.     /**
  642.      * @throws StockNotAvaibleException
  643.      * @throws StockNotFoundException
  644.      */
  645.     private function checkStocks($soldList): array
  646.     {
  647.         $warehouseId = $soldList[0]['warehouse'];
  649.         $quantities = [];
  651.         foreach ($soldList as $soldProduct) {
  652.             $productId = $soldProduct['productid'];
  654.             // Ürün tipine göre stok kontrolünü atla (service & tree)
  655.             $product = $this->productService->getEntityId($productId);
  657.             if ($product && $this->isStockExemptProductType($product->getProductTypeEnum())) {
  658.                 continue; // bu ürünlerde stok kontrolü yapılmaz
  659.             }
  661.             // Birim dönüşümü: selectedUnitId farklı ise temel birime çevirerek topla
  662.             $rawQuantity = (float) $soldProduct['quantity'];
  663.             $selectedUnitId = $soldProduct['selectedUnitId'] ?? null;
  665.             if (!isset($quantities[$productId])) {
  666.                 $quantities[$productId] = 0.0;
  667.             }
  669.             if ($selectedUnitId) {
  670.                 // SalesServiceImpl içindeki dönüştürme mantığını kullan
  671.                 $converted = $this->salesServiceImpl->getConvertedQuantity($product, $selectedUnitId, $rawQuantity);
  672.                 $quantities[$productId] += (float) $converted;
  673.             } else {
  674.                 $quantities[$productId] += $rawQuantity;
  675.             }
  676.         }
  678.         foreach ($quantities as $productId => $quantity) {
  679.             $this->stockInfoService->checkIsStockAvailable($quantity, $productId, $warehouseId);
  680.         }
  682.         return $quantities;
  683.     }
  685.     /**
  686.      * @throws Exception
  687.      */
  688.     private function applyRoundingRule(float $value): float
  689.     {
  690.         return round($value, self::MONEY_SCALE, PHP_ROUND_HALF_UP);
  691.     }
  693.     /**
  694.      * @throws Exception
  695.      */
  696.     private function checkPaymentAndAmountIsEqual($payments, $soldList)
  697.     {
  698.         $totalPriceRaw = 0.0;
  699.         $totalAmountOfPayments = 0.0;
  701.         foreach ($payments as $payment) {
  702.             $totalAmountOfPayments += CurrencyHelper::convertToFloat($payment['amount']);
  703.         }
  705.         foreach ($soldList as $soldProduct) {
  706.             $totalPriceRaw += $this->calculateTotalPrice($soldProduct);
  707.         }
  709.         $totalPrice = $this->applyRoundingRule($totalPriceRaw);
  710.         $totalAmountOfPayments = $this->applyRoundingRule($totalAmountOfPayments);
  712.         $diff = abs($totalPrice - $totalAmountOfPayments);
  713.         if ($diff > 1) {
  714.             throw new Exception("Ödemeler ile ürünlerin fiyatları farklı. Toplam Ürün Fiyatı: " . $totalPrice . ", Toplam Ödeme: " . $totalAmountOfPayments . ", Fark: " . $diff, 401);
  715.         }
  716.         return $totalPrice;
  717.     }
  719.     /**
  720.      * @throws Exception
  721.      */
  722.     private function calculateTotalPrice($soldProduct): float
  723.     {
  724.         $quantity = CurrencyHelper::convertToFloat($soldProduct['quantity']);
  725.         $unAllocatedQuantity = CurrencyHelper::convertToFloat($soldProduct['unAllocatedQuantity']);
  726.         $tax = CurrencyHelper::convertToFloat($soldProduct['tax']);
  727.         $unitPrice = CurrencyHelper::convertToFloat($soldProduct['unitPrice']);
  728.         $discount = CurrencyHelper::convertToFloat($soldProduct['discount']);
  729.         $totalPurchasePrice = CurrencyHelper::convertToFloat($soldProduct['totalPurchasePrice']);
  731.         $totalQuantity = $quantity + $unAllocatedQuantity;
  733.         $subtotal = $totalQuantity * $unitPrice;
  734.         $discountAmount = $subtotal * ($discount / 100);
  735.         $afterDiscount = $subtotal - $discountAmount;
  736.         $taxAmount = $afterDiscount * ($tax / 100);
  737.         $lineTotal = $afterDiscount + $taxAmount;
  738.         $roundedLineTotal = $this->applyRoundingRule($lineTotal);
  739.         $roundedFrontend = $this->applyRoundingRule($totalPurchasePrice);
  740.         $difference = abs($roundedLineTotal - $roundedFrontend);
  741.         $rawDifference = abs($lineTotal - $totalPurchasePrice);
  742.         if ($difference > 1) {
  743.             throw new Exception("Fiyatlar arasında hesaplamada fark var. Backend: " . $roundedLineTotal . ", Frontend: " . $totalPurchasePrice . ", Fark: " . $difference, 401);
  744.         }
  746.         $this->logger->info("sales", [
  747.             'title' => 'Kullanıcının girdiği ödemeler ile ürün bazlı toplamlar karşılaştırılıyor',
  748.             'backend_rounded' => $roundedLineTotal,
  749.             'backend_raw' => $lineTotal,
  750.             'frontend' => $totalPurchasePrice,
  751.             'frontend_rounded' => $roundedFrontend,
  752.             'difference' => $difference,
  753.             'raw_difference' => $rawDifference,
  754.         ]);
  756.         return $lineTotal;
  757.     }
  759.     private function roundUpToTwoDecimalsPrecise($number)
  760.     {
  761.         return round(ceil($number * 1000) / 1000, 2);
  762.     }
  764.     #[Route('/product-calculate-cost', name: 'product_calculate_cost')]
  765.     public function exampleCostCalcolator(Request $request, StockRepository $stockRepository)
  766.     {
  767.         $repo = $stockRepository->calculateCost(30, 1);
  768.         return $this->json(['data' => 'data']);
  769.     }
  773.     #[Route('/stock-detail/{id}', name: 'app_admin_stock_detail')]
  774.     public function stockDetail(Request $request, $id)
  775.     {
  776.         $stock = $this->stockService->getStockById($id);
  777.         return $this->json($stock);
  778.     }
  781.     /**
  782.      * @throws Exception
  783.      */
  784.     #[Route('/product/{id}/measurement-units', name: 'get_product_measurement_units', methods: ['GET'])]
  785.     public function getAvailableMeasurementUnits(int $id): JsonResponse
  786.     {
  787.         $product = $this->productService->getEntityId($id);
  788.         if (!$product)
  789.             throw new Exception(sprintf("Product not found with %s", $id), 404);
  790.         $availableUnits = $this->measurementConversionsService->getAvailableUnitsFor($product);
  791.         //        dd($availableUnits);
  792.         return $this->json(
  793.             $availableUnits,
  794.             JsonResponse::HTTP_OK,
  795.             [],
  796.             ['groups' => 'measurement:read']
  797.         );
  798.     }
  802.     #[Route('/sales/detail/{id}', name: 'app_admin_sales_detail')]
  803.     public function edit(Request $request, $id, SalesRepository $salesRepository)
  804.     {
  805.         $payments = $request->get('payments');
  806.         $soldList = $request->get('soldList');
  807.         $oldStatus = $this->salesService->getEntityById($id)->getStatus();
  808.         $newStatus = $request->get('invoice')['salesStatus'] ?? null;
  811.         $sales = $this->salesServiceImpl->getEntityById(3);
  812.         if (isset($soldList[0]['warehouse']))
  813.             $warehouseId = $soldList[0]['warehouse'];
  814.         else
  815.             $warehouseId = 0;
  816.         $invoice = $request->get('invoice');
  817.         // Log the edit operation
  818.         $this->logger->info("sales", [
  819.             'title' => 'Satış düzenleme işlemi başlatıldı',
  820.             'saleId' => $id,
  821.             'request' => $request->request->all(),
  822.         ]);
  823.         $this->entityManager->beginTransaction();
  825.         try {
  826.             $sale = $this->salesService->getEntityById($id);
  828.             $form = $this->createForm(SalesFormType::class, $sale);
  829.             $soldProducts = new ProductsSold();
  830.             $soldProductsFrom = $this->createForm(ProductsSoldType::class, $soldProducts);
  831.             $form->handleRequest($request);
  833.             $customer = new Customer();
  834.             $customerForm = $this->createForm(CustomerType::class, $customer);
  836.             $customerForm->handleRequest($request);
  838.             if ($customerForm->isSubmitted() && $customerForm->isValid()) {
  839.                 /**
  840.                  * @var Customer $customer
  841.                  */
  842.                 $customer = $customerForm->getData();
  844.                 $this->addFlash('success', 'Müşteri başarıyla eklendi. Listeden seçebilirsiniz.');
  845.                 $email = $customer->getEmail();
  846.                 $customer->setEmail(mb_strtolower($email, 'UTF-8'));
  847.                 $this->customerService->save($customerForm->getData());
  849.                 $this->entityManager->commit();
  850.                 $referer = $request->headers->get('referer');
  851.                 return $this->redirect($referer ?: '/sales/detail/' . $id);
  852.             }
  854.             $payment = new Payment();
  855.             $paymentForm = $this->createForm(PaymentType::class, $payment);
  857.             $paymentMethods = $this->paymentMethodService->getPaymentMethods();
  859.             $warehouses = $this->warehouseService->getAll();
  860.             if ($request->getMethod() == 'POST') {
  862.                 $sale = $this->salesService->getEntityById($id);
  863.                 $salesType = $invoice['salesType'] ?? 'PROFORMA'; // Default to PROFORMA if not provided
  865.                 $groupedTotalQuantitiesByProduct = $salesRepository->getGroupedProductsSoldBySale($sale);
  867.                 // Stok kontrolü: yalnızca COMPLETED veya PENDING_ITEMS durumunda yapılır
  868.                 $intendedStatus = $this->resolveSalesStatus($invoice['salesStatus'] ?? null);
  869.                 if ($this->shouldAffectStock($intendedStatus)) {
  870.                     $this->checkStocksIsAvailableForEditedSale($soldList, $groupedTotalQuantitiesByProduct);
  871.                 }
  873.                 // Ürün bazlı indirim kdv gibi işlemler yapılıp total fiyatların frontend ile aynı olup olmadığı kontrol ediliyor.
  874.                 foreach ($soldList as $soldProduct) {
  875.                     $this->logger->info("sales", [
  876.                         'title' => 'Ürün bazlı indirim kdv hesaplanıyor (düzenleme)...',
  877.                         'product' => $soldProduct,
  878.                     ]);
  879.                     $this->assertUnitPriceAllowed($soldProduct);
  880.                     $this->calculateTotalPrice($soldProduct);
  881.                 }
  883.                 // Ödeme planı ile ürünlerin toplam fiyatlarının eşitliği kontrol ediliyor.
  884.                 $totalPrice = $this->checkPaymentAndAmountIsEqual($payments, $soldList);
  886.                 $repo = $this->entityManager->getRepository(Sales::class);
  888.                 $saleQ = $repo->createQueryBuilder('c')
  889.                     ->where('c.invoiceNumber = :invoiceNumber')
  890.                     ->andWhere('c.id != :id')
  891.                     ->setParameters(['invoiceNumber' => $invoice['invoiceNumber'], 'id' => $id])
  892.                     ->getQuery()
  893.                     ->getResult();
  894.                 if ($saleQ) {
  895.                     throw new Exception(sprintf("%s fatura numarasına kayıtlı bir satış mevcut.", $invoice['invoiceNumber']));
  896.                 } else {
  897.                     $soldProductsArray = new ArrayCollection();
  898.                     for ($i = 0; $i < count($soldList); $i++) {
  899.                         $product = $this->productService->getEntityId($soldList[$i]['productid']);
  900.                         $calculatorDto = $this->stockRepository->calculateCost($soldList[$i]['productid'], $warehouseId);
  902.                         $builder = new SalesProductsDtoBuilder();
  903.                         $soldProductsArray->add(
  904.                             $builder
  905.                                 ->setProductName($soldList[$i]['productName'] ?? $product->getName())
  906.                                 ->setMeasurement($product->getMeasurement()?->getMeasurement())
  907.                                 ->setQuantity($soldList[$i]['quantity'])
  908.                                 ->setUnitPriceFob($calculatorDto->getPriceFob())
  909.                                 ->setUnitPriceNavlun($calculatorDto->getPriceNavlun())
  910.                                 ->setTotalUnitPrice($soldList[$i]['unitPrice'])
  911.                                 ->setTotalUnitPurchasePrice($soldList[$i]['totalPurchasePrice'])
  912.                                 ->setProductId($product->getId())
  913.                                 ->setWarehouseId($warehouseId)
  914.                                 ->setTax($soldList[$i]['tax'])
  915.                                 ->setTotalSalePrice($soldList[$i]['totalPurchasePrice'])
  916.                                 ->setDiscount($soldList[$i]['discount'])
  917.                                 ->setUnAllocatedQuantity($soldList[$i]['unAllocatedQuantity'])
  918.                                 ->setSelectedUnitId($soldList[$i]['selectedUnitId'] ?? null)
  919.                                 ->build()
  920.                         );
  921.                     }
  923.                     $customer = $this->customerService->getCustomerById($invoice['customer']);
  925.                     $sale->setSalesDate(new \DateTime($invoice['salesDate']));
  926.                     $sale->setDeliveryDate(!empty($invoice['deliveryDate']) ? new \DateTime($invoice['deliveryDate']) : null);
  927.                     $sale->setDueDate(!empty($invoice['dueDate']) ? new \DateTime($invoice['dueDate']) : null);
  928.                     $sale->setValidDate(!empty($invoice['validDate']) ? new \DateTime($invoice['validDate']) : null);
  929.                     $sale->setCustomer($customer);
  930.                     $userRepo = $this->entityManager->getRepository(User::class);
  931.                     $sale->setSeller($userRepo->find($invoice['seller']));
  932.                     $sale->setInvoiceNumber($invoice['invoiceNumber']);
  933.                     $sale->setTotalPurchasePrice($totalPrice);
  934.                     $sale->setDescription($invoice['description']);
  935.                     $sale->setShippingNotes($invoice['shippingNotes']);
  936.                     $sale->setPaymentNotes($invoice['paymentNotes']);
  938.                     $performedBy = $this->getUser();
  939.                     $sale = $this->salesService->update(
  940.                         $sale,
  941.                         $soldProductsArray,
  942.                         $intendedStatus,
  943.                         $performedBy instanceof User ? $performedBy : null
  944.                     );
  945.                     $this->createPayments($payments, $customer, $sale);
  946.                     $this->entityManager->commit();
  948.                     return new JsonResponse(['success' => true]);
  949.                 }
  950.             }
  952.         } catch (Exception $exception) {
  953.             $this->entityManager->rollback();
  954.             $message = $exception->getMessage();
  955.             $this->logger->error("sales", [
  956.                 'title' => 'Satış düzenleme hatası',
  957.                 'error' => $message,
  958.                 'trace' => $exception->getTraceAsString()
  959.             ]);
  960.             return new JsonResponse(['status' => 'error', 'message' => $message], 400);
  961.         }
  963.         $historyEntries = $sale->getHistoryEntries()->toArray();
  964.         usort(
  965.             $historyEntries,
  966.             static fn(SalesHistory $a, SalesHistory $b) => $b->getPerformedAt()->getTimestamp() <=> $a->getPerformedAt()->getTimestamp()
  967.         );
  968.         $returns = $this->salesReturnRepository->findBy(['sale' => $sale], ['requestedAt' => 'DESC']);
  970.         // Check if returns can be created for this sale
  971.         $canCreateReturn = $this->canCreateReturnForSale($sale);
  973.         return $this->render('admin/sales/edit.html.twig', [
  974.             'sale' => $sale,
  975.             'form' => $form->createView(),
  976.             'warehouses' => $warehouses,
  977.             'productsSoldForm' => $soldProductsFrom->createView(),
  978.             'customerForm' => $customerForm->createView(),
  979.             'paymentForm' => $paymentForm->createView(),
  980.             'paymentMethods' => $paymentMethods,
  981.             'historyEntries' => $historyEntries,
  982.             'returns' => $returns,
  983.             'canCreateReturn' => $canCreateReturn,
  984.             'defaultMailContent' => $this->getDefaultMailContent(),
  985.         ]);
  986.     }
  990.     public function checkStocksIsAvailableForEditedSale($productToSolds, $soldQuantities)
  991.     {
  992.         $newProductSoldArr = [];
  993.         $warehouse = $productToSolds[0]['warehouse'];
  995.         foreach ($productToSolds as $productToSold) {
  996.             $productId = $productToSold['productid'];
  998.             // Ürün tipine göre stok kontrolünü atla (service & tree)
  999.             $product = $this->productService->getEntityId($productId);
  1001.             if ($product && $this->isStockExemptProductType($product->getProductTypeEnum())) {
  1002.                 continue; // bu ürünlerde stok kontrolü yapılmaz
  1003.             }
  1005.             // Birim dönüşümü: selectedUnitId farklı ise temel birime çevirerek topla
  1006.             $rawQuantity = (float) $productToSold['quantity'];
  1007.             $selectedUnitId = $productToSold['selectedUnitId'] ?? null;
  1009.             if (!isset($newProductSoldArr[$productId])) {
  1010.                 $newProductSoldArr[$productId] = 0.0;
  1011.             }
  1013.             if ($selectedUnitId) {
  1014.                 // SalesServiceImpl içindeki dönüştürme mantığını kullan
  1015.                 $converted = $this->salesServiceImpl->getConvertedQuantity($product, $selectedUnitId, $rawQuantity);
  1016.                 $newProductSoldArr[$productId] += (float) $converted;
  1017.             } else {
  1018.                 $newProductSoldArr[$productId] += $rawQuantity;
  1019.             }
  1020.         }
  1022.         foreach ($newProductSoldArr as $productId => $requiredQuantity) {
  1023.             $availableStock = $this->stockInfoService->getStockInfoByProductAndWarehouse(
  1024.                 $this->productService->getEntityId($productId),
  1025.                 $this->warehouseService->getEntityById($warehouse)
  1026.             );
  1027.             $previouslySoldQuantity = $this->findStockInArray($soldQuantities, $productId);
  1028.             $totalAvailableStock = $previouslySoldQuantity + $availableStock->getTotalQuantity();
  1030.             if ($requiredQuantity > $totalAvailableStock) {
  1031.                 throw new Exception(sprintf(
  1032.                     "Yetersiz stok. %s id'li ürün için toplam kullanılabilir stok miktarı = %s, talep edilen = %s",
  1033.                     $productId,
  1034.                     $totalAvailableStock,
  1035.                     $requiredQuantity
  1036.                 ));
  1037.             }
  1038.         }
  1039.         return true;
  1040.     }
  1042.     public function findStockInArray($arr, $productId)
  1043.     {
  1044.         foreach ($arr as $item) {
  1045.             if ($item['productId'] == $productId) {
  1046.                 return $item['totalQuantity'];
  1047.             }
  1048.         }
  1049.         return 0;
  1050.     }
  1052.     private function normalizeProductTypeName($type): ?string
  1053.     {
  1054.         if ($type instanceof \UnitEnum) {
  1055.             return $type->name;
  1056.         }
  1057.         if (is_array($type)) {
  1058.             return $type['name'] ?? ($type['key'] ?? null);
  1059.         }
  1060.         if (is_string($type)) {
  1061.             return strtoupper($type);
  1062.         }
  1063.         return null;
  1064.     }
  1066.     private function isStockExemptProductType($type): bool
  1067.     {
  1068.         $normalized = $this->normalizeProductTypeName($type);
  1069.         return $normalized ? in_array($normalized, self::STOCK_EXEMPT_PRODUCT_TYPES, true) : false;
  1070.     }
  1072.     private function canProductTypeUseNegativePrice($type): bool
  1073.     {
  1074.         $normalized = $this->normalizeProductTypeName($type);
  1075.         return $normalized ? in_array($normalized, self::NEGATIVE_PRICE_ALLOWED_PRODUCT_TYPES, true) : false;
  1076.     }
  1078.     private function assertUnitPriceAllowed(array $soldProduct): void
  1079.     {
  1080.         if (empty($soldProduct['productid']) || !array_key_exists('unitPrice', $soldProduct)) {
  1081.             return;
  1082.         }
  1084.         $product = $this->productService->getEntityId($soldProduct['productid']);
  1085.         if (!$product) {
  1086.             return;
  1087.         }
  1089.         $unitPrice = CurrencyHelper::convertToFloat($soldProduct['unitPrice']);
  1090.         $type = $product->getProductTypeEnum();
  1092.         if ($this->canProductTypeUseNegativePrice($type)) {
  1093.             if ($unitPrice >= 0) {
  1094.                 throw new Exception('Avoir ürünlerinde birim fiyat negatif olmalıdır.');
  1095.             }
  1096.             return;
  1097.         }
  1099.     }
  1101.     private function resolveSalesStatus(?string $status): SalesStatus
  1102.     {
  1103.         if ($status === null) {
  1104.             return SalesStatus::PENDING;
  1105.         }
  1107.         return SalesStatus::tryFrom($status) ?? SalesStatus::PENDING;
  1108.     }
  1110.     private function shouldAffectStock(SalesStatus $status): bool
  1111.     {
  1112.         return in_array($status, [SalesStatus::COMPLETED, SalesStatus::PENDING_ITEMS], true);
  1113.     }
  1115.     /**
  1116.      * Check if returns can be created for this sale
  1117.      * Returns can only be created for:
  1118.      * 1. Sales with COMPLETED or PENDING_ITEMS status
  1119.      * 2. Sales that have at least one physical product (excluding services, trees)
  1120.      */
  1121.     private function canCreateReturnForSale(Sales $sale): bool
  1122.     {
  1123.         // Check sale status
  1124.         $saleStatus = $sale->getStatus();
  1125.         if (!$saleStatus || !in_array($saleStatus, [SalesStatus::COMPLETED, SalesStatus::PENDING_ITEMS], true)) {
  1126.             return false;
  1127.         }
  1129.         // Check if there are any physical products
  1130.         $productsSold = $sale->getProductsSolds();
  1131.         foreach ($productsSold as $productSold) {
  1132.             if (!$productSold instanceof ProductsSold) {
  1133.                 continue;
  1134.             }
  1136.             $product = $productSold->getProduct();
  1137.             if (!$product) {
  1138.                 continue;
  1139.             }
  1141.             $type = $product->getProductTypeEnum();
  1142.             if (!$this->isStockExemptProductType($type)) {
  1143.                 return true; // Found at least one physical product
  1144.             }
  1145.         }
  1147.         return false; // No physical products found
  1148.     }
  1151.     #[Route('/delete-sales/{id}', name: 'delete-sales')]
  1152.     public function delete(Request $request, $id, EntityManagerInterface $entityManager)
  1153.     {
  1154.         $sale = $entityManager->getRepository(Sales::class)->find($id);
  1155.         if (!$sale) {
  1156.             throw $this->createNotFoundException('Satış bulunamadı.');
  1157.         }
  1159.         $performedBy = $this->getUser();
  1160.         $sale->setVisible(false);
  1161.         $this->salesHistoryService->record(
  1162.             $sale,
  1163.             SalesHistoryEventType::VISIBILITY_CHANGED,
  1164.             'Satış gizlendi (soft delete).',
  1165.             ['visible' => false],
  1166.             $performedBy instanceof User ? $performedBy : null
  1167.         );
  1168.         $entityManager->persist($sale);
  1169.         $entityManager->flush();
  1170.         $this->addFlash('success', 'Satış Başarıyla silindi. Stoklar eklendi');
  1171.         return $this->redirectToRoute('app_admin_sales');
  1172.         /*
  1173.         $sale = $entityManager->getRepository(Sales::class)->find($id);
  1174.         $entityManager->beginTransaction();
  1175.         try{
  1177.             if($sale->getInvoice() != null){
  1178.                 $this->invoiceService->deleteInvoice($sale->getInvoice());
  1179.             }
  1181.             if($sale->getStatus() === SalesStatus::PENDING_ITEMS || $sale->getStatus() === SalesStatus::COMPLETED){
  1182.                 $warehouse = $sale->getWarehouse();
  1184.                 foreach ($sale->getProductsSolds() as $salesProductsDto) {
  1185.                         $productEntity = $this->productService->getEntityId($salesProductsDto->getProduct()->getId());
  1186.                         $beforeQuantity = $this->stockInfoService->getStockInfoByProductAndWarehouse($productEntity, $warehouse)->getTotalQuantity();
  1187.                         $stockTransaction = new StockTransaction();
  1188.                         $stockTransaction->setWarehouse($warehouse);
  1189.                         $stockTransaction->setProductId($productEntity);
  1190.                         $stockTransaction->setName($productEntity->getName() . " Code " . $productEntity->getCode());
  1191.                         $stockTransaction->setQuantity($salesProductsDto->getQuantity());
  1192.                         $stockTransaction->setAction("IN");
  1193.                         $stockTransaction->setDescription("Satış siliyor bu yüzden ürün stoğu EKLENİYOR");
  1194.                         $stockTransaction->setBeforeQuantity(
  1195.                             $beforeQuantity
  1196.                         );
  1197.                         $this->stockInfoService->addStock( $productEntity, $warehouse,$salesProductsDto->getQuantity());
  1198.                         $stockTransaction->setAfterQuantity(
  1199.                             $this->stockInfoService->getStockInfoByProductAndWarehouse($productEntity, $warehouse)->getTotalQuantity()
  1200.                         );
  1201.                         $stockTransaction->setSale($sale);
  1202.                         $this->entityManager->remove($salesProductsDto);
  1203.                         $this->entityManager->persist($stockTransaction);
  1204.                     }
  1206.             }else{
  1207.                 $products = $sale->getProductsSolds();
  1208.                 foreach ($products as $product){
  1209.                     $this->entityManager->remove($product);
  1210.                 }
  1211.             }
  1214.             $payments = $sale->getPayments();
  1215.             foreach ($payments as $payment){
  1216.                 $this->paymentService->deletePayment($payment);
  1217.             }
  1219.             $entityManager->remove($sale);
  1220.             $entityManager->flush();
  1221.             $entityManager->commit();
  1222.             $this->addFlash('success', 'Satış Başarıyla silindi. Stoklar eklendi');
  1223.             return $this->redirectToRoute('app_admin_sales');
  1224.         }catch (\Exception $exception){
  1225.             $entityManager->rollback();
  1226.             throw $exception;
  1227.         }
  1228.         */
  1231.     }
  1233.     #[Route('/admin/sales/permanently-delete/{id}', name: 'app_admin_sales_permanently_delete', methods: ['POST'])]
  1234.     public function permanentlyDelete(
  1235.         Request $request,
  1236.         int $id,
  1237.         SalesRepository $salesRepository,
  1238.         EntityManagerInterface $entityManager,
  1239.         InvoiceService $invoiceService,
  1240.         ProductService $productService,
  1241.         StockInfoService $stockInfoService,
  1242.         PaymentService $paymentService
  1243.     ) {
  1244.         $sale = $salesRepository->find($id);
  1245.         if (!$sale) {
  1246.             return new JsonResponse(['success' => false, 'message' => 'Satış bulunamadı'], 404);
  1247.         }
  1249.         $user = $this->getUser();
  1250.         if (!$user || strtolower($user->getUserIdentifier()) !== 'gizli@kullanici.com') {
  1251.             return new JsonResponse(['success' => false, 'message' => 'Yetkiniz yok'], 403);
  1252.         }
  1254.         $entityManager->beginTransaction();
  1255.         try {
  1256.             // 1. Fatura Kontrolü ve Silme
  1257.             if ($sale->getInvoice() != null) {
  1258.                 // Faturayı sil
  1259.                 $invoiceService->deleteInvoice($sale->getInvoice());
  1260.                 $sale->setInvoice(null);
  1261.             }
  1263.             // 2. Stok İadesi (Stock Reversal)
  1264.             if ($sale->getStatus() === SalesStatus::PENDING_ITEMS || $sale->getStatus() === SalesStatus::COMPLETED) {
  1265.                 $warehouse = $sale->getWarehouse();
  1267.                 foreach ($sale->getProductsSolds() as $salesProductsDto) {
  1268.                     $productEntity = $this->productService->getEntityId($salesProductsDto->getProduct()->getId());
  1270.                     if ($this->shouldSkipStockUpdate($productEntity)) {
  1271.                         continue;
  1272.                     }
  1274.                     $beforeQuantity = $this->stockInfoService->getStockInfoByProductAndWarehouse($productEntity, $warehouse)->getTotalQuantity();
  1276.                     $quantityToReverse = $salesProductsDto->getBaseUnitQuantity();
  1278.                     if (($quantityToReverse === null || $quantityToReverse == 0) && $salesProductsDto->getSelectedUnit()) {
  1279.                         $quantityToReverse = $this->salesServiceImpl->getConvertedQuantity(
  1280.                             $productEntity,
  1281.                             $salesProductsDto->getSelectedUnit()->getId(),
  1282.                             $salesProductsDto->getQuantity()
  1283.                         );
  1284.                     }
  1286.                     if ($quantityToReverse === null || $quantityToReverse == 0) {
  1287.                         $quantityToReverse = $salesProductsDto->getQuantity();
  1288.                     }
  1291.                     $stockTransaction = new StockTransaction();
  1292.                     $stockTransaction->setWarehouse($warehouse);
  1293.                     $stockTransaction->setProductId($productEntity);
  1294.                     $stockTransaction->setName($productEntity->getName() . " Code " . $productEntity->getCode());
  1295.                     $stockTransaction->setQuantity($quantityToReverse);
  1296.                     $stockTransaction->setAction("IN");
  1297.                     $stockTransaction->setDescription("Satış kalıcı olarak silindi (Soft Delete), stok iade edildi. Satış ID: " . $sale->getId());
  1298.                     $stockTransaction->setBeforeQuantity($beforeQuantity);
  1300.                     $this->stockInfoService->addStock($productEntity, $warehouse, $quantityToReverse);
  1302.                     $stockTransaction->setAfterQuantity(
  1303.                         $this->stockInfoService->getStockInfoByProductAndWarehouse($productEntity, $warehouse)->getTotalQuantity()
  1304.                     );
  1305.                     $stockTransaction->setSale($sale);
  1307.                     $entityManager->persist($stockTransaction);
  1308.                 }
  1309.             }
  1311.             // 3. Ödemelerin Silinmesi ve İadesi
  1312.             $payments = $sale->getPayments();
  1313.             foreach ($payments as $payment) {
  1314.                 // Ek Kural: Hediye Çeki veya Müşteri Bakiyesi İadesi
  1315.                 $paymentMethod = $payment->getPaymentMethod();
  1316.                 if (
  1317.                     $paymentMethod && (
  1318.                         stripos($paymentMethod->getName(), 'Hediye') !== false ||
  1319.                         stripos($paymentMethod->getName(), 'Gift') !== false ||
  1320.                         stripos($paymentMethod->getName(), 'Kupon') !== false
  1321.                     )
  1322.                 ) {
  1323.                     // Müşteriye yeni bir hediye çeki (bakiye) oluşturarak iade yapalım.
  1324.                     // Çünkü hangi çekten düştüğünü takip eden yapı (GiftVoucherUsage) invoice tarafında olabilir ama auto-deduct'ta yoktu.
  1325.                     // En güvenli yöntem: Müşteriye iade tutarı kadar yeni bir hediye çeki tanımlamak.
  1327.                     $refundDescription = sprintf('İade: Silinen Satış #%s Ödemesi', $sale->getInvoiceNumber() ?? $sale->getId());
  1328.                     $this->giftVoucherService->createVoucher(
  1329.                         (float) $payment->getAmount(),
  1330.                         $user, // İşlemi yapan admin
  1331.                         $sale->getCustomer(),
  1332.                         (new \DateTime())->modify('+1 year') // 1 yıl geçerli
  1333.                     );
  1335.                     // Loglama gerekirse buraya eklenebilir.
  1336.                 }
  1338.                 $entityManager->remove($payment);
  1339.             }
  1341.             // 4. Loglama
  1342.             $this->salesHistoryService->record(
  1343.                 $sale,
  1344.                 SalesHistoryEventType::DELETED,
  1345.                 'Satış kalıcı olarak silindi (Flagged as deleted).',
  1346.                 ['deleted' => true, 'visible' => false],
  1347.                 $user instanceof User ? $user : null
  1348.             );
  1350.             // 5. Satış Kaydının İşlenmesi (Flag Update)
  1351.             $sale->setDeleted(true);
  1352.             $sale->setVisible(false);
  1354.             $entityManager->flush();
  1355.             $entityManager->commit();
  1357.             return new JsonResponse(['success' => true]);
  1359.         } catch (\Exception $e) {
  1360.             $entityManager->rollback();
  1361.             $this->logger->error('Kalıcı silme hatası: ' . $e->getMessage());
  1362.             return new JsonResponse(['success' => false, 'message' => 'İşlem sırasında hata: ' . $e->getMessage()], 500);
  1363.         }
  1364.     }
  1366.     #[Route('/admin/sales/restore/{id}', name: 'app_admin_sales_restore', methods: ['POST'])]
  1367.     public function restoreSales(Request $request, int $id, SalesRepository $salesRepository, EntityManagerInterface $entityManager)
  1368.     {
  1369.         $sale = $salesRepository->find($id);
  1370.         if (!$sale) {
  1371.             return new JsonResponse(['success' => false, 'message' => 'Satış bulunamadı'], 404);
  1372.         }
  1374.         $user = $this->getUser();
  1375.         if (!$user || strtolower($user->getUserIdentifier()) !== 'gizli@kullanici.com') {
  1376.             return new JsonResponse(['success' => false, 'message' => 'Yetkiniz yok'], 403);
  1377.         }
  1379.         try {
  1380.             $sale->setVisible(true);
  1381.             $sale->setDeleted(false); // Also unset deleted flag if it was set
  1383.             $this->salesHistoryService->record(
  1384.                 $sale,
  1385.                 SalesHistoryEventType::VISIBILITY_CHANGED, // Or RESTORED if available
  1386.                 'Satış tekrar görünür yapıldı.',
  1387.                 ['visible' => true, 'deleted' => false],
  1388.                 $user instanceof User ? $user : null
  1389.             );
  1391.             $entityManager->flush();
  1393.             return new JsonResponse(['success' => true]);
  1394.         } catch (\Exception $e) {
  1395.             return new JsonResponse(['success' => false, 'message' => 'Hata: ' . $e->getMessage()], 500);
  1396.         }
  1397.     }
  1399.     private function shouldSkipStockUpdate($product): bool
  1400.     {
  1401.         // Service ve Tree gibi tiplerde stok tutulmuyorsa true dönmeli
  1402.         // ProductTypeEnum kontrolü gerekebilir. 
  1403.         // Mevcut kodda checkStocks fonksiyonunda: $this->isStockExemptProductType($product->getProductTypeEnum()) kullanılıyor.
  1404.         return $product && $this->isStockExemptProductType($product->getProductTypeEnum());
  1405.     }
  1407.     #[Route('/warehouse-stocks/{warehouseId}', name: 'app_admin_warehouse_stock_information')]
  1408.     public function getStockByWarehouse(Request $request, $warehouseId)
  1409.     {
  1410.         $stocks = $this->stockService->getStocksByWarehouse($warehouseId);
  1411.         return $this->json($stocks);
  1412.     }
  1414.     // Tüm satışlar anasayfa
  1415.     #[Route('/sales/all', name: 'app_admin_sales_all')]
  1416.     public function showAll(Request $request, EntityManagerInterface $entityManager)
  1417.     {
  1418.         $warehouses = $this->warehouseService->getAll();
  1420.         return $this->render('admin/sales/allsales.html.twig', [
  1421.             'controller_name' => 'StockController',
  1422.             'warehouses' => $warehouses,
  1423.             'statuses' => SalesStatus::cases(),
  1424.             'defaultMailContent' => $this->getDefaultMailContent(),
  1425.         ]);
  1426.     }
  1428.     // Tüm satışlar ajax ile dataların gönderiliyor
  1429.     #[Route('/admin/sales/show', name: 'app_admin_sales_show')]
  1430.     public function show(Request $request, EntityManagerInterface $entityManager)
  1431.     {
  1433.         if (isset($request->get('search')['value']))
  1434.             $s = $request->get('search')['value'];
  1435.         else
  1436.             $s = '';
  1438.         $id = $request->get('id');
  1439.         if (isset($request->get('order')[0]['column']))
  1440.             $column = $request->get('order')[0]['column'];
  1441.         else
  1442.             $column = 0;
  1443.         if (isset($request->get('order')[0]['dir']))
  1444.             $dir = $request->get('order')[0]['dir'];
  1445.         else
  1446.             $dir = 'ASC';
  1447.         $startDate = $request->get('startDate');
  1448.         $finishDate = $request->get('finishDate');
  1450.         $limit = $request->get('length');
  1451.         if ($request->get('start'))
  1452.             $page = 1 + ($request->get('start') / $limit);
  1453.         else
  1454.             $page = 1;
  1455.         $warehouseid = $request->get('warehouseid');
  1456.         $statusParam = $request->get('status');
  1457.         $status = null;
  1458.         if (!empty($statusParam)) {
  1459.             try {
  1460.                 $status = SalesStatus::from($statusParam);
  1461.             } catch (\ValueError $exception) {
  1462.                 $status = null;
  1463.             }
  1464.         }
  1466.         $stocks = $this->salesService->getAllSalesPaginate($page, $limit, $warehouseid, $column, $dir, $s, $startDate, $finishDate, $status, $this->getUser());
  1467.         return new JsonResponse($this->createArrayForDataTable($stocks));
  1468.     }
  1470.     private function getPdfContentFromProforma($proformaId)
  1471.     {
  1472.         $logoPath = $this->projectDir . '/public/images/decopierrelogo.png';
  1473.         $logoDataUri = '';
  1475.         if (file_exists($logoPath)) {
  1476.             $logoBase64 = base64_encode(file_get_contents($logoPath));
  1477.             $logoDataUri = 'data:' . mime_content_type($logoPath) . ';base64,' . $logoBase64;
  1478.         }
  1480.         $sales = $this->salesServiceImpl->getEntityById($proformaId);
  1482.         if (!$sales) {
  1483.             return null; // Fatura bulunamazsa null döndür
  1484.         }
  1486.         $companyData = [
  1487.             'name' => 'DECO PIERRE ET NATURE',
  1488.             'address' => '152 ROUTE DE GRENOBLE 69800 SAINT PRIEST, France',
  1489.             'siren' => '948485271',
  1490.             'tva' => 'FR13948485271',
  1491.             'contact' => 'MATHIAS | 0652901882 | decopierreetnature@gmail.com',
  1492.             'bank_details' => [
  1493.                 'titulaire' => 'SAS FAV',
  1494.                 'bank_name' => 'BANQUE POPULAIRE',
  1495.                 'code_banque' => '16807',
  1496.                 'num_compte' => '37402602218',
  1497.                 'iban' => 'FR7616807004133740260221837',
  1498.                 'bic' => 'CCBPFRPPGRE'
  1499.             ]
  1500.         ];
  1502.         $html = $this->renderView('/admin/sales/proforma.html.twig', [
  1503.             'proforma' => $sales,
  1504.             'logo_data_uri' => $logoDataUri,
  1505.             'company' => $companyData
  1506.         ]);
  1508.         $footerHtml = $this->renderView('/admin/sales/invoice_footer.html.twig', [
  1509.             'company' => $companyData
  1510.         ]);
  1512.         $options = [
  1513.             'footer-html' => $footerHtml,
  1514.             'margin-bottom' => 30,
  1515.             'enable-local-file-access' => true,
  1516.             'encoding' => 'UTF-8',
  1517.         ];
  1519.         return [
  1520.             'html' => $html,
  1521.             'options' => $options,
  1522.         ];
  1523.     }
  1525.     private function getDefaultMailContent(): string
  1526.     {
  1527.         return MailTemplateHelper::getDefaultMailContent();
  1528.     }
  1530.     private function applyMailPlaceholders(string $mailContent, Sales $sale): string
  1531.     {
  1532.         $customer = $sale->getCustomer();
  1534.         $placeholders = [
  1535.             '[[client_name]]' => $customer ? (string) $customer->getFullName() : '',
  1536.             '[[client_email]]' => $customer && $customer->getEmail() ? (string) $customer->getEmail() : '',
  1537.             '[[client_phone]]' => $customer && $customer->getPhone() ? (string) $customer->getPhone() : '',
  1538.         ];
  1540.         foreach ($placeholders as $placeholder => $value) {
  1541.             $mailContent = str_replace($placeholder, $value ?? '', $mailContent);
  1542.         }
  1544.         return $mailContent;
  1545.     }
  1547.     private function getPdfContentFromInvoice(int $invoiceId): ?array
  1548.     {
  1549.         $logoPath = $this->projectDir . '/public/images/decopierrelogo.png';
  1550.         $logoDataUri = '';
  1552.         if (file_exists($logoPath)) {
  1553.             $logoBase64 = base64_encode(file_get_contents($logoPath));
  1554.             $logoDataUri = 'data:' . mime_content_type($logoPath) . ';base64,' . $logoBase64;
  1555.         }
  1557.         $invoice = $this->invoiceService->getEntityById($invoiceId);
  1559.         if (!$invoice) {
  1560.             return null;
  1561.         }
  1563.         $companyData = [
  1564.             'name' => 'DECO PIERRE ET NATURE',
  1565.             'address' => '152 ROUTE DE GRENOBLE 69800 SAINT PRIEST, France',
  1566.             'siren' => '948485271',
  1567.             'tva' => 'FR13948485271',
  1568.             'contact' => 'MATHIAS | 0652901882 | decopierreetnature@gmail.com',
  1569.             'bank_details' => [
  1570.                 'titulaire' => 'SAS FAV',
  1571.                 'bank_name' => 'BANQUE POPULAIRE',
  1572.                 'code_banque' => '16807',
  1573.                 'num_compte' => '37402602218',
  1574.                 'iban' => 'FR7616807004133740260221837',
  1575.                 'bic' => 'CCBPFRPPGRE'
  1576.             ]
  1577.         ];
  1579.         $html = $this->renderView('/admin/sales/invoice.html.twig', [
  1580.             'invoice' => $invoice,
  1581.             'logo_data_uri' => $logoDataUri,
  1582.             'company' => $companyData
  1583.         ]);
  1585.         $footerHtml = $this->renderView('/admin/sales/invoice_footer.html.twig', [
  1586.             'company' => $companyData
  1587.         ]);
  1589.         $options = [
  1590.             'footer-html' => $footerHtml,
  1591.             'margin-bottom' => 30,
  1592.             'enable-local-file-access' => true,
  1593.             'encoding' => 'UTF-8',
  1594.         ];
  1596.         return [
  1597.             'html' => $html,
  1598.             'options' => $options,
  1599.         ];
  1600.     }
  1602.     #[Route('/proforma/send-mail/{proformaId}', name: 'proforma_send_mail', methods: ['POST'])]
  1603.     public function sendMailToCustomer(Request $request, $proformaId, MailService $mailService)
  1604.     {
  1605.         $sale = $this->salesService->getEntityById($proformaId);
  1607.         if (!$sale) {
  1608.             return new JsonResponse(['message' => 'sale_not_found'], 404);
  1609.         }
  1611.         $data = json_decode($request->getContent(), true);
  1612.         if (json_last_error() !== JSON_ERROR_NONE || !is_array($data)) {
  1613.             $data = $request->request->all();
  1614.         }
  1616.         $recipientsRaw = $data['recipients'] ?? [];
  1617.         if (!is_array($recipientsRaw)) {
  1618.             $recipientsRaw = explode(',', (string) $recipientsRaw);
  1619.         }
  1621.         if (empty($recipientsRaw) && $sale->getCustomer() && $sale->getCustomer()->getEmail()) {
  1622.             $recipientsRaw = [$sale->getCustomer()->getEmail()];
  1623.         }
  1625.         $recipients = [];
  1626.         foreach ($recipientsRaw as $recipient) {
  1627.             $recipient = mb_strtolower(trim((string) $recipient));
  1628.             if ($recipient && filter_var($recipient, FILTER_VALIDATE_EMAIL)) {
  1629.                 $recipients[] = $recipient;
  1630.             }
  1631.         }
  1632.         $recipients = array_values(array_unique($recipients));
  1634.         if (!$recipients) {
  1635.             return new JsonResponse(['message' => 'recipient_not_found'], 400);
  1636.         }
  1638.         $mailContent = $data['content'] ?? $this->getDefaultMailContent();
  1639.         if (!$mailContent) {
  1640.             $mailContent = $this->getDefaultMailContent();
  1641.         }
  1642.         $mailContent = $this->applyMailPlaceholders($mailContent, $sale);
  1644.         $includeProforma = array_key_exists('includeProforma', $data)
  1645.             ? filter_var($data['includeProforma'], FILTER_VALIDATE_BOOLEAN)
  1646.             : true;
  1648.         $includeInvoice = array_key_exists('includeInvoice', $data)
  1649.             ? filter_var($data['includeInvoice'], FILTER_VALIDATE_BOOLEAN)
  1650.             : ($sale->getInvoice() !== null);
  1652.         $attachments = [];
  1654.         if ($includeProforma) {
  1655.             $proformaContent = $this->getPdfContentFromProforma($proformaId);
  1656.             if ($proformaContent) {
  1657.                 $proformaPath = $this->pdfService->convertAndSave(
  1658.                     $proformaContent['html'],
  1659.                     $sale->getInvoiceNumber(),
  1660.                     'proforma',
  1661.                     $proformaContent['options']
  1662.                 );
  1663.                 if ($proformaPath && file_exists($proformaPath)) {
  1664.                     $attachments[] = $proformaPath;
  1665.                 }
  1666.             }
  1667.         }
  1669.         if ($includeInvoice && $sale->getInvoice()) {
  1670.             $invoiceContent = $this->getPdfContentFromInvoice($sale->getInvoice()->getId());
  1671.             if ($invoiceContent) {
  1672.                 $invoicePath = $this->pdfService->convertAndSave(
  1673.                     $invoiceContent['html'],
  1674.                     $sale->getInvoice()->getInvoiceNumber(),
  1675.                     'invoice',
  1676.                     $invoiceContent['options']
  1677.                 );
  1678.                 if ($invoicePath && file_exists($invoicePath)) {
  1679.                     $attachments[] = $invoicePath;
  1680.                 }
  1681.             }
  1682.         }
  1684.         $subject = ($includeInvoice && $sale->getInvoice())
  1685.             ? 'Facture ' . $sale->getInvoice()->getInvoiceNumber()
  1686.             : 'Devis ' . $sale->getInvoiceNumber();
  1688.         //        dd($mailContent);
  1689.         $result = $mailService->sendAdvancedMail([
  1690.             'to' => $recipients,
  1691.             'subject' => $subject,
  1692.             'html' => $mailContent,
  1693.             'bcc' => ['arsiv@decopierrenature.com'],
  1694.             'replyTo' => 'decopierrefatih@gmail.com',
  1695.             'attachments' => array_values(array_unique($attachments)),
  1696.             'sale' => $sale,
  1697.             'senderUser' => $this->getUser(),
  1698.         ]);
  1700.         $message = $result ? 'success' : 'error';
  1702.         return new JsonResponse(['message' => $message]);
  1703.     }
  1705.     /**
  1706.      * @throws Exception
  1707.      */
  1708.     #[Route('/proforma/convert-to-invoice/{salesId}', name: 'proforma_convert_to_invoice')]
  1709.     public function convertToInvoice(int $salesId): JsonResponse
  1710.     {
  1711.         $this->entityManager->beginTransaction();
  1713.         try {
  1714.             /** @var Sales|null $sales */
  1715.             $sales = $this->entityManager->getRepository(Sales::class)->find($salesId, LockMode::PESSIMISTIC_WRITE);
  1717.             if (!$sales) {
  1718.                 throw new Exception(sprintf("Proforma not found with %s id", $salesId));
  1719.             }
  1721.             if ($sales->getInvoice()) {
  1722.                 $invoiceId = $sales->getInvoice()->getId();
  1723.                 $this->entityManager->commit();
  1725.                 return new JsonResponse(
  1726.                     [
  1727.                         'success' => false,
  1728.                         'message' => 'invoice_already_exists',
  1729.                         'invoiceId' => $invoiceId,
  1730.                     ],
  1731.                     Response::HTTP_CONFLICT
  1732.                 );
  1733.             }
  1735.             $invoice = $this->invoiceService->create($sales);
  1736.             $this->entityManager->commit();
  1738.             return new JsonResponse(
  1739.                 [
  1740.                     'success' => true,
  1741.                     'invoiceId' => $invoice->getId(),
  1742.                 ],
  1743.                 Response::HTTP_CREATED
  1744.             );
  1745.         } catch (Exception $exception) {
  1746.             $this->entityManager->rollback();
  1747.             throw $exception;
  1748.         }
  1749.     }
  1751.     private function createArrayForDataTable($stocks): array
  1752.     {
  1753.         $records = [];
  1754.         $records['recordsTotal'] = $stocks->getTotalItemCount();
  1755.         $records['recordsFiltered'] = $stocks->getTotalItemCount();
  1756.         $records["data"] = [];
  1758.         /**
  1759.          * @var Sales $entity
  1760.          */
  1761.         foreach ($stocks as $entity) {
  1762.             $pdfLink = '/admin/sales/proforma/generate-pdf/' . $entity->getId();
  1763.             $printLink = '/admin/sales/proforma/preview-print/' . $entity->getId();
  1764.             $showProforma = '/admin/sales/proforma/' . $entity->getId();
  1766.             $customer = $entity->getCustomer();
  1767.             $customerName = $customer ? (string) $customer->getFullName() : '';
  1768.             $customerEmail = $customer && $customer->getEmail() ? mb_strtolower((string) $customer->getEmail(), 'UTF-8') : '';
  1769.             $customerPhone = $customer && $customer->getPhone() ? (string) $customer->getPhone() : '';
  1771.             $proformaPreviewUrl = $this->generateUrl('admin_sales_proforma_preview_print', ['salesId' => $entity->getId()]);
  1772.             $invoicePreviewUrl = $entity->getInvoice() ? $this->generateUrl('admin_sales_invoice_preview_print', ['invoiceId' => $entity->getInvoice()->getId()]) : '';
  1773.             $sendMailUrl = $this->generateUrl('proforma_send_mail', ['proformaId' => $entity->getId()]);
  1775.             $sendMailAttributes = sprintf(
  1776.                 'data-id="%s" data-sale-id="%s" data-send-url="%s" data-default-email="%s" data-customer-name="%s" data-customer-email="%s" data-customer-phone="%s" data-proforma-url="%s" data-invoice-url="%s" data-has-invoice="%s"',
  1777.                 htmlspecialchars((string) $entity->getId(), ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8'),
  1778.                 htmlspecialchars((string) $entity->getId(), ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8'),
  1779.                 htmlspecialchars($sendMailUrl, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8'),
  1780.                 htmlspecialchars($customerEmail, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8'),
  1781.                 htmlspecialchars($customerName, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8'),
  1782.                 htmlspecialchars($customerEmail, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8'),
  1783.                 htmlspecialchars($customerPhone, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8'),
  1784.                 htmlspecialchars($proformaPreviewUrl, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8'),
  1785.                 htmlspecialchars($invoicePreviewUrl, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8'),
  1786.                 $entity->getInvoice() ? '1' : '0'
  1787.             );
  1789.             $actionButtons = '';
  1791.             // Hidden User Buttons for Hidden Sales
  1792.             if ($this->getUser() && strtolower($this->getUser()->getUserIdentifier()) === 'gizli@kullanici.com' && !$entity->isVisible()) {
  1793.                 $actionButtons .= '<a href="javascript:void(0);" class="restore-sale-btn" data-id="' . $entity->getId() . '" title="Görünür Yap" style="margin-right: 8px;"><i class="fas fa-eye fa-lg" style="color: #17a2b8;"></i></a>';
  1794.                 $actionButtons .= '<a href="javascript:void(0);" class="permanently-delete-btn" data-id="' . $entity->getId() . '" title="Kalıcı Olarak Sil" style="margin-right: 8px;"><i class="fas fa-trash-alt fa-lg" style="color: #d32f2f;"></i></a>';
  1795.             }
  1797.             // Existing Buttons
  1798.             $actionButtons .= sprintf(
  1799.                 '<a href="%s" target="_blank" title="Download PDF" style="margin-right: 8px;"><i class="far fa-file-pdf fa-lg" style="color: #d32f2f;"></i></a>
  1800.                         <a type="button" class="send-mail-btn" %s title="Send Mail" style="margin-right: 8px;"><i class="fas fa-mail-bulk fa-lg" style="color: #3498db;"></i></a>
  1801.                         <a href="%s" title="Print" target="_blank"><i class="fas fa-print fa-lg" style="color: #026309;"></i></a>
  1802.                         <a href="%s" title="Show" target="_blank"><i class="fas fa-eye fa-lg"></i></a>',
  1803.                 $pdfLink,
  1804.                 $sendMailAttributes,
  1805.                 $printLink,
  1806.                 $showProforma
  1807.             );
  1809.             $actions = $actionButtons;
  1811.             $salesStatus = $entity->getStatus();
  1812.             $statusLabel = $salesStatus?->getLabel() ?? 'Belirtilmedi';
  1813.             $statusValue = $salesStatus?->value ?? 'UNSPECIFIED';
  1814.             $statusCell = sprintf(
  1815.                 "<span class='sales-status-badge' data-status='%s'>%s</span>",
  1816.                 htmlspecialchars($statusValue, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8'),
  1817.                 htmlspecialchars($statusLabel, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8')
  1818.             );
  1820.             $records["data"][] = [
  1821.                 $entity->getId(),
  1822.                 $entity->getInvoiceNumber(),
  1823.                 $customerName,
  1824.                 CurrencyHelper::convertToCurrency($entity->getTotalPurchasePrice()) . ' ' . $this->translator->trans('currency.symbol'),
  1825.                 $entity->getSeller()->getFullname(),
  1826.                 $entity->getInvoice() ?
  1827.                 "<a target='_blank' href='" . $this->generateUrl('admin_sales_invoice_preview_print', ['invoiceId' => $entity->getInvoice()->getId()]) . "' class='btn btn-primary btn-xs showInvoiceBtn'>" . $this->translator->trans('showInvoice') . "</a>" :
  1828.                 "<a target='_blank' data-id='" . $entity->getId() . "' class='btn btn-warning btn-xs convertToInvoiceBtn'>" . $this->translator->trans('convertToInvoice') . "</a>",
  1829.                 $entity->getSalesDate()->format('d.m.Y'),
  1830.                 $statusCell,
  1831.                 $this->getPaymentStatus($entity),
  1832.                 $actions
  1833.             ];
  1834.         }
  1836.         return $records;
  1837.     }
  1838.     private function getPaymentStatus(Sales $sales)
  1839.     {
  1840.         $paymentStatus = '';
  1841.         foreach ($sales->getPayments() as $payment) {
  1842.             if ($payment->getPaymentStatus() == 2) {
  1843.                 $paymentStatus = "TERM_SALE-" . $this->translator->trans('payment_status.term_sale');
  1844.                 break;
  1845.             }
  1846.             if ($payment->getPaymentStatus() == 1) {
  1847.                 $paymentStatus = "UNPAID-" . $this->translator->trans('payment_status.not_paid');
  1848.                 ;
  1849.                 break;
  1850.             }
  1851.             $paymentStatus = "PAID-" . $this->translator->trans('payment_status.paid');
  1852.             ;
  1854.         }
  1855.         return $paymentStatus;
  1856.     }
  1858.     // PROFORMAYI HTML SAYFASI OLARAK GÖSTERİYOR
  1859.     #[Route('/admin/sales/proforma/{salesId}', name: 'admin_sales_proforma_show')]
  1860.     public function showInvoice(Request $request, $salesId)
  1861.     {
  1862.         $logoPath = $this->projectDir . '/public/images/decopierrelogo.png';
  1863.         $logoDataUri = '';
  1865.         if (file_exists($logoPath)) {
  1866.             $logoBase64 = base64_encode(file_get_contents($logoPath));
  1867.             $logoDataUri = 'data:' . mime_content_type($logoPath) . ';base64,' . $logoBase64;
  1868.         }
  1870.         $sales = $this->salesServiceImpl->getEntityById($salesId);
  1872.         $html = $this->render('/admin/sales/proforma.html.twig', [
  1873.             'proforma' => $sales,
  1874.             'logo_data_uri' => $logoDataUri,
  1875.             'company' => [
  1876.                 'name' => 'DECO PIERRE & NATURE',
  1877.                 'address' => '152 ROUTE DE GRENOBLE 69800 SAINT PRIEST, France',
  1878.                 'siren' => '948485271',
  1879.                 'tva' => 'FR13948485271',
  1880.                 'contact' => 'MATHIAS | 0652901882 | decopierreetnature@gmail.com'
  1881.             ]
  1882.         ]);
  1884.         return $html;
  1885.     }
  1888.     // PROFORMAYI PDF OLARAK İNDİRİYOR
  1889.     #[Route('/admin/sales/proforma/generate-pdf/{salesId}', name: 'admin_sales_proforma_generate_pdf')]
  1890.     public function generatePdf(Request $request, $salesId, Pdf $knpSnappyPdf)
  1891.     {
  1892.         $logoPath = $this->projectDir . '/public/images/decopierrelogo.png';
  1893.         $logoDataUri = '';
  1895.         if (file_exists($logoPath)) {
  1896.             $logoBase64 = base64_encode(file_get_contents($logoPath));
  1897.             $logoDataUri = 'data:' . mime_content_type($logoPath) . ';base64,' . $logoBase64;
  1898.         }
  1900.         $invoice = $this->salesServiceImpl->getEntityById($salesId);
  1902.         // Şirket ve banka bilgilerini içeren bir array oluşturun
  1903.         $companyData = [
  1904.             'name' => 'DECO PIERRE ET NATURE',
  1905.             'address' => '152 ROUTE DE GRENOBLE 69800 SAINT PRIEST, France',
  1906.             'siren' => '948485271',
  1907.             'tva' => 'FR13948485271',
  1908.             'contact' => 'MATHIAS | 0652901882 | decopierreetnature@gmail.com',
  1909.             'bank_details' => [
  1910.                 'titulaire' => 'SAS FAV',
  1911.                 'bank_name' => 'BANQUE POPULAIRE',
  1912.                 'code_banque' => '16807',
  1913.                 'num_compte' => '37402602218',
  1914.                 'iban' => 'FR7616807004133740260221837',
  1915.                 'bic' => 'CCBPFRPPGRE'
  1916.             ]
  1917.         ];
  1919.         // Ana fatura içeriği için Twig render'ı
  1920.         $html = $this->renderView('/admin/sales/proforma.html.twig', [
  1921.             'proforma' => $invoice,
  1922.             'logo_data_uri' => $logoDataUri,
  1923.             'company' => $companyData
  1924.         ]);
  1926.         // Footer içeriği için Twig render'ı
  1927.         // NOT: footer.html.twig dosyasına sadece companyData'yı göndermeniz yeterlidir.
  1928.         $footerHtml = $this->renderView('/admin/sales/invoice_footer.html.twig', [
  1929.             'company' => $companyData
  1930.         ]);
  1932.         $options = [
  1933.             'footer-html' => $footerHtml,
  1934.             'margin-bottom' => 30,
  1935.             'enable-local-file-access' => true,
  1936.             'encoding' => 'UTF-8',
  1937.         ];
  1939.         return new PdfResponse(
  1940.             $knpSnappyPdf->getOutputFromHtml($html, $options),
  1941.             $invoice->getInvoiceNumber() . '.pdf',
  1942.             'inline'
  1943.         );
  1946.     }
  1949.     // PROFORMAYI PDF OLARAK KAYDEDİYOR DOSYA YOLU DÖNÜYOR
  1950.     private function createAndSavePdf(int $invoiceId): ?string
  1951.     {
  1952.         $content = $this->getPdfContentFromProforma($invoiceId);
  1953.         return $this->pdfService->convertAndSave($content['html'], $invoiceId, 'proforma', $content['options']);
  1954.     }
  1957.     // PROFORMAYI PDF OLARAK AÇAR ANCAK YAZDIRMA SEÇENEĞİ AÇILMAZ
  1958.     #[Route('/admin/sales/proforma/send-pdf/{salesId}', name: 'admin_sales_proforma_send_pdf')]
  1959.     public function sendPdf(Request $request, int $salesId): Response
  1960.     {
  1961.         $filePath = $this->createAndSavePdf($salesId);
  1963.         if (!$filePath || !file_exists($filePath)) {
  1964.             throw $this->createNotFoundException('PDF dosyası oluşturulamadı veya bulunamadı.');
  1965.         }
  1967.         $sales = $this->salesServiceImpl->getEntityById($salesId);
  1968.         $fileName = $sales ? $sales->getInvoiceNumber() . '.pdf' : 'fatura.pdf';
  1970.         $response = new BinaryFileResponse($filePath);
  1971.         $response->setContentDisposition(
  1972.             ResponseHeaderBag::DISPOSITION_INLINE,
  1973.             $fileName
  1974.         );
  1976.         $response->headers->set('Cache-Control', 'no-cache, no-store, must-revalidate');
  1977.         $response->headers->set('Pragma', 'no-cache');
  1978.         $response->headers->set('Expires', '0');
  1980.         return $response;
  1981.     }
  1983.     // PROFORMAYI PDF OLARAK AÇAR VE YAZDIRMA SEÇENEĞİ ÇIKAR
  1984.     #[Route('/admin/sales/proforma/preview-print/{salesId}', name: 'admin_sales_proforma_preview_print')]
  1985.     public function previewAndPrint(int $salesId): Response
  1986.     {
  1987.         return $this->render('/admin/sales/proforma_print_preview.html.twig', [
  1988.             'salesId' => $salesId,
  1989.             'pdf_url' => $this->generateUrl('admin_sales_proforma_send_pdf', ['salesId' => $salesId]),
  1990.         ]);
  1991.     }
  1993.     public function findColumn($rank)
  1994.     {
  1995.         $columns = [
  1996.             'id',
  1997.             'invoiceNumber',
  1998.             'salesCompany',
  1999.             'totalPurchasePrice',
  2000.             'seller',
  2001.             'salesDate'
  2002.         ];
  2003.         return $columns[$rank];
  2004.     }
  2010.     #[Route('/admin/excel')]
  2011.     public function excelDetail()
  2012.     {
  2013.         $spreadsheet = IOFactory::load($this->getParameter('kernel.project_dir') . '/public/yeni.xlsx'); // Here we are able to read from the excel file
  2014.         $row = $spreadsheet->getActiveSheet()->removeRow(1); // I added this to be able to remove the first file line
  2015.         $sheetData = $spreadsheet->getActiveSheet()->toArray(null, true, true, true); // here, the read data is turned into an array
  2016.         dd($sheetData);
  2017.     }
  2019.     #[Route('/product-cost-detail/{id}', name: 'product_cost_detail')]
  2020.     public function getProductCost(Request $request, $id)
  2021.     {
  2022.         $warehouseId = $request->get('warehouse');
  2024.         $product = $this->productService->getEntityId($id);
  2025.         $warehouse = $this->entityManager->getRepository(Warehouse::class)->findOneBy(['id' => $warehouseId]);
  2027.         /**
  2028.          * @var CalculatorProductsCostsDTO $cost
  2029.          */
  2030.         $cost = $this->stockRepository->calculateCost($id, $warehouse);
  2031.         $stock = $this->stockInfoService->getStockInfoByProductAndWarehouse($product, $warehouse);
  2032.         $info = [
  2033.             'cost' => $cost->getAverageCostPrice(),
  2034.             'stock' => $stock->getTotalQuantity(),
  2035.             'measurement' => $product->getMeasurementUnit()?->getName(),
  2036.         ];
  2037.         return $this->json($info);
  2038.     }
  2041.     #[Route('/hesapla/kar')]
  2042.     public function calculateProfitOrDamage(EntityManagerInterface $entityManager)
  2043.     {
  2044.         $salesId = 13;
  2045.         $productId = 16;
  2046.         $quantity = 8;
  2047.         $totalPrice = 55.1;
  2048.         $sale = $this->salesService->getEntityById($salesId);
  2049.         $product = $this->productService->getEntityId($productId);
  2050.         $product->getStockTransferProducts();
  2051.         $warehouse = $sale->getWarehouse();
  2052.         $stockRepo = $entityManager->getRepository(Stock::class);
  2053.         $lastStock = $stockRepo->findOneBy(['product' => $product, 'warehouse' => $warehouse], ['createdAt' => 'desc']);
  2054.         $stockTransfer = $lastStock->getStockTransfer();
  2055.         dd($stockTransfer);
  2056.         dd($product->getStockTransferProducts());
  2057.         //        $transferProduct = $this->stockTransferService->getEntityById($sale-)
  2058.     }
  2069. }