src/Controller/SellerController.php line 32

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\Shop;
  6. use App\Entity\Product;
  7. use App\Entity\Category;
  8. use App\Entity\ShopPlan;
  9. use App\Entity\OrderItem;
  10. use Symfony\Bridge\Doctrine\Attribute\MapEntity;
  11. use App\Entity\User;
  12. use App\Form\SellerShopType;
  13. use App\Repository\ShopPlanRepository;
  14. use App\Service\NotificationService;
  15. use App\Service\ShopLimitService;
  16. use Doctrine\ORM\EntityManagerInterface;
  17. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  18. use Symfony\Component\HttpFoundation\JsonResponse;
  19. use Symfony\Component\HttpFoundation\Request;
  20. use Symfony\Component\HttpFoundation\Response;
  21. use Symfony\Component\Mailer\MailerInterface;
  22. use Symfony\Bridge\Twig\Mime\TemplatedEmail;
  23. use Symfony\Component\Mime\Address as EmailAddress;
  24. use Symfony\Component\Routing\Annotation\Route;
  25. use Symfony\Component\String\Slugger\AsciiSlugger;
  26. use function Symfony\Component\String\s;
  28. #[Route('/seller_space', name: 'seller_')]
  29. class SellerController extends AbstractController
  30. {
  31.     #[Route('/', name: 'index')]
  32.     public function indexSeller(EntityManagerInterface $em): Response
  33.     {
  34.         if (!$this->getUser()) {
  35.             return $this->redirectToRoute('ui_app_login');
  36.         }
  37.         if (!$this->isAuthorized()) {
  38.             return $this->render('misc/access_denied.html.twig');
  39.         }
  41.         $user = $this->getUser();
  42.         if (!$user instanceof User) {
  43.             return $this->redirectToRoute('ui_app_login');
  44.         }
  46.         // Récupérer toutes les boutiques de l'utilisateur (relation ManyToMany)
  47.         $shops = $em->getRepository(Shop::class)
  48.             ->createQueryBuilder('s')
  49.             ->where(':user MEMBER OF s.manager')
  50.             ->setParameter('user', $user)
  51.             ->getQuery()
  52.             ->getResult();
  53.         $shopsCount = count($shops);
  55.         // Initialiser les statistiques
  56.         $stats = [
  57.             'shopsCount' => $shopsCount,
  58.             'totalProducts' => 0,
  59.             'activeProducts' => 0,
  60.             'totalOrders' => 0,
  61.             'totalRevenue' => 0.0,
  62.             'averageCart' => 0.0,
  63.             'conversionRate' => 0.0,
  64.             'totalFollowers' => 0,
  65.             'totalViews' => 0,
  66.             'recentOrders' => [],
  67.             'topShops' => []
  68.         ];
  70.         if ($shopsCount > 0) {
  71.             // Calculer le nombre total de produits
  72.             $totalProducts = $em->getRepository(Product::class)
  73.                 ->createQueryBuilder('p')
  74.                 ->select('COUNT(p.id)')
  75.                 ->where('p.shop IN (:shops)')
  76.                 ->setParameter('shops', $shops)
  77.                 ->getQuery()
  78.                 ->getSingleScalarResult();
  79.             $stats['totalProducts'] = (int)$totalProducts;
  81.             // Calculer le nombre de produits actifs
  82.             $activeProducts = $em->getRepository(Product::class)
  83.                 ->createQueryBuilder('p')
  84.                 ->select('COUNT(p.id)')
  85.                 ->where('p.shop IN (:shops)')
  86.                 ->andWhere('p.isActive = :active')
  87.                 ->setParameter('shops', $shops)
  88.                 ->setParameter('active', true)
  89.                 ->getQuery()
  90.                 ->getSingleScalarResult();
  91.             $stats['activeProducts'] = (int)$activeProducts;
  93.             // Calculer le nombre total de commandes
  94.             try {
  95.                 $totalOrders = $em->createQueryBuilder()
  96.                     ->select('COUNT(DISTINCT o.id)')
  97.                     ->from(\App\Entity\Order::class, 'o')
  98.                     ->join('o.items', 'oi')
  99.                     ->join('oi.product', 'p')
  100.                     ->where('p.shop IN (:shops)')
  101.                     ->setParameter('shops', $shops)
  102.                     ->getQuery()
  103.                     ->getSingleScalarResult();
  104.                 $stats['totalOrders'] = (int)$totalOrders;
  106.                 // Calculer le chiffre d'affaires total
  107.                 $totalRevenue = $em->createQueryBuilder()
  108.                     ->select('COALESCE(SUM(CAST(oi.totalPrice AS DECIMAL(10,2))), 0)')
  109.                     ->from(OrderItem::class, 'oi')
  110.                     ->join('oi.product', 'p')
  111.                     ->join('oi.order', 'o')
  112.                     ->where('p.shop IN (:shops)')
  113.                     ->andWhere('o.paymentStatus = :paid')
  114.                     ->setParameter('shops', $shops)
  115.                     ->setParameter('paid', 'paid')
  116.                     ->getQuery()
  117.                     ->getSingleScalarResult();
  118.                 $stats['totalRevenue'] = (float)$totalRevenue;
  120.                 // Calculer le panier moyen
  121.                 if ($stats['totalOrders'] > 0) {
  122.                     $stats['averageCart'] = $stats['totalRevenue'] / $stats['totalOrders'];
  123.                 }
  125.                 // Récupérer les commandes récentes (10 dernières)
  126.                 $recentOrders = $em->getRepository(\App\Entity\Order::class)
  127.                     ->createQueryBuilder('o')
  128.                     ->select('DISTINCT o')
  129.                     ->leftJoin('o.items', 'oi')
  130.                     ->leftJoin('oi.product', 'p')
  131.                     ->leftJoin('o.customer', 'c')
  132.                     ->addSelect('oi', 'p', 'c')
  133.                     ->where('p.shop IN (:shops)')
  134.                     ->setParameter('shops', $shops)
  135.                     ->orderBy('o.orderedAt', 'DESC')
  136.                     ->setMaxResults(10)
  137.                     ->getQuery()
  138.                     ->getResult();
  139.                 $stats['recentOrders'] = $recentOrders;
  140.             } catch (\Exception $e) {
  141.                 // Si l'entité Order n'existe pas encore, on continue avec des valeurs par défaut
  142.             }
  144.             // Calculer le total des followers (somme des followers de toutes les boutiques)
  145.             foreach ($shops as $shop) {
  146.                 $stats['totalFollowers'] += $shop->getFollowerCount() ?? 0;
  147.                 $stats['totalViews'] += $shop->getViewCount() ?? 0;
  148.             }
  150.             // Calculer le taux de conversion (approximation basée sur les vues et commandes)
  151.             if ($stats['totalViews'] > 0) {
  152.                 $stats['conversionRate'] = ($stats['totalOrders'] / $stats['totalViews']) * 100;
  153.             }
  155.             // Calculer les top boutiques par revenus
  156.             $topShops = [];
  157.             foreach ($shops as $shop) {
  158.                 try {
  159.                     $shopRevenue = $em->createQueryBuilder()
  160.                         ->select('COALESCE(SUM(CAST(oi.totalPrice AS DECIMAL(10,2))), 0)')
  161.                         ->from(OrderItem::class, 'oi')
  162.                         ->join('oi.product', 'p')
  163.                         ->join('oi.order', 'o')
  164.                         ->where('p.shop = :shop')
  165.                         ->andWhere('o.paymentStatus = :paid')
  166.                         ->setParameter('shop', $shop)
  167.                         ->setParameter('paid', 'paid')
  168.                         ->getQuery()
  169.                         ->getSingleScalarResult();
  170.                     
  171.                     $topShops[] = [
  172.                         'shop' => $shop,
  173.                         'revenue' => (float)$shopRevenue
  174.                     ];
  175.                 } catch (\Exception $e) {
  176.                     $topShops[] = [
  177.                         'shop' => $shop,
  178.                         'revenue' => 0.0
  179.                     ];
  180.                 }
  181.             }
  182.             // Trier par revenus décroissants
  183.             usort($topShops, function($a, $b) {
  184.                 return $b['revenue'] <=> $a['revenue'];
  185.             });
  186.             $stats['topShops'] = array_slice($topShops, 0, 5); // Top 5
  187.         }
  189.         return $this->render('seller/index.html.twig', [
  190.             'current_menu' => 'home',
  191.             'stats' => $stats,
  192.             'shops' => $shops
  193.         ]);
  194.     }
  196.     #[Route('/help/how-to-sell', name: 'help_how_to_sell')]
  197.     public function howToSell(): Response
  198.     {
  199.         return $this->render('seller/help/how_to_sell.html.twig', [
  200.             'current_menu' => 'help'
  201.         ]);
  202.     }
  204.     #[Route('/help/pricing', name: 'help_pricing')]
  205.     public function pricing(EntityManagerInterface $em): Response
  206.     {
  207.         $shopPlans = $em->getRepository(ShopPlan::class)->findAll();
  208.         return $this->render('seller/help/pricing.html.twig', [
  209.             'current_menu' => 'help',
  210.             'shopPlans' => $shopPlans
  211.         ]);
  212.     }
  214.     #[Route('/help/support', name: 'help_support')]
  215.     public function support(): Response
  216.     {
  217.         return $this->render('seller/help/support.html.twig', [
  218.             'current_menu' => 'help'
  219.         ]);
  220.     }
  222.     #[Route('/shop/new', name: 'shop_new')]
  223.     public function newShopSeller(Request $request, EntityManagerInterface $entityManager, NotificationService $notificationService, MailerInterface $mailer, ShopLimitService $shopLimitService): Response
  224.     {
  225.         if (!$this->getUser()) {
  226.             return $this->redirectToRoute('ui_app_login');
  227.         }
  228.         if (!$this->isAuthorized()) {
  229.             return $this->render('misc/access_denied.html.twig');
  230.         }
  231.         
  232.         // Récupérer l'utilisateur et vérifier la limite dès l'accès à la page
  233.         $authenticatedUser = $this->getUser();
  234.         if (!$authenticatedUser instanceof User) {
  235.             return $this->redirectToRoute('ui_app_login');
  236.         }
  238.         $userId = $authenticatedUser->getId();
  239.         $user = $entityManager->getRepository(User::class)->find($userId);
  241.         if (!$user) {
  242.             throw $this->createNotFoundException('Utilisateur introuvable');
  243.         }
  245.         // Vérifier la limite de boutiques par utilisateur AVANT d'afficher le formulaire
  246.         $shopLimitCheck = $shopLimitService->canUserCreateShop($user);
  247.         if (!$shopLimitCheck['allowed']) {
  248.             // Afficher un message d'erreur visible au lieu de rediriger
  249.             $this->addFlash('error', $shopLimitCheck['message']);
  250.             
  251.             // Récupérer tous les plans pour le template (même si la limite est atteinte)
  252.             $shopPlans = $entityManager->getRepository(ShopPlan::class)->findAll();
  253.             $plansData = [];
  254.             foreach ($shopPlans as $plan) {
  255.                 $plansData[$plan->getId()] = [
  256.                     'id' => $plan->getId(),
  257.                     'name' => $plan->getName(),
  258.                     'requireSiretNif' => $plan->isRequireSiretNif(),
  259.                     'requireIban' => $plan->isRequireIban(),
  260.                     'maxProducts' => $plan->getMaxProducts(),
  261.                     'maxEmployees' => $plan->getMaxEmployees(),
  262.                 ];
  263.             }
  264.             
  265.             $shop = new Shop();
  266.             $form = $this->createForm(SellerShopType::class, $shop);
  267.             
  268.             return $this->render('seller/new_shop_simple.html.twig', [
  269.                 'current_menu' => 'shop',
  270.                 'current' => 'shopNew',
  271.                 'shop' => $shop,
  272.                 'form' => $form->createView(),
  273.                 'plansData' => $plansData,
  274.                 'shopLimitCheck' => $shopLimitCheck // Passer les infos de limite au template
  275.             ]);
  276.         }
  277.         
  278.         $shop = new Shop();
  279.         $form = $this->createForm(SellerShopType::class, $shop);
  280.         $form->handleRequest($request);
  282.         if ($form->isSubmitted() && $form->isValid()) {
  283.             // Vérifier à nouveau la limite lors de la soumission (au cas où elle aurait changé)
  284.             $shopLimitCheck = $shopLimitService->canUserCreateShop($user);
  285.             if (!$shopLimitCheck['allowed']) {
  286.                 $this->addFlash('error', $shopLimitCheck['message']);
  287.                 
  288.                 // Récupérer tous les plans pour les contraintes JavaScript
  289.                 $shopPlans = $entityManager->getRepository(ShopPlan::class)->findAll();
  290.                 $plansData = [];
  291.                 foreach ($shopPlans as $plan) {
  292.                     $plansData[$plan->getId()] = [
  293.                         'id' => $plan->getId(),
  294.                         'name' => $plan->getName(),
  295.                         'requireSiretNif' => $plan->isRequireSiretNif(),
  296.                         'requireIban' => $plan->isRequireIban(),
  297.                         'maxProducts' => $plan->getMaxProducts(),
  298.                         'maxEmployees' => $plan->getMaxEmployees(),
  299.                     ];
  300.                 }
  301.                 
  302.                 return $this->render('seller/new_shop_simple.html.twig', [
  303.                     'current_menu' => 'shop',
  304.                     'current' => 'shopNew',
  305.                     'shop' => $shop,
  306.                     'form' => $form->createView(),
  307.                     'plansData' => $plansData,
  308.                     'shopLimitCheck' => $shopLimitCheck
  309.                 ]);
  310.             }
  312.             // Configuration de base
  313.             $shop->setIsActive(true);
  314.             $shop->setCreatedAt(new \DateTimeImmutable('now'));
  315.             $shop->setCurrentEmployees(1);
  316.             
  317.             // Génération automatique du slug si nécessaire
  318.             if ($shop->getName()) {
  319.                 $slugger = new AsciiSlugger();
  320.                 $shop->setSlug(strtolower($slugger->slug($shop->getName())->toString()));
  321.             }
  322.             
  323.             // Initialisation des compteurs
  324.             $shop->setCurrentOrders(0);
  325.             $shop->setCurrentProducts(0);
  326.             $shop->setCurrentCaLimit(0);
  327.             $shop->setCurrentRevenue('0.000');
  328.             $shop->setCurrentStorage(0);
  329.             
  330.             // Initialisation des statistiques
  331.             $shop->setViewCount(0);
  332.             $shop->setFollowerCount(0);
  333.             $shop->setAverageRating(0.0);
  334.             $shop->setReviewCount(0);
  335.             
  336.             // Configuration des statuts par défaut
  337.             if (!$shop->getStatus()) {
  338.                 $shop->setStatus('pending');
  339.             }
  340.             if (!$shop->getVerificationStatus()) {
  341.                 $shop->setVerificationStatus('unverified');
  342.             }
  343.             
  344.             // Configuration des options par défaut (uniquement pour les champs modifiables par le vendeur)
  345.             if ($shop->isIsActive() === null) {
  346.                 $shop->setIsActive(true);
  347.             }
  348.             if ($shop->isAllowReviews() === null) {
  349.                 $shop->setAllowReviews(true);
  350.             }
  351.             if ($shop->isAllowMessages() === null) {
  352.                 $shop->setAllowMessages(true);
  353.             }
  354.             if ($shop->isShowContactInfo() === null) {
  355.                 $shop->setShowContactInfo(true);
  356.             }
  357.             if ($shop->isShowSocialLinks() === null) {
  358.                 $shop->setShowSocialLinks(true);
  359.             }
  360.             
  361.             // Champs gérés uniquement par l'administrateur (ne pas modifier)
  362.             // isVerified, isPremium, status, verificationStatus sont gérés par l'admin
  363.             if (!$shop->getStatus()) {
  364.                 $shop->setStatus('pending');
  365.             }
  366.             if (!$shop->getVerificationStatus()) {
  367.                 $shop->setVerificationStatus('unverified');
  368.             }
  369.             if ($shop->isIsVerified() === null) {
  370.                 $shop->setIsVerified(false);
  371.             }
  372.             if ($shop->isIsPremium() === null) {
  373.                 $shop->setIsPremium(false);
  374.             }
  375.             
  376.             // Gestion des fichiers uploadés
  377.             $logoFile = $form->get('logo')->getData();
  378.             if ($logoFile && $logoFile->isValid()) {
  379.                 $maxSize = 15 * 1024 * 1024; // 15MB
  380.                 if ($logoFile->getSize() > $maxSize) {
  381.                     $this->addFlash('error', 'Le logo est trop volumineux. Taille maximale : 15MB.');
  382.                 } else {
  383.                     $newFilename = uniqid().'.'.$logoFile->guessExtension();
  384.                     $logoFile->move(
  385.                         $this->getParameter('kernel.project_dir').'/public/uploads/shops/',
  386.                         $newFilename
  387.                     );
  388.                     $shop->setLogo('uploads/shops/'.$newFilename);
  389.                 }
  390.             }
  391.             
  392.             // Gestion des images de bannière (jusqu'à 7 images, 15MB max chacune)
  393.             $allBannerImages = $shop->getAllBannerImages();
  394.             
  395.             // Gestion des nouvelles images multiples de bannière
  396.             $bannerImagesFile = $form->get('bannerImages')->getData();
  397.             if ($bannerImagesFile) {
  398.                 $maxSize = 15 * 1024 * 1024; // 15MB
  399.                 foreach ($bannerImagesFile as $file) {
  400.                     if ($file && $file->isValid()) {
  401.                         // Vérifier la taille du fichier
  402.                         if ($file->getSize() > $maxSize) {
  403.                             $this->addFlash('error', 'Le fichier "' . $file->getClientOriginalName() . '" est trop volumineux. Taille maximale : 15MB.');
  404.                             continue;
  405.                         }
  406.                         
  407.                         $newFilename = uniqid().'.'.$file->guessExtension();
  408.                         $file->move(
  409.                             $this->getParameter('kernel.project_dir').'/public/uploads/shops/',
  410.                             $newFilename
  411.                         );
  412.                         $allBannerImages[] = 'uploads/shops/'.$newFilename;
  413.                     }
  414.                 }
  415.             }
  417.             // Dédupliquer et limiter à 7 images max
  418.             $allBannerImages = array_values(array_unique($allBannerImages));
  419.             if (count($allBannerImages) > 7) {
  420.                 $this->addFlash('error', 'Maximum 7 images de bannière autorisées. Les images supplémentaires ont été ignorées.');
  421.                 $allBannerImages = array_slice($allBannerImages, 0, 7);
  422.             }
  423.             $shop->setBannerImages($allBannerImages);
  424.             
  425.             // Contraintes basées sur le plan sélectionné
  426.             if ($shop->getPlan()) {
  427.                 $plan = $shop->getPlan();
  428.                 $errors = [];
  429.                 
  430.                 // Vérifier les champs requis par le plan
  431.                 if ($plan->isRequireSiretNif() && !$shop->getSiretNif()) {
  432.                     $errors[] = 'Votre plan exige un SIRET/NIF. Veuillez le renseigner.';
  433.                 }
  434.                 
  435.                 if ($plan->isRequireIban() && !$shop->getIban()) {
  436.                     $errors[] = 'Votre plan exige un IBAN. Veuillez le renseigner.';
  437.                 }
  438.                 
  439.                 // Si des erreurs, retourner au formulaire
  440.                 if (!empty($errors)) {
  441.                     foreach ($errors as $error) {
  442.                         $this->addFlash('error', $error);
  443.                     }
  444.                     return $this->render('seller/new_shop_simple.html.twig', [
  445.                         'current_menu' => 'shop',
  446.                         'current' => 'shopNew',
  447.                         'shop' => $shop,
  448.                         'form' => $form->createView()
  449.                     ]);
  450.                 }
  451.             }
  452.             
  453.             $shop->addManager($user);
  454.             $entityManager->persist($shop);
  455.             $entityManager->flush();
  457.             // Créer une notification de félicitations
  458.             $notificationService->createShopCreatedNotification($user, $shop);
  460.             // Envoyer un email de félicitations
  461.             try {
  462.                 $email = (new TemplatedEmail())
  463.                     ->from(new EmailAddress('no-reply@maketou-ht.com', 'MaketOu'))
  464.                     ->to(new EmailAddress($user->getEmail(), $user->getFirstname() . ' ' . $user->getLastname()))
  465.                     ->subject('Félicitations ! Votre boutique "' . $shop->getName() . '" a été créée')
  466.                     ->htmlTemplate('emails/shop_created.html.twig')
  467.                     ->context([
  468.                         'user' => $user,
  469.                         'shop' => $shop,
  470.                     ]);
  472.                 $mailer->send($email);
  473.             } catch (\Exception $e) {
  474.                 // Log l'erreur mais ne bloque pas la création de la boutique
  475.                 // On peut logger l'erreur ici si nécessaire
  476.             }
  478.             $this->addFlash('success', 'Boutique créée avec succès ! Vous avez reçu un email de confirmation.');
  479.             return $this->redirectToRoute('seller_index', [], Response::HTTP_SEE_OTHER);
  480.         }
  481.         // Récupérer tous les plans pour les contraintes JavaScript
  482.         $shopPlans = $entityManager->getRepository(ShopPlan::class)->findAll();
  483.         $plansData = [];
  484.         foreach ($shopPlans as $plan) {
  485.             $plansData[$plan->getId()] = [
  486.                 'id' => $plan->getId(),
  487.                 'name' => $plan->getName(),
  488.                 'requireSiretNif' => $plan->isRequireSiretNif(),
  489.                 'requireIban' => $plan->isRequireIban(),
  490.                 'maxProducts' => $plan->getMaxProducts(),
  491.                 'maxEmployees' => $plan->getMaxEmployees(),
  492.             ];
  493.         }
  494.         
  495.         return $this->render('seller/new_shop_simple.html.twig', [
  496.             'current_menu' => 'shop',
  497.             'current' => 'shopNew',
  498.             'shop' => $shop,
  499.             'form' => $form->createView(),
  500.             'plansData' => $plansData,
  501.             'shopLimitCheck' => $shopLimitCheck // Passer les infos de limite au template
  502.         ]);
  503.     }
  505.     #[Route('/shop/{slug}/show', name: 'shop_show')]
  506.     public function showShopSeller(string $slug, Request $request, EntityManagerInterface $em): Response
  507.     {
  508.         if (!$this->getUser()) {
  509.             return $this->redirectToRoute('ui_app_login');
  510.         }
  511.         if (!$this->isAuthorized()) {
  512.             return $this->render('misc/access_denied.html.twig');
  513.         }
  515.         // Récupérer la boutique
  516.         $shop = $em->getRepository(Shop::class)->findOneBy(['slug' => $slug]);
  517.         
  518.         if (!$shop) {
  519.             $this->addFlash('error', 'Boutique non trouvée. Le slug "' . $slug . '" ne correspond à aucune boutique.');
  520.             return $this->redirectToRoute('seller_index');
  521.         }
  523.         // Vérifier que la boutique appartient à l'utilisateur connecté
  524.         $canEdit = $shop->getManager()->contains($this->getUser());
  526.         // Calculer les statistiques dynamiques
  527.         $productsCount = $shop->getActiveProductsCount();
  528.         // Optimisation: Utiliser une requête COUNT au lieu de charger la collection
  529.         $totalProducts = $em->getRepository(Product::class)
  530.             ->createQueryBuilder('p')
  531.             ->select('COUNT(p.id)')
  532.             ->where('p.shop = :shop')
  533.             ->setParameter('shop', $shop)
  534.             ->getQuery()
  535.             ->getSingleScalarResult();
  536.         
  537.         // Optimisation: Utiliser des requêtes séparées optimisées au lieu de charger toutes les commandes
  538.         $recentOrders = [];
  539.         $ordersCount = 0;
  540.         $revenue = 0.0;
  541.         
  542.         try {
  543.             $orderRepo = $em->getRepository(\App\Entity\Order::class);
  544.             
  545.             // Compter les commandes avec une requête COUNT optimisée
  546.             $ordersCount = $orderRepo->createQueryBuilder('o')
  547.                 ->select('COUNT(DISTINCT o.id)')
  548.                 ->join('o.items', 'oi')
  549.                 ->join('oi.product', 'p')
  550.                 ->where('p.shop = :shop')
  551.                 ->setParameter('shop', $shop)
  552.                 ->getQuery()
  553.                 ->getSingleScalarResult();
  554.             
  555.             // Calculer le chiffre d'affaires directement avec SUM (évite de charger toutes les commandes)
  556.             $revenueResult = $em->createQueryBuilder()
  557.                 ->select('COALESCE(SUM(CAST(oi.totalPrice AS DECIMAL(10,2))), 0)')
  558.                 ->from(\App\Entity\OrderItem::class, 'oi')
  559.                 ->join('oi.product', 'p')
  560.                 ->join('oi.order', 'o')
  561.                 ->where('p.shop = :shop')
  562.                 ->andWhere('o.paymentStatus = :paid')
  563.                 ->setParameter('shop', $shop)
  564.                 ->setParameter('paid', 'paid')
  565.                 ->getQuery()
  566.                 ->getSingleScalarResult();
  567.             
  568.             $revenue = (float)$revenueResult;
  569.             
  570.             // Récupérer seulement les 10 commandes récentes avec eager loading
  571.             $recentOrders = $orderRepo->createQueryBuilder('o')
  572.                 ->select('DISTINCT o')
  573.                 ->leftJoin('o.items', 'oi')
  574.                 ->leftJoin('oi.product', 'p')
  575.                 ->leftJoin('o.customer', 'c')
  576.                 ->addSelect('oi', 'p', 'c') // Eager loading pour éviter N+1
  577.                 ->where('p.shop = :shop')
  578.                 ->setParameter('shop', $shop)
  579.                 ->orderBy('o.orderedAt', 'DESC')
  580.                 ->setMaxResults(10)
  581.                 ->getQuery()
  582.                 ->getResult();
  583.         } catch (\Exception $e) {
  584.             // Si l'entité Order n'existe pas encore ou erreur, on continue sans
  585.             $ordersCount = 0;
  586.             $revenue = 0.0;
  587.             $recentOrders = [];
  588.         }
  589.         
  590.         // Calculer le solde disponible (revenue - dépenses potentielles)
  591.         // Pour l'instant, on utilise le revenue comme solde disponible
  592.         $availableBalance = $revenue;
  593.         
  594.         // Calculer la date de dernière mise à jour (date de création ou dernière commande)
  595.         $lastUpdate = $shop->getCreatedAt();
  596.         if ($ordersCount > 0 && !empty($recentOrders)) {
  597.             // Utiliser la date de la commande la plus récente
  598.             $lastUpdate = $recentOrders[0]->getOrderedAt();
  599.         }
  600.         
  601.         // Calculer le temps depuis la dernière mise à jour
  602.         $updateText = 'Aujourd\'hui';
  603.         if ($lastUpdate) {
  604.             $now = new \DateTimeImmutable();
  605.             $diff = $now->diff($lastUpdate);
  606.             if ($diff->days > 0) {
  607.                 if ($diff->days == 1) {
  608.                     $updateText = 'Hier';
  609.                 } elseif ($diff->days < 7) {
  610.                     $updateText = 'Il y a ' . $diff->days . ' jours';
  611.                 } elseif ($diff->days < 30) {
  612.                     $weeks = floor($diff->days / 7);
  613.                     $updateText = 'Il y a ' . $weeks . ' semaine' . ($weeks > 1 ? 's' : '');
  614.                 } else {
  615.                     $months = floor($diff->days / 30);
  616.                     $updateText = 'Il y a ' . $months . ' mois';
  617.                 }
  618.             }
  619.         }
  621.         // Calculer les statistiques de vues par période (derniers 30 jours)
  622.         $viewsLast30Days = 0;
  623.         try {
  624.             // Pour l'instant, on utilise viewCount comme approximation
  625.             $viewsLast30Days = (int)($shop->getViewCount() * 0.3); // Approximation
  626.         } catch (\Exception $e) {
  627.             // Ignorer si erreur
  628.         }
  630.         // Récupérer les produits populaires (actifs uniquement, triés par ventes puis vues)
  631.         $popularProducts = [];
  632.         try {
  633.             $productRepo = $em->getRepository(\App\Entity\Product::class);
  634.             $popularProducts = $productRepo->createQueryBuilder('p')
  635.                 ->where('p.shop = :shop')
  636.                 ->andWhere('p.isActive = :isActive')
  637.                 ->setParameter('shop', $shop)
  638.                 ->setParameter('isActive', true)
  639.                 ->orderBy('p.salesCount', 'DESC')
  640.                 ->addOrderBy('p.viewCount', 'DESC')
  641.                 ->addOrderBy('p.publishedAt', 'DESC')
  642.                 ->setMaxResults(6)
  643.                 ->getQuery()
  644.                 ->getResult();
  645.         } catch (\Exception $e) {
  646.             // En cas d'erreur, utiliser les produits actifs de la boutique
  647.             $popularProducts = $shop->getProducts()->filter(function($product) {
  648.                 return $product->isIsActive();
  649.             })->toArray();
  650.             // Trier par ventes puis vues
  651.             usort($popularProducts, function($a, $b) {
  652.                 $salesDiff = ($b->getSalesCount() ?? 0) - ($a->getSalesCount() ?? 0);
  653.                 if ($salesDiff !== 0) return $salesDiff;
  654.                 return ($b->getViewCount() ?? 0) - ($a->getViewCount() ?? 0);
  655.             });
  656.             $popularProducts = array_slice($popularProducts, 0, 6);
  657.         }
  659.         return $this->render('seller/show_shop.html.twig', [
  660.             'current_menu' => 'shop',
  661.             'slugShop' => $shop->getSlug(),
  662.             'shop' => $shop,
  663.             'canEdit' => $canEdit,
  664.             'recentOrders' => $recentOrders,
  665.             'viewsLast30Days' => $viewsLast30Days,
  666.             'popularProducts' => $popularProducts,
  667.             'stats' => [
  668.                 'productsCount' => $productsCount,
  669.                 'totalProducts' => $totalProducts,
  670.                 'ordersCount' => $ordersCount,
  671.                 'revenue' => $revenue,
  672.                 'availableBalance' => $availableBalance,
  673.                 'lastUpdate' => $updateText
  674.             ]
  675.         ]);
  676.     }
  678.     #[Route('/shop/{slug}/edit', name: 'shop_edit')]
  679.     public function editShopSeller(string $slug, Request $request, EntityManagerInterface $entityManager): Response
  680.     {
  681.         if (!$this->getUser()) {
  682.             return $this->redirectToRoute('ui_app_login');
  683.         }
  684.         if (!$this->isAuthorized()) {
  685.             return $this->render('misc/access_denied.html.twig');
  686.         }
  688.         $shop = $entityManager->getRepository(Shop::class)->findOneBy(['slug' => $slug]);
  689.         
  690.         if (!$shop) {
  691.             $this->addFlash('error', 'Boutique non trouvée.');
  692.             return $this->redirectToRoute('seller_index');
  693.         }
  695.         // Vérifier que la boutique appartient à l'utilisateur connecté
  696.         if (!$shop->getManager()->contains($this->getUser())) {
  697.             $this->addFlash('error', 'Vous n\'avez pas la permission de modifier cette boutique.');
  698.             return $this->redirectToRoute('seller_shop_show', ['slug' => $shop->getSlug()]);
  699.         }
  701.         $form = $this->createForm(SellerShopType::class, $shop);
  702.         $form->handleRequest($request);
  704.         // Gérer les uploads AJAX partiels (images de bannière uniquement)
  705.         $isAjax = $request->isXmlHttpRequest() || $request->headers->get('X-Requested-With') === 'XMLHttpRequest';
  706.         $uploadedBannerImages = $request->files->all('bannerImages');
  707.         $isPartialUpload = $isAjax && !empty($uploadedBannerImages);
  709.         if ($isPartialUpload) {
  710.             // Upload AJAX partiel pour les images de bannière
  711.             $allBannerImages = $shop->getAllBannerImages();
  712.             $maxSize = 15 * 1024 * 1024; // 15MB
  713.             
  714.             foreach ($uploadedBannerImages as $file) {
  715.                 if ($file && $file->isValid()) {
  716.                     if ($file->getSize() > $maxSize) {
  717.                         return new JsonResponse([
  718.                             'success' => false,
  719.                             'message' => 'Le fichier "' . $file->getClientOriginalName() . '" est trop volumineux. Taille maximale : 15MB.'
  720.                         ], 400);
  721.                     }
  722.                     
  723.                     if (count($allBannerImages) >= 7) {
  724.                         return new JsonResponse([
  725.                             'success' => false,
  726.                             'message' => 'Maximum 7 images de bannière autorisées.'
  727.                         ], 400);
  728.                     }
  729.                     
  730.                     $newFilename = uniqid().'.'.$file->guessExtension();
  731.                     $file->move(
  732.                         $this->getParameter('kernel.project_dir').'/public/uploads/shops/',
  733.                         $newFilename
  734.                     );
  735.                     $allBannerImages[] = 'uploads/shops/'.$newFilename;
  736.                 }
  737.             }
  738.             
  739.             $allBannerImages = array_values(array_unique($allBannerImages));
  740.             $shop->setBannerImages($allBannerImages);
  741.             $entityManager->flush();
  742.             
  743.             return new JsonResponse([
  744.                 'success' => true,
  745.                 'message' => count($uploadedBannerImages) . ' image(s) ajoutée(s) avec succès',
  746.                 'data' => [
  747.                     'bannerImages' => $shop->getAllBannerImages()
  748.                 ]
  749.             ]);
  750.         }
  752.         if ($form->isSubmitted() && $form->isValid()) {
  753.             // Génération automatique du slug si le nom a changé
  754.             if ($shop->getName()) {
  755.                 $slugger = new AsciiSlugger();
  756.                 $newSlug = strtolower($slugger->slug($shop->getName())->toString());
  757.                 // Vérifier si le slug existe déjà pour une autre boutique
  758.                 $existingShop = $entityManager->getRepository(Shop::class)->findOneBy(['slug' => $newSlug]);
  759.                 if (!$existingShop || $existingShop->getId() === $shop->getId()) {
  760.                     $shop->setSlug($newSlug);
  761.                 }
  762.             }
  763.             
  764.             // Gestion des fichiers uploadés
  765.             $logoFile = $form->get('logo')->getData();
  766.             if ($logoFile && $logoFile->isValid()) {
  767.                 $maxSize = 15 * 1024 * 1024; // 15MB
  768.                 if ($logoFile->getSize() > $maxSize) {
  769.                     $this->addFlash('error', 'Le logo est trop volumineux. Taille maximale : 15MB.');
  770.                 } else {
  771.                     $newFilename = uniqid().'.'.$logoFile->guessExtension();
  772.                     $logoFile->move(
  773.                         $this->getParameter('kernel.project_dir').'/public/uploads/shops/',
  774.                         $newFilename
  775.                     );
  776.                     $shop->setLogo('uploads/shops/'.$newFilename);
  777.                 }
  778.             }
  779.             
  780.             // Gestion des images de bannière (jusqu'à 7 images, 15MB max chacune)
  781.             $allBannerImages = $shop->getAllBannerImages();
  782.             
  783.             // Gérer la suppression d'images existantes
  784.             $removeBannerImages = $request->request->all('removeBannerImages');
  785.             if ($removeBannerImages) {
  786.                 foreach ($removeBannerImages as $imageToRemove) {
  787.                     $allBannerImages = array_filter($allBannerImages, function($img) use ($imageToRemove) {
  788.                         return $img !== $imageToRemove;
  789.                     });
  790.                 }
  791.                 $allBannerImages = array_values($allBannerImages);
  792.             }
  793.             
  794.             // Gestion des nouvelles images multiples de bannière
  795.             $bannerImagesFile = $form->get('bannerImages')->getData();
  796.             if ($bannerImagesFile) {
  797.                 $maxSize = 15 * 1024 * 1024; // 15MB
  798.                 foreach ($bannerImagesFile as $file) {
  799.                     if ($file && $file->isValid()) {
  800.                         // Vérifier la taille du fichier
  801.                         if ($file->getSize() > $maxSize) {
  802.                             $this->addFlash('error', 'Le fichier "' . $file->getClientOriginalName() . '" est trop volumineux. Taille maximale : 15MB.');
  803.                             continue;
  804.                         }
  805.                         
  806.                         $newFilename = uniqid().'.'.$file->guessExtension();
  807.                         $file->move(
  808.                             $this->getParameter('kernel.project_dir').'/public/uploads/shops/',
  809.                             $newFilename
  810.                         );
  811.                         $allBannerImages[] = 'uploads/shops/'.$newFilename;
  812.                     }
  813.                 }
  814.             }
  816.             // Dédupliquer et limiter à 7 images max
  817.             $allBannerImages = array_values(array_unique($allBannerImages));
  818.             if (count($allBannerImages) > 7) {
  819.                 $this->addFlash('error', 'Maximum 7 images de bannière autorisées. Les images supplémentaires ont été ignorées.');
  820.                 $allBannerImages = array_slice($allBannerImages, 0, 7);
  821.             }
  822.             $shop->setBannerImages($allBannerImages);
  823.             
  824.             // Contraintes basées sur le plan sélectionné
  825.             if ($shop->getPlan()) {
  826.                 $plan = $shop->getPlan();
  827.                 $errors = [];
  828.                 
  829.                 // Vérifier les champs requis par le plan
  830.                 if ($plan->isRequireSiretNif() && !$shop->getSiretNif()) {
  831.                     $errors[] = 'Votre plan exige un SIRET/NIF. Veuillez le renseigner.';
  832.                 }
  833.                 
  834.                 if ($plan->isRequireIban() && !$shop->getIban()) {
  835.                     $errors[] = 'Votre plan exige un IBAN. Veuillez le renseigner.';
  836.                 }
  837.                 
  838.                 // Si des erreurs, retourner au formulaire
  839.                 if (!empty($errors)) {
  840.                     foreach ($errors as $error) {
  841.                         $this->addFlash('error', $error);
  842.                     }
  843.                     // Récupérer tous les plans pour les contraintes JavaScript
  844.                     $shopPlans = $entityManager->getRepository(ShopPlan::class)->findAll();
  845.                     $plansData = [];
  846.                     foreach ($shopPlans as $planItem) {
  847.                         $plansData[$planItem->getId()] = [
  848.                             'id' => $planItem->getId(),
  849.                             'name' => $planItem->getName(),
  850.                             'requireSiretNif' => $planItem->isRequireSiretNif(),
  851.                             'requireIban' => $planItem->isRequireIban(),
  852.                             'maxProducts' => $planItem->getMaxProducts(),
  853.                             'maxEmployees' => $planItem->getMaxEmployees(),
  854.                         ];
  855.                     }
  856.                     return $this->render('seller/new_shop_simple.html.twig', [
  857.                         'current_menu' => 'shop',
  858.                         'current' => 'shopEdit',
  859.                         'shop' => $shop,
  860.                         'form' => $form->createView(),
  861.                         'plansData' => $plansData
  862.                     ]);
  863.                 }
  864.             }
  865.             
  866.             $entityManager->flush();
  868.             $this->addFlash('success', 'Boutique modifiée avec succès !');
  869.             return $this->redirectToRoute('seller_shop_show', ['slug' => $shop->getSlug()], Response::HTTP_SEE_OTHER);
  870.         }
  872.         // Récupérer tous les plans pour les contraintes JavaScript
  873.         $shopPlans = $entityManager->getRepository(ShopPlan::class)->findAll();
  874.         $plansData = [];
  875.         foreach ($shopPlans as $plan) {
  876.             $plansData[$plan->getId()] = [
  877.                 'id' => $plan->getId(),
  878.                 'name' => $plan->getName(),
  879.                 'requireSiretNif' => $plan->isRequireSiretNif(),
  880.                 'requireIban' => $plan->isRequireIban(),
  881.                 'maxProducts' => $plan->getMaxProducts(),
  882.                 'maxEmployees' => $plan->getMaxEmployees(),
  883.             ];
  884.         }
  885.         
  886.         return $this->render('seller/new_shop_simple.html.twig', [
  887.             'current_menu' => 'shop',
  888.             'current' => 'shopEdit',
  889.             'shop' => $shop,
  890.             'form' => $form->createView(),
  891.             'plansData' => $plansData
  892.         ]);
  893.     }
  895.     #[Route('/shop/{slug}/show/products', name: 'shop_show_products')]
  896.     public function showProductsSeller(string $slug, Request $request, EntityManagerInterface $em): Response
  897.     {
  898.         if (!$this->getUser()) {
  899.             return $this->redirectToRoute('ui_app_login');
  900.         }
  901.         if (!$this->isAuthorized()) {
  902.             return $this->render('misc/access_denied.html.twig');
  903.         }
  904.         
  905.         $shop = $em->getRepository(Shop::class)->findOneBy(['slug' => $slug]);
  906.         
  907.         if (!$shop) {
  908.             $this->addFlash('error', 'Boutique non trouvée.');
  909.             return $this->redirectToRoute('seller_index');
  910.         }
  911.         
  912.         // Filtrer uniquement les produits actifs pour le vendeur
  913.         $products = $shop->getProducts()->filter(function($product) {
  914.             return $product->isIsActive();
  915.         });
  916.         $categories = $em->getRepository(Category::class)->findAll();
  918.         $data = [];
  919.         foreach ($products as $product) {
  920.             $tierPrices = $product->getTierPrices();
  921.             $hasTierPricing = $product->hasTierPricing() || ($tierPrices && count($tierPrices) > 0);
  922.             
  923.             $data[] = [
  924.                 'id' => $product->getId(),
  925.                 'slug' => $product->getSlug(),
  926.                 'image' => $product->getImages()[0] ?? null,
  927.                 'name' => $product->getName(),
  928.                 'price' => $product->getPrice(),
  929.                 'stock' => $product->getStock(),
  930.                 'status' => $product->getStockStatus(),
  931.                 'hasTierPricing' => $hasTierPricing,
  932.                 'isActive' => $product->isIsActive(),
  933.             ];
  934.         }
  936.         return $this->render('seller/show_products.html.twig', [
  937.             'current_menu' => 'shop',
  938.             'current' => 'products',
  939.             'productsJson' => json_encode($data),
  940.             'categoriesJson' => json_encode(array_map(static function(Category $c){
  941.                 return ['id' => $c->getId(), 'name' => $c->getName()];
  942.             }, $categories)),
  943.             'slugShop' => $shop->getSlug(),
  944.             'shop' => $shop
  945.         ]);
  946.     }
  948.     #[Route('/shop/{slug}/products/new', name: 'shop_products_new', methods: ['GET', 'POST'])]
  949.     public function createProductForShop(string $slug, Request $request, EntityManagerInterface $em, ShopLimitService $shopLimitService): Response
  950.     {
  951.         if (!$this->getUser() || !$this->isAuthorized()) {
  952.             if ($request->isMethod('GET')) {
  953.                 return $this->redirectToRoute('ui_app_login');
  954.             }
  955.             return new JsonResponse(['ok' => false, 'message' => 'Non autorisé'], 401);
  956.         }
  958.         $shop = $em->getRepository(Shop::class)->findOneBy(['slug' => $slug]);
  959.         
  960.         if (!$shop) {
  961.             if ($request->isMethod('GET')) {
  962.                 $this->addFlash('error', 'Boutique non trouvée.');
  963.                 return $this->redirectToRoute('seller_index');
  964.             }
  965.             return new JsonResponse(['ok' => false, 'message' => 'Boutique non trouvée'], 404);
  966.         }
  968.         // Vérifier que la boutique appartient au vendeur
  969.         if (!$shop->getManager()->contains($this->getUser())) {
  970.             if ($request->isMethod('GET')) {
  971.                 $this->addFlash('error', 'Vous n\'avez pas accès à cette boutique.');
  972.                 return $this->redirectToRoute('seller_index');
  973.             }
  974.             return new JsonResponse(['ok' => false, 'message' => 'Vous n\'avez pas accès à cette boutique.'], 403);
  975.         }
  977.         // Si GET, afficher le formulaire de création
  978.         if ($request->isMethod('GET')) {
  979.             // Vérifier les limites du plan avant d'afficher le formulaire
  980.             $productLimitCheck = $shopLimitService->canShopAddProduct($shop);
  981.             $categories = $em->getRepository(Category::class)->findAll();
  982.             
  983.             // Récupérer les attributs disponibles pour les variantes
  984.             $attributes = $em->getRepository(\App\Entity\ProductAttribute::class)->findActiveOrdered();
  985.             $attributesData = [];
  986.             foreach ($attributes as $attr) {
  987.                 $values = [];
  988.                 foreach ($attr->getValues() as $value) {
  989.                     if ($value->isIsActive()) {
  990.                         $values[] = [
  991.                             'id' => $value->getId(),
  992.                             'value' => $value->getValue(),
  993.                             'colorCode' => $value->getColorCode(),
  994.                             'image' => $value->getImage(),
  995.                         ];
  996.                     }
  997.                 }
  998.                 $attributesData[] = [
  999.                     'id' => $attr->getId(),
  1000.                     'name' => $attr->getName(),
  1001.                     'slug' => $attr->getSlug(),
  1002.                     'type' => $attr->getType(),
  1003.                     'values' => $values,
  1004.                 ];
  1005.             }
  1006.             
  1007.             return $this->render('seller/product/new.html.twig', [
  1008.                 'shop' => $shop,
  1009.                 'categories' => $categories,
  1010.                 'productLimitCheck' => $productLimitCheck,
  1011.                 'attributes' => $attributesData,
  1012.             ]);
  1013.         }
  1015.         // Si POST, vérifier les limites avant de créer le produit
  1016.         $productLimitCheck = $shopLimitService->canShopAddProduct($shop);
  1017.         if (!$productLimitCheck['allowed']) {
  1018.             $isAjax = $request->isXmlHttpRequest() || $request->headers->get('X-Requested-With') === 'XMLHttpRequest';
  1019.             if ($isAjax) {
  1020.                 return new JsonResponse(['ok' => false, 'message' => $productLimitCheck['message']], 403);
  1021.             }
  1022.             $this->addFlash('error', $productLimitCheck['message']);
  1023.             $categories = $em->getRepository(Category::class)->findAll();
  1024.             return $this->render('seller/product/new.html.twig', [
  1025.                 'shop' => $shop,
  1026.                 'categories' => $categories,
  1027.                 'productLimitCheck' => $productLimitCheck,
  1028.             ]);
  1029.         }
  1031.         // Si POST, créer le produit
  1032.         $product = new Product();
  1034.         $name = trim((string) $request->request->get('name'));
  1035.         $description = (string) $request->request->get('description');
  1036.         $price = (float) $request->request->get('price');
  1037.         $compareAtPrice = $request->request->get('compareAtPrice') !== null ? (float) $request->request->get('compareAtPrice') : null;
  1038.         $stock = (int) $request->request->get('stock');
  1039.         $minStockAlert = $request->request->get('minStockAlert') !== null ? (int) $request->request->get('minStockAlert') : 0;
  1040.         $manageStock = (bool) $request->request->get('manageStock');
  1041.         $allowBackorders = (bool) $request->request->get('allowBackorders');
  1042.         $isFeatured = (bool) $request->request->get('isFeatured');
  1043.         $isDigital = (bool) $request->request->get('isDigital');
  1044.         $stockStatus = (string) $request->request->get('stockStatus');
  1045.         $categoryId = (int) $request->request->get('category');
  1047.         // Définir $isAjax pour les validations
  1048.         $isAjax = $request->isXmlHttpRequest() || $request->headers->get('X-Requested-With') === 'XMLHttpRequest';
  1050.         if ($name === '' || $price <= 0 || $stock < 0 || !$categoryId) {
  1051.             if ($isAjax) {
  1052.                 return new JsonResponse(['ok' => false, 'message' => 'Champs requis manquants'], 400);
  1053.             }
  1054.             $this->addFlash('error', 'Champs requis manquants ou invalides.');
  1055.             return $this->redirectToRoute('seller_shop_products_new', ['slug' => $shop->getSlug()]);
  1056.         }
  1058.         $category = $em->getRepository(Category::class)->find($categoryId);
  1059.         if (!$category) {
  1060.             if ($isAjax) {
  1061.                 return new JsonResponse(['ok' => false, 'message' => 'Catégorie invalide'], 400);
  1062.             }
  1063.             $this->addFlash('error', 'Catégorie invalide.');
  1064.             return $this->redirectToRoute('seller_shop_products_new', ['slug' => $shop->getSlug()]);
  1065.         }
  1067.         $slugger = new AsciiSlugger();
  1068.         $slug = strtolower($slugger->slug($name)->toString());
  1069.         $sku = 'SKU-' . strtoupper(substr(md5($name.microtime()), 0, 8));
  1071.         $product->setName($name);
  1072.         $product->setDescription($description ?: null);
  1073.         $product->setPrice($price);
  1074.         $product->setCompareAtPrice($compareAtPrice);
  1075.         $product->setStock($stock);
  1076.         $product->setMinStockAlert($minStockAlert);
  1077.         $product->setManageStock($manageStock);
  1078.         $product->setAllowBackorders($allowBackorders);
  1079.         $product->setIsFeatured($isFeatured);
  1080.         $product->setIsDigital($isDigital);
  1081.         $product->setStockStatus($stockStatus ?: 'In stock');
  1082.         $product->setCategory($category);
  1083.         $product->setShop($shop);
  1084.         $product->setSlug($slug);
  1085.         $product->setSku($sku);
  1086.         $product->setIsActive(true);
  1087.         $product->setPublishedAt(new \DateTimeImmutable('now'));
  1088.         $product->setViewCount(0);
  1089.         $product->setSalesCount(0);
  1090.         $product->setAverageRating(0);
  1091.         $product->setReviewCount(0);
  1093.         // Prix de gros (facultatif, à l'initiative du vendeur)
  1094.         $enableTierPricing = (bool) $request->request->get('enableTierPricing');
  1095.         $tierMins = $request->request->all('tierMin');
  1096.         $tierPrices = $request->request->all('tierPrice');
  1097.         $normalizedTiers = [];
  1098.         if ($enableTierPricing && is_array($tierMins) && is_array($tierPrices)) {
  1099.             $count = min(count($tierMins), count($tierPrices));
  1100.             for ($i = 0; $i < $count; $i++) {
  1101.                 $m = (int) ($tierMins[$i] ?? 0);
  1102.                 $p = (float) ($tierPrices[$i] ?? 0);
  1103.                 if ($m >= 1 && $p > 0) {
  1104.                     $normalizedTiers[$m] = $p; // utiliser la quantité min comme clé pour dédupliquer
  1105.                 }
  1106.             }
  1107.             if (!empty($normalizedTiers)) {
  1108.                 ksort($normalizedTiers, SORT_NUMERIC);
  1109.                 $tiersArray = [];
  1110.                 foreach ($normalizedTiers as $minQty => $priceVal) {
  1111.                     $tiersArray[] = [ 'min' => (int)$minQty, 'price' => (float)$priceVal ];
  1112.                 }
  1113.                 $product->setHasTierPricing(true);
  1114.                 $product->setTierPrices($tiersArray);
  1115.             } else {
  1116.                 $product->setHasTierPricing(false);
  1117.                 $product->setTierPrices(null);
  1118.             }
  1119.         } else {
  1120.             $product->setHasTierPricing(false);
  1121.             $product->setTierPrices(null);
  1122.         }
  1124.         // Définir $isAjax pour les blocs catch
  1125.         $isAjax = $request->isXmlHttpRequest() || $request->headers->get('X-Requested-With') === 'XMLHttpRequest';
  1127.         // Uploads
  1128.         try {
  1129.             $projectDir = $this->getParameter('kernel.project_dir');
  1130.             $baseUploadDir = $projectDir . '/public/uploads/products/' . $shop->getSlug();
  1131.             $imagesDir = $baseUploadDir . '/images';
  1132.             $videosDir = $baseUploadDir . '/videos';
  1133.             $documentsDir = $baseUploadDir . '/documents';
  1135.             foreach ([$imagesDir, $videosDir, $documentsDir] as $dir) {
  1136.                 if (!is_dir($dir) && !@mkdir($dir, 0777, true) && !is_dir($dir)) {
  1137.                     throw new \RuntimeException('Impossible de créer le dossier: ' . $dir);
  1138.                 }
  1139.             }
  1141.             $sluggerFile = new AsciiSlugger();
  1143.             $images = [];
  1144.             $filesImages = $request->files->get('images', []);
  1145.             if ($filesImages instanceof \Symfony\Component\HttpFoundation\File\UploadedFile) {
  1146.                 $filesImages = [$filesImages];
  1147.             }
  1148.             foreach ($filesImages as $file) {
  1149.                 if (!$file || !($file instanceof \Symfony\Component\HttpFoundation\File\UploadedFile) || !$file->isValid()) continue;
  1150.                 $ext = $file->guessExtension() ?: $file->getClientOriginalExtension() ?: 'bin';
  1151.                 $orig = pathinfo((string)$file->getClientOriginalName(), PATHINFO_FILENAME);
  1152.                 $safeOrig = strtolower($sluggerFile->slug($orig)->toString());
  1153.                 $unique = bin2hex(random_bytes(8)) . '_' . str_replace('.', '', (string) microtime(true));
  1154.                 $filename = $safeOrig . '_' . $unique . '.' . $ext;
  1155.                 $file->move($imagesDir, $filename);
  1156.                 $images[] = '/uploads/products/' . $shop->getSlug() . '/images/' . $filename;
  1157.             }
  1158.             $videos = [];
  1159.             $filesVideos = $request->files->get('videos', []);
  1160.             if ($filesVideos instanceof \Symfony\Component\HttpFoundation\File\UploadedFile) {
  1161.                 $filesVideos = [$filesVideos];
  1162.             }
  1163.             foreach ($filesVideos as $file) {
  1164.                 if (!$file || !($file instanceof \Symfony\Component\HttpFoundation\File\UploadedFile) || !$file->isValid()) continue;
  1165.                 $ext = $file->guessExtension() ?: $file->getClientOriginalExtension() ?: 'bin';
  1166.                 $orig = pathinfo((string)$file->getClientOriginalName(), PATHINFO_FILENAME);
  1167.                 $safeOrig = strtolower($sluggerFile->slug($orig)->toString());
  1168.                 $unique = bin2hex(random_bytes(8)) . '_' . str_replace('.', '', (string) microtime(true));
  1169.                 $filename = $safeOrig . '_' . $unique . '.' . $ext;
  1170.                 $file->move($videosDir, $filename);
  1171.                 $videos[] = '/uploads/products/' . $shop->getSlug() . '/videos/' . $filename;
  1172.             }
  1173.             $documents = [];
  1174.             $filesDocuments = $request->files->get('documents', []);
  1175.             if ($filesDocuments instanceof \Symfony\Component\HttpFoundation\File\UploadedFile) {
  1176.                 $filesDocuments = [$filesDocuments];
  1177.             }
  1178.             foreach ($filesDocuments as $file) {
  1179.                 if (!$file || !($file instanceof \Symfony\Component\HttpFoundation\File\UploadedFile) || !$file->isValid()) continue;
  1180.                 $ext = $file->guessExtension() ?: $file->getClientOriginalExtension() ?: 'bin';
  1181.                 $orig = pathinfo((string)$file->getClientOriginalName(), PATHINFO_FILENAME);
  1182.                 $safeOrig = strtolower($sluggerFile->slug($orig)->toString());
  1183.                 $unique = bin2hex(random_bytes(8)) . '_' . str_replace('.', '', (string) microtime(true));
  1184.                 $filename = $safeOrig . '_' . $unique . '.' . $ext;
  1185.                 $file->move($documentsDir, $filename);
  1186.                 $documents[] = '/uploads/products/' . $shop->getSlug() . '/documents/' . $filename;
  1187.             }
  1188.         } catch (\Throwable $e) {
  1189.             if ($isAjax) {
  1190.                 return new JsonResponse(['ok' => false, 'message' => 'Upload échoué: '.$e->getMessage()], 500);
  1191.             }
  1192.             $this->addFlash('error', 'Erreur lors de l\'upload des fichiers: '.$e->getMessage());
  1193.             return $this->redirectToRoute('seller_shop_products_new', ['slug' => $shop->getSlug()]);
  1194.         }
  1196.         $product->setImages($images);
  1197.         $product->setVideos($videos ?: null);
  1198.         $product->setDocuments($documents ?: null);
  1200.         // Gérer les variantes de produit
  1201.         $variantsData = $request->request->all('variants') ?? [];
  1202.         $variantsFiles = $request->files->all('variants') ?? [];
  1203.         $attributeValueRepo = $em->getRepository(\App\Entity\ProductAttributeValue::class);
  1204.         
  1205.         foreach ($variantsData as $variantIndex => $variantData) {
  1206.             if (empty($variantData['price']) || empty($variantData['stock'])) {
  1207.                 continue; // Ignorer les variantes incomplètes
  1208.             }
  1209.             
  1210.             $variant = new \App\Entity\ProductVariant();
  1211.             $variant->setProduct($product);
  1212.             // Générer automatiquement le SKU si non fourni
  1213.             if (empty($variantData['sku'])) {
  1214.                 $variantSku = 'SKU-' . strtoupper(substr(md5($name . microtime() . $variantIndex), 0, 8)) . '-' . uniqid();
  1215.                 $variant->setSku($variantSku);
  1216.             } else {
  1217.                 $variant->setSku($variantData['sku']);
  1218.             }
  1219.             $variant->setPrice((float) $variantData['price']);
  1220.             $variant->setStock((int) $variantData['stock']);
  1221.             $variant->setCompareAtPrice(!empty($variantData['compareAtPrice']) ? (float) $variantData['compareAtPrice'] : null);
  1222.             $variant->setManageStock($manageStock);
  1223.             $variant->setAllowBackorders($allowBackorders);
  1224.             $variant->setStockStatus($stockStatus ?: 'in_stock');
  1225.             $variant->setIsActive(true);
  1226.             $variant->setIsDefault(false);
  1227.             
  1228.             // Gérer les attributs de la variante
  1229.             if (!empty($variantData['attributes']) && is_array($variantData['attributes'])) {
  1230.                 foreach ($variantData['attributes'] as $attrData) {
  1231.                     if (!empty($attrData['valueId'])) {
  1232.                         $attrValue = $attributeValueRepo->find((int) $attrData['valueId']);
  1233.                         if ($attrValue && $attrValue->isIsActive()) {
  1234.                             $variant->addAttributeValue($attrValue);
  1235.                         }
  1236.                     }
  1237.                 }
  1238.             }
  1239.             
  1240.             // Gérer les images spécifiques à la variante
  1241.             $variantImages = [];
  1242.             if (isset($variantsFiles[$variantIndex]['images']) && is_array($variantsFiles[$variantIndex]['images'])) {
  1243.                 foreach ($variantsFiles[$variantIndex]['images'] as $file) {
  1244.                     if ($file && $file instanceof \Symfony\Component\HttpFoundation\File\UploadedFile && $file->isValid()) {
  1245.                         $ext = $file->guessExtension() ?: $file->getClientOriginalExtension() ?: 'bin';
  1246.                         $orig = pathinfo((string)$file->getClientOriginalName(), PATHINFO_FILENAME);
  1247.                         $safeOrig = strtolower($sluggerFile->slug($orig)->toString());
  1248.                         $unique = bin2hex(random_bytes(8)) . '_' . str_replace('.', '', (string) microtime(true));
  1249.                         $filename = $safeOrig . '_' . $unique . '.' . $ext;
  1250.                         $file->move($imagesDir, $filename);
  1251.                         $variantImages[] = '/uploads/products/' . $shop->getSlug() . '/images/' . $filename;
  1252.                     }
  1253.                 }
  1254.             }
  1255.             $variant->setImages($variantImages);
  1256.             
  1257.             $em->persist($variant);
  1258.         }
  1259.         
  1260.         // Gérer les détails supplémentaires
  1261.         $detailsData = $request->request->all('details') ?? [];
  1262.         foreach ($detailsData as $detailData) {
  1263.             if (empty($detailData['label']) || empty($detailData['value'])) {
  1264.                 continue; // Ignorer les détails incomplets
  1265.             }
  1266.             
  1267.             $detail = new \App\Entity\ProductDetail();
  1268.             $detail->setProduct($product);
  1269.             $detail->setLabel(trim($detailData['label']));
  1270.             $detail->setValue(trim($detailData['value']));
  1271.             $detail->setIsActive(true);
  1272.             $detail->setSortOrder(0);
  1273.             
  1274.             $em->persist($detail);
  1275.         }
  1277.         try {
  1278.             // Incrémente le compteur de produits de la catégorie sélectionnée
  1279.             if ($category) {
  1280.                 $category->incrementProductCount();
  1281.                 $em->persist($category);
  1282.             }
  1283.             $em->persist($product);
  1284.             $em->flush();
  1285.             
  1286.             // Mettre à jour le compteur de produits de la boutique
  1287.             $shopLimitService->updateProductCount($shop);
  1288.         } catch (\Throwable $e) {
  1289.             if ($isAjax) {
  1290.                 return new JsonResponse(['ok' => false, 'message' => 'Erreur enregistrement: '.$e->getMessage()], 500);
  1291.             }
  1292.             $this->addFlash('error', 'Erreur lors de l\'enregistrement: '.$e->getMessage());
  1293.             return $this->redirectToRoute('seller_shop_products_new', ['slug' => $shop->getSlug()]);
  1294.         }
  1296.         // Rediriger vers la page d'édition du produit créé
  1297.         if ($isAjax) {
  1298.             return new JsonResponse([
  1299.                 'ok' => true,
  1300.                 'redirect' => $this->generateUrl('seller_product_edit', ['shopSlug' => $shop->getSlug(), 'id' => $product->getId()]),
  1301.                 'product' => [
  1302.                     'id' => $product->getId(),
  1303.                     'image' => $images[0] ?? null,
  1304.                     'name' => $product->getName(),
  1305.                     'price' => $product->getPrice(),
  1306.                     'stock' => $product->getStock(),
  1307.                     'status' => $product->getStockStatus(),
  1308.                     'hasTierPricing' => $product->hasTierPricing(),
  1309.                 ]
  1310.             ]);
  1311.         }
  1312.         
  1313.         $this->addFlash('success', 'Produit créé avec succès !');
  1314.         return $this->redirectToRoute('seller_shop_show', ['slug' => $shop->getSlug()]);
  1315.     }
  1317.     #[Route('/shop/{shopSlug}/products/{id}/show', name: 'product_show')]
  1318.     // Note: Le préfixe 'seller_' fait que la route finale est 'seller_product_show'
  1319.     public function showProductSeller(string $shopSlug, int $id, EntityManagerInterface $em): Response
  1320.     {
  1321.         if (!$this->getUser() || !$this->isAuthorized()) {
  1322.             return $this->redirectToRoute('ui_app_login');
  1323.         }
  1325.         $shop = $em->getRepository(Shop::class)->findOneBy(['slug' => $shopSlug]);
  1326.         
  1327.         if (!$shop) {
  1328.             $this->addFlash('error', 'Boutique non trouvée.');
  1329.             return $this->redirectToRoute('seller_index');
  1330.         }
  1332.         // Vérifier que la boutique appartient au vendeur
  1333.         if (!$shop->getManager()->contains($this->getUser())) {
  1334.             $this->addFlash('error', 'Vous n\'avez pas accès à cette boutique.');
  1335.             return $this->redirectToRoute('seller_index');
  1336.         }
  1338.         $product = $em->getRepository(Product::class)->find($id);
  1339.         
  1340.         if (!$product || $product->getShop()->getId() !== $shop->getId()) {
  1341.             throw $this->createNotFoundException('Produit non trouvé');
  1342.         }
  1344.         // Rendre le template seller pour voir le produit
  1345.         return $this->render('seller/product/show.html.twig', [
  1346.             'product' => $product,
  1347.             'shop' => $shop,
  1348.         ]);
  1349.     }
  1351.     #[Route('/shop/{shopSlug}/products/{id}/edit', name: 'product_edit', methods: ['GET', 'POST'])]
  1352.     // Note: Le préfixe 'seller_' fait que la route finale est 'seller_product_edit'
  1353.     public function editProductSeller(string $shopSlug, int $id, Request $request, EntityManagerInterface $em): Response
  1354.     {
  1355.         if (!$this->getUser() || !$this->isAuthorized()) {
  1356.             return $this->redirectToRoute('ui_app_login');
  1357.         }
  1359.         $shop = $em->getRepository(Shop::class)->findOneBy(['slug' => $shopSlug]);
  1360.         
  1361.         if (!$shop) {
  1362.             $this->addFlash('error', 'Boutique non trouvée.');
  1363.             return $this->redirectToRoute('seller_index');
  1364.         }
  1366.         // Vérifier que la boutique appartient au vendeur
  1367.         if (!$shop->getManager()->contains($this->getUser())) {
  1368.             $this->addFlash('error', 'Vous n\'avez pas accès à cette boutique.');
  1369.             return $this->redirectToRoute('seller_index');
  1370.         }
  1372.         $product = $em->getRepository(Product::class)->find($id);
  1373.         
  1374.         if (!$product || $product->getShop()->getId() !== $shop->getId()) {
  1375.             throw $this->createNotFoundException('Produit non trouvé');
  1376.         }
  1378.         // Traitement de la soumission du formulaire (POST)
  1379.         if ($request->isMethod('POST')) {
  1380.             $isAjax = $request->isXmlHttpRequest() || $request->headers->get('X-Requested-With') === 'XMLHttpRequest';
  1381.             
  1382.             $name = trim((string) $request->request->get('name'));
  1383.             $description = (string) $request->request->get('description');
  1384.             $price = (float) $request->request->get('price');
  1385.             $compareAtPrice = $request->request->get('compareAtPrice') !== null && $request->request->get('compareAtPrice') !== '' ? (float) $request->request->get('compareAtPrice') : null;
  1386.             $stock = (int) $request->request->get('stock');
  1387.             $minStockAlert = $request->request->get('minStockAlert') !== null ? (int) $request->request->get('minStockAlert') : 0;
  1388.             // Valeurs par défaut gérées en backend
  1389.             $manageStock = true; // Gérer le stock par défaut
  1390.             $allowBackorders = false; // Pas de précommandes par défaut
  1391.             $isFeatured = false; // Pas en vedette par défaut
  1392.             $stockStatus = 'In stock'; // En stock par défaut
  1393.             $isDigital = (bool) $request->request->get('isDigital');
  1394.             $categoryId = (int) $request->request->get('category');
  1395.             $isActive = (bool) $request->request->get('isActive');
  1397.             // Si c'est un upload partiel via AJAX, on peut ignorer la validation des champs de base
  1398.             // à condition que des fichiers soient présents
  1399.             $uploadedImages = $request->files->all('images');
  1400.             $uploadedVideos = $request->files->all('videos');
  1401.             $uploadedDocuments = $request->files->all('documents');
  1402.             $isPartialUpload = $isAjax && (!empty($uploadedImages) || !empty($uploadedVideos) || !empty($uploadedDocuments));
  1404.             if (!$isPartialUpload) {
  1405.             if ($name === '' || $price <= 0 || $stock < 0 || !$categoryId) {
  1406.                     if ($isAjax) {
  1407.                         return new JsonResponse(['success' => false, 'message' => 'Champs requis manquants ou invalides.'], 400);
  1408.                     }
  1409.                 $this->addFlash('error', 'Champs requis manquants ou invalides.');
  1410.                 return $this->redirectToRoute('seller_product_edit', ['shopSlug' => $shop->getSlug(), 'id' => $product->getId()]);
  1411.             }
  1413.             $category = $em->getRepository(Category::class)->find($categoryId);
  1414.             if (!$category) {
  1415.                     if ($isAjax) {
  1416.                         return new JsonResponse(['success' => false, 'message' => 'Catégorie invalide.'], 400);
  1417.                     }
  1418.                 $this->addFlash('error', 'Catégorie invalide.');
  1419.                 return $this->redirectToRoute('seller_product_edit', ['shopSlug' => $shop->getSlug(), 'id' => $product->getId()]);
  1420.             }
  1422.             // Mettre à jour le slug si le nom a changé
  1423.             if ($product->getName() !== $name) {
  1424.                 $slugger = new AsciiSlugger();
  1425.                 $slug = strtolower($slugger->slug($name)->toString());
  1426.                 $product->setSlug($slug);
  1427.             }
  1429.             $product->setName($name);
  1430.             $product->setDescription($description ?: null);
  1431.             $product->setPrice($price);
  1432.             $product->setCompareAtPrice($compareAtPrice);
  1433.             $product->setStock($stock);
  1434.             $product->setMinStockAlert($minStockAlert);
  1435.             $product->setManageStock($manageStock);
  1436.             $product->setAllowBackorders($allowBackorders);
  1437.             $product->setIsFeatured($isFeatured);
  1438.             $product->setIsDigital($isDigital);
  1439.             $product->setStockStatus($stockStatus ?: 'In stock');
  1440.             $product->setCategory($category);
  1441.             $product->setIsActive($isActive);
  1443.             // Prix de gros (Tier Pricing)
  1444.             $enableTierPricing = (bool) $request->request->get('enableTierPricing');
  1445.             $tierMins = $request->request->all('tierMin');
  1446.             $tierPrices = $request->request->all('tierPrice');
  1447.             $normalizedTiers = [];
  1448.             if ($enableTierPricing && is_array($tierMins) && is_array($tierPrices)) {
  1449.                 $count = min(count($tierMins), count($tierPrices));
  1450.                 for ($i = 0; $i < $count; $i++) {
  1451.                     $m = (int) ($tierMins[$i] ?? 0);
  1452.                     $p = (float) ($tierPrices[$i] ?? 0);
  1453.                     if ($m >= 1 && $p > 0) {
  1454.                         $normalizedTiers[$m] = $p;
  1455.                     }
  1456.                 }
  1457.                 if (!empty($normalizedTiers)) {
  1458.                     ksort($normalizedTiers, SORT_NUMERIC);
  1459.                     $tiersArray = [];
  1460.                     foreach ($normalizedTiers as $minQty => $priceVal) {
  1461.                         $tiersArray[] = [ 'min' => (int)$minQty, 'price' => (float)$priceVal ];
  1462.                     }
  1463.                     $product->setHasTierPricing(true);
  1464.                     $product->setTierPrices($tiersArray);
  1465.                 } else {
  1466.                     $product->setHasTierPricing(false);
  1467.                     $product->setTierPrices(null);
  1468.                 }
  1469.             } else {
  1470.                 $product->setHasTierPricing(false);
  1471.                 $product->setTierPrices(null);
  1472.                 }
  1473.             }
  1475.             // Gestion des fichiers (images, vidéos, documents)
  1476.             $images = $product->getImages();
  1477.             $videos = $product->getVideos();
  1478.             $documents = $product->getDocuments();
  1480.             // Upload des nouvelles images
  1481.             if (!empty($uploadedImages)) {
  1482.                 $productDir = $this->getParameter('kernel.project_dir') . '/public/uploads/products/' . $product->getId();
  1483.                 if (!is_dir($productDir)) {
  1484.                     mkdir($productDir, 0755, true);
  1485.                 }
  1486.                 foreach ($uploadedImages as $file) {
  1487.                     if ($file && $file->isValid()) {
  1488.                         $filename = uniqid() . '.' . $file->guessExtension();
  1489.                         $file->move($productDir, $filename);
  1490.                         $images[] = '/uploads/products/' . $product->getId() . '/' . $filename;
  1491.                     }
  1492.                 }
  1493.             }
  1495.             // Upload des nouvelles vidéos
  1496.             $uploadedVideos = $request->files->all('videos');
  1497.             if (!empty($uploadedVideos)) {
  1498.                 if ($videos === null) $videos = [];
  1499.                 $productDir = $this->getParameter('kernel.project_dir') . '/public/uploads/products/' . $product->getId() . '/videos';
  1500.                 if (!is_dir($productDir)) {
  1501.                     mkdir($productDir, 0755, true);
  1502.                 }
  1503.                 foreach ($uploadedVideos as $file) {
  1504.                     if ($file && $file->isValid()) {
  1505.                         $filename = uniqid() . '.' . $file->guessExtension();
  1506.                         $file->move($productDir, $filename);
  1507.                         $videos[] = '/uploads/products/' . $product->getId() . '/videos/' . $filename;
  1508.                     }
  1509.                 }
  1510.             }
  1512.             // Upload des nouveaux documents
  1513.             $uploadedDocuments = $request->files->all('documents');
  1514.             if (!empty($uploadedDocuments)) {
  1515.                 if ($documents === null) $documents = [];
  1516.                 $productDir = $this->getParameter('kernel.project_dir') . '/public/uploads/products/' . $product->getId() . '/documents';
  1517.                 if (!is_dir($productDir)) {
  1518.                     mkdir($productDir, 0755, true);
  1519.                 }
  1520.                 foreach ($uploadedDocuments as $file) {
  1521.                     if ($file && $file->isValid()) {
  1522.                         $filename = uniqid() . '.' . $file->guessExtension();
  1523.                         $file->move($productDir, $filename);
  1524.                         $documents[] = '/uploads/products/' . $product->getId() . '/documents/' . $filename;
  1525.                     }
  1526.                 }
  1527.             }
  1529.             $product->setImages($images);
  1530.             $product->setVideos($videos ?: null);
  1531.             $product->setDocuments($documents ?: null);
  1533.             // Gérer les variantes de produit
  1534.             $variantsData = $request->request->all('variants') ?? [];
  1535.             $variantsFiles = $request->files->all('variants') ?? [];
  1536.             $attributeValueRepo = $em->getRepository(\App\Entity\ProductAttributeValue::class);
  1537.             $variantRepo = $em->getRepository(\App\Entity\ProductVariant::class);
  1538.             $sluggerFile = new AsciiSlugger();
  1539.             
  1540.             // Récupérer toutes les variantes existantes
  1541.             $existingVariants = [];
  1542.             foreach ($product->getVariants() as $existingVariant) {
  1543.                 $existingVariants[$existingVariant->getId()] = $existingVariant;
  1544.             }
  1545.             
  1546.             // Traiter les variantes soumises
  1547.             foreach ($variantsData as $variantKey => $variantData) {
  1548.                 // Vérifier si c'est une suppression
  1549.                 if (!empty($variantData['delete'])) {
  1550.                     if (isset($existingVariants[$variantKey])) {
  1551.                         $existingVariants[$variantKey]->setIsActive(false);
  1552.                     }
  1553.                     continue;
  1554.                 }
  1555.                 
  1556.                 // Vérifier si c'est une variante existante à mettre à jour
  1557.                 if (is_numeric($variantKey) && isset($existingVariants[$variantKey])) {
  1558.                     $variant = $existingVariants[$variantKey];
  1559.                     // Le SKU est préservé via le champ caché, pas besoin de le modifier
  1560.                     $variant->setPrice((float) $variantData['price']);
  1561.                     $variant->setStock((int) $variantData['stock']);
  1562.                     $variant->setCompareAtPrice(!empty($variantData['compareAtPrice']) ? (float) $variantData['compareAtPrice'] : null);
  1563.                     
  1564.                     // Mettre à jour les attributs
  1565.                     $variant->getAttributeValues()->clear();
  1566.                     if (!empty($variantData['attributes']) && is_array($variantData['attributes'])) {
  1567.                         foreach ($variantData['attributes'] as $attrData) {
  1568.                             if (!empty($attrData['valueId'])) {
  1569.                                 $attrValue = $attributeValueRepo->find((int) $attrData['valueId']);
  1570.                                 if ($attrValue && $attrValue->isIsActive()) {
  1571.                                     $variant->addAttributeValue($attrValue);
  1572.                                 }
  1573.                             }
  1574.                         }
  1575.                     }
  1576.                     
  1577.                     // Gérer les nouvelles images de variante
  1578.                     if (isset($variantsFiles[$variantKey]['images']) && is_array($variantsFiles[$variantKey]['images'])) {
  1579.                         $variantImages = $variant->getImages();
  1580.                         $productDir = $this->getParameter('kernel.project_dir') . '/public/uploads/products/' . $product->getId();
  1581.                         foreach ($variantsFiles[$variantKey]['images'] as $file) {
  1582.                             if ($file && $file instanceof \Symfony\Component\HttpFoundation\File\UploadedFile && $file->isValid()) {
  1583.                                 $ext = $file->guessExtension() ?: $file->getClientOriginalExtension() ?: 'bin';
  1584.                                 $orig = pathinfo((string)$file->getClientOriginalName(), PATHINFO_FILENAME);
  1585.                                 $safeOrig = strtolower($sluggerFile->slug($orig)->toString());
  1586.                                 $unique = bin2hex(random_bytes(8)) . '_' . str_replace('.', '', (string) microtime(true));
  1587.                                 $filename = $safeOrig . '_' . $unique . '.' . $ext;
  1588.                                 $file->move($productDir, $filename);
  1589.                                 $variantImages[] = '/uploads/products/' . $product->getId() . '/' . $filename;
  1590.                             }
  1591.                         }
  1592.                         $variant->setImages($variantImages);
  1593.                     }
  1594.                 } else {
  1595.                     // Nouvelle variante
  1596.                     if (empty($variantData['price']) || empty($variantData['stock'])) {
  1597.                         continue;
  1598.                     }
  1599.                     
  1600.                     $variant = new \App\Entity\ProductVariant();
  1601.                     $variant->setProduct($product);
  1602.                     // Générer automatiquement le SKU si non fourni
  1603.                     if (empty($variantData['sku'])) {
  1604.                         $variantSku = 'SKU-' . strtoupper(substr(md5($name . microtime() . $variantKey), 0, 8)) . '-' . uniqid();
  1605.                         $variant->setSku($variantSku);
  1606.                     } else {
  1607.                         $variant->setSku($variantData['sku']);
  1608.                     }
  1609.                     $variant->setPrice((float) $variantData['price']);
  1610.                     $variant->setStock((int) $variantData['stock']);
  1611.                     $variant->setCompareAtPrice(!empty($variantData['compareAtPrice']) ? (float) $variantData['compareAtPrice'] : null);
  1612.                     $variant->setManageStock($manageStock);
  1613.                     $variant->setAllowBackorders($allowBackorders);
  1614.                     $variant->setStockStatus($stockStatus ?: 'in_stock');
  1615.                     $variant->setIsActive(true);
  1616.                     $variant->setIsDefault(false);
  1617.                     
  1618.                     // Gérer les attributs
  1619.                     if (!empty($variantData['attributes']) && is_array($variantData['attributes'])) {
  1620.                         foreach ($variantData['attributes'] as $attrData) {
  1621.                             if (!empty($attrData['valueId'])) {
  1622.                                 $attrValue = $attributeValueRepo->find((int) $attrData['valueId']);
  1623.                                 if ($attrValue && $attrValue->isIsActive()) {
  1624.                                     $variant->addAttributeValue($attrValue);
  1625.                                 }
  1626.                             }
  1627.                         }
  1628.                     }
  1629.                     
  1630.                     // Gérer les images
  1631.                     $variantImages = [];
  1632.                     if (isset($variantsFiles[$variantKey]['images']) && is_array($variantsFiles[$variantKey]['images'])) {
  1633.                         $productDir = $this->getParameter('kernel.project_dir') . '/public/uploads/products/' . $product->getId();
  1634.                         foreach ($variantsFiles[$variantKey]['images'] as $file) {
  1635.                             if ($file && $file instanceof \Symfony\Component\HttpFoundation\File\UploadedFile && $file->isValid()) {
  1636.                                 $ext = $file->guessExtension() ?: $file->getClientOriginalExtension() ?: 'bin';
  1637.                                 $orig = pathinfo((string)$file->getClientOriginalName(), PATHINFO_FILENAME);
  1638.                                 $safeOrig = strtolower($sluggerFile->slug($orig)->toString());
  1639.                                 $unique = bin2hex(random_bytes(8)) . '_' . str_replace('.', '', (string) microtime(true));
  1640.                                 $filename = $safeOrig . '_' . $unique . '.' . $ext;
  1641.                                 $file->move($productDir, $filename);
  1642.                                 $variantImages[] = '/uploads/products/' . $product->getId() . '/' . $filename;
  1643.                             }
  1644.                         }
  1645.                     }
  1646.                     $variant->setImages($variantImages);
  1647.                     
  1648.                     $em->persist($variant);
  1649.                 }
  1650.             }
  1651.             
  1652.             // Supprimer les variantes qui n'ont pas été soumises (si nécessaire)
  1653.             // Pour l'instant, on garde toutes les variantes existantes sauf celles marquées pour suppression
  1654.             
  1655.             // Gérer les détails supplémentaires
  1656.             $detailsData = $request->request->all('details') ?? [];
  1657.             $detailRepo = $em->getRepository(\App\Entity\ProductDetail::class);
  1658.             
  1659.             // Récupérer tous les détails existants
  1660.             $existingDetails = [];
  1661.             foreach ($product->getDetails() as $existingDetail) {
  1662.                 $existingDetails[$existingDetail->getId()] = $existingDetail;
  1663.             }
  1664.             
  1665.             // Traiter les détails soumis
  1666.             foreach ($detailsData as $detailKey => $detailData) {
  1667.                 // Vérifier si c'est une suppression
  1668.                 if (!empty($detailData['delete'])) {
  1669.                     if (isset($existingDetails[$detailKey])) {
  1670.                         $existingDetails[$detailKey]->setIsActive(false);
  1671.                     }
  1672.                     continue;
  1673.                 }
  1674.                 
  1675.                 // Vérifier si c'est un détail existant à mettre à jour
  1676.                 if (is_numeric($detailKey) && isset($existingDetails[$detailKey])) {
  1677.                     $detail = $existingDetails[$detailKey];
  1678.                     $detail->setLabel(trim($detailData['label']));
  1679.                     $detail->setValue(trim($detailData['value']));
  1680.                 } else {
  1681.                     // Nouveau détail
  1682.                     if (empty($detailData['label']) || empty($detailData['value'])) {
  1683.                         continue;
  1684.                     }
  1685.                     
  1686.                     $detail = new \App\Entity\ProductDetail();
  1687.                     $detail->setProduct($product);
  1688.                     $detail->setLabel(trim($detailData['label']));
  1689.                     $detail->setValue(trim($detailData['value']));
  1690.                     $detail->setIsActive(true);
  1691.                     $detail->setSortOrder(0);
  1692.                     
  1693.                     $em->persist($detail);
  1694.                 }
  1695.             }
  1697.             try {
  1698.                 $em->flush();
  1699.                 
  1700.                 // Si c'est une requête AJAX (upload de fichiers), retourner du JSON
  1701.                 if ($request->isXmlHttpRequest() || $request->headers->get('X-Requested-With') === 'XMLHttpRequest' || !empty($uploadedImages) || !empty($uploadedVideos) || !empty($uploadedDocuments)) {
  1702.                     // Si la requête contient uniquement des fichiers, on peut considérer que c'est un upload partiel
  1703.                     // Sinon, c'est peut-être la soumission globale via AJAX
  1704.                     return new JsonResponse([
  1705.                         'success' => true,
  1706.                         'message' => 'Produit mis à jour avec succès',
  1707.                         'data' => [
  1708.                             'images' => $product->getImages(),
  1709.                             'videos' => $product->getVideos(),
  1710.                             'documents' => $product->getDocuments()
  1711.                         ]
  1712.                     ]);
  1713.                 }
  1715.                 $this->addFlash('success', 'Produit modifié avec succès.');
  1716.                 return $this->redirectToRoute('seller_product_show', ['shopSlug' => $shop->getSlug(), 'id' => $product->getId()]);
  1717.             } catch (\Throwable $e) {
  1718.                 if ($request->isXmlHttpRequest() || $request->headers->get('X-Requested-With') === 'XMLHttpRequest') {
  1719.                     return new JsonResponse(['success' => false, 'message' => 'Erreur lors de la modification: ' . $e->getMessage()], 500);
  1720.                 }
  1721.                 $this->addFlash('error', 'Erreur lors de la modification: ' . $e->getMessage());
  1722.             }
  1723.         }
  1725.         // Récupérer les catégories pour le formulaire
  1726.         $categories = $em->getRepository(Category::class)->findAll();
  1728.         // Récupérer les attributs disponibles pour les variantes
  1729.         $attributes = $em->getRepository(\App\Entity\ProductAttribute::class)->findActiveOrdered();
  1730.         $attributesData = [];
  1731.         foreach ($attributes as $attr) {
  1732.             $values = [];
  1733.             foreach ($attr->getValues() as $value) {
  1734.                 if ($value->isIsActive()) {
  1735.                     $values[] = [
  1736.                         'id' => $value->getId(),
  1737.                         'value' => $value->getValue(),
  1738.                         'colorCode' => $value->getColorCode(),
  1739.                         'image' => $value->getImage(),
  1740.                     ];
  1741.                 }
  1742.             }
  1743.             $attributesData[] = [
  1744.                 'id' => $attr->getId(),
  1745.                 'name' => $attr->getName(),
  1746.                 'slug' => $attr->getSlug(),
  1747.                 'type' => $attr->getType(),
  1748.                 'values' => $values,
  1749.             ];
  1750.         }
  1752.         // Rendre le template seller pour modifier le produit
  1753.         return $this->render('seller/product/edit.html.twig', [
  1754.             'product' => $product,
  1755.             'shop' => $shop,
  1756.             'categories' => $categories,
  1757.             'attributes' => $attributesData,
  1758.         ]);
  1759.     }
  1761.     #[Route('/shop/{shopSlug}/products/{id}/image/delete', name: 'product_image_delete', methods: ['POST'])]
  1762.     public function deleteProductImage(string $shopSlug, int $id, Request $request, EntityManagerInterface $em): JsonResponse
  1763.     {
  1764.         if (!$this->getUser() || !$this->isAuthorized()) {
  1765.             return new JsonResponse(['success' => false, 'message' => 'Non autorisé'], 401);
  1766.         }
  1768.         $shop = $em->getRepository(Shop::class)->findOneBy(['slug' => $shopSlug]);
  1769.         
  1770.         if (!$shop) {
  1771.             return new JsonResponse(['success' => false, 'message' => 'Boutique non trouvée'], 404);
  1772.         }
  1774.         // Vérifier que la boutique appartient au vendeur
  1775.         if (!$shop->getManager()->contains($this->getUser())) {
  1776.             return new JsonResponse(['success' => false, 'message' => 'Vous n\'avez pas accès à cette boutique.'], 403);
  1777.         }
  1779.         $product = $em->getRepository(Product::class)->find($id);
  1780.         
  1781.         if (!$product || $product->getShop()->getId() !== $shop->getId()) {
  1782.             return new JsonResponse(['success' => false, 'message' => 'Produit non trouvé'], 404);
  1783.         }
  1785.         $imagePath = $request->request->get('image');
  1786.         if (!$imagePath) {
  1787.             return new JsonResponse(['success' => false, 'message' => 'Chemin d\'image manquant'], 400);
  1788.         }
  1790.         // Normaliser le chemin (s'assurer qu'il commence par /)
  1791.         $normalizedPath = ltrim($imagePath, '/');
  1792.         $normalizedPath = '/' . $normalizedPath;
  1794.         $images = $product->getImages();
  1795.         
  1796.         // Essayer de trouver l'image avec différentes variantes du chemin
  1797.         $imageIndex = false;
  1798.         foreach ($images as $index => $storedImage) {
  1799.             // Normaliser le chemin stocké aussi
  1800.             $normalizedStored = ltrim($storedImage, '/');
  1801.             $normalizedStored = '/' . $normalizedStored;
  1802.             
  1803.             // Comparer les chemins normalisés ou originaux
  1804.             if ($normalizedStored === $normalizedPath || 
  1805.                 $storedImage === $imagePath || 
  1806.                 $storedImage === $normalizedPath ||
  1807.                 $storedImage === ltrim($imagePath, '/')) {
  1808.                 $imageIndex = $index;
  1809.                 $imagePath = $storedImage; // Utiliser le chemin exact stocké
  1810.                 break;
  1811.             }
  1812.         }
  1813.         
  1814.         if ($imageIndex === false) {
  1815.             return new JsonResponse([
  1816.                 'success' => false, 
  1817.                 'message' => 'Image non trouvée dans la liste',
  1818.                 'debug' => [
  1819.                     'requested' => $imagePath,
  1820.                     'normalized_requested' => $normalizedPath,
  1821.                     'available_images' => $images
  1822.                 ]
  1823.             ], 404);
  1824.         }
  1826.         // Supprimer l'image du tableau
  1827.         unset($images[$imageIndex]);
  1828.         $images = array_values($images); // Réindexer le tableau
  1829.         $product->setImages($images);
  1831.         // Supprimer le fichier physique - utiliser le chemin exact stocké
  1832.         $filePathToDelete = $this->getParameter('kernel.project_dir') . '/public' . $imagePath;
  1833.         
  1834.         // Essayer aussi avec le chemin normalisé si différent
  1835.         if (!file_exists($filePathToDelete) && $imagePath !== $normalizedPath) {
  1836.             $filePathToDelete = $this->getParameter('kernel.project_dir') . '/public' . $normalizedPath;
  1837.         }
  1838.         
  1839.         if (file_exists($filePathToDelete)) {
  1840.             @unlink($filePathToDelete);
  1841.         }
  1843.         try {
  1844.             $em->flush();
  1845.             return new JsonResponse([
  1846.                 'success' => true,
  1847.                 'message' => 'Image supprimée avec succès',
  1848.                 'data' => [
  1849.                     'images' => $product->getImages(),
  1850.                     'videos' => $product->getVideos(),
  1851.                     'documents' => $product->getDocuments()
  1852.                 ]
  1853.             ]);
  1854.         } catch (\Throwable $e) {
  1855.             return new JsonResponse(['success' => false, 'message' => 'Erreur lors de la suppression: ' . $e->getMessage()], 500);
  1856.         }
  1857.     }
  1859.     #[Route('/shop/{shopSlug}/products/{id}/video/delete', name: 'product_video_delete', methods: ['POST'])]
  1860.     public function deleteProductVideo(string $shopSlug, int $id, Request $request, EntityManagerInterface $em): JsonResponse
  1861.     {
  1862.         if (!$this->getUser() || !$this->isAuthorized()) {
  1863.             return new JsonResponse(['success' => false, 'message' => 'Non autorisé'], 401);
  1864.         }
  1866.         $shop = $em->getRepository(Shop::class)->findOneBy(['slug' => $shopSlug]);
  1867.         
  1868.         if (!$shop) {
  1869.             return new JsonResponse(['success' => false, 'message' => 'Boutique non trouvée'], 404);
  1870.         }
  1872.         if (!$shop->getManager()->contains($this->getUser())) {
  1873.             return new JsonResponse(['success' => false, 'message' => 'Vous n\'avez pas accès à cette boutique.'], 403);
  1874.         }
  1876.         $product = $em->getRepository(Product::class)->find($id);
  1877.         
  1878.         if (!$product || $product->getShop()->getId() !== $shop->getId()) {
  1879.             return new JsonResponse(['success' => false, 'message' => 'Produit non trouvé'], 404);
  1880.         }
  1882.         $videoPath = $request->request->get('video');
  1883.         if (!$videoPath) {
  1884.             return new JsonResponse(['success' => false, 'message' => 'Chemin de vidéo manquant'], 400);
  1885.         }
  1887.         $normalizedPath = ltrim($videoPath, '/');
  1888.         $normalizedPath = '/' . $normalizedPath;
  1890.         $videos = $product->getVideos() ?: [];
  1891.         
  1892.         $videoIndex = false;
  1893.         foreach ($videos as $index => $storedVideo) {
  1894.             $normalizedStored = ltrim($storedVideo, '/');
  1895.             $normalizedStored = '/' . $normalizedStored;
  1896.             
  1897.             if ($normalizedStored === $normalizedPath || 
  1898.                 $storedVideo === $videoPath || 
  1899.                 $storedVideo === $normalizedPath ||
  1900.                 $storedVideo === ltrim($videoPath, '/')) {
  1901.                 $videoIndex = $index;
  1902.                 $videoPath = $storedVideo;
  1903.                 break;
  1904.             }
  1905.         }
  1906.         
  1907.         if ($videoIndex === false) {
  1908.             return new JsonResponse(['success' => false, 'message' => 'Vidéo non trouvée dans la liste'], 404);
  1909.         }
  1911.         unset($videos[$videoIndex]);
  1912.         $videos = array_values($videos);
  1913.         $product->setVideos(empty($videos) ? null : $videos);
  1915.         $filePathToDelete = $this->getParameter('kernel.project_dir') . '/public' . $videoPath;
  1916.         if (!file_exists($filePathToDelete) && $videoPath !== $normalizedPath) {
  1917.             $filePathToDelete = $this->getParameter('kernel.project_dir') . '/public' . $normalizedPath;
  1918.         }
  1919.         
  1920.         if (file_exists($filePathToDelete)) {
  1921.             @unlink($filePathToDelete);
  1922.         }
  1924.         try {
  1925.             $em->flush();
  1926.             return new JsonResponse([
  1927.                 'success' => true,
  1928.                 'message' => 'Vidéo supprimée avec succès',
  1929.                 'data' => [
  1930.                     'images' => $product->getImages(),
  1931.                     'videos' => $product->getVideos(),
  1932.                     'documents' => $product->getDocuments()
  1933.                 ]
  1934.             ]);
  1935.         } catch (\Throwable $e) {
  1936.             return new JsonResponse(['success' => false, 'message' => 'Erreur lors de la suppression: ' . $e->getMessage()], 500);
  1937.         }
  1938.     }
  1940.     #[Route('/shop/{shopSlug}/products/{id}/document/delete', name: 'product_document_delete', methods: ['POST'])]
  1941.     public function deleteProductDocument(string $shopSlug, int $id, Request $request, EntityManagerInterface $em): JsonResponse
  1942.     {
  1943.         if (!$this->getUser() || !$this->isAuthorized()) {
  1944.             return new JsonResponse(['success' => false, 'message' => 'Non autorisé'], 401);
  1945.         }
  1947.         $shop = $em->getRepository(Shop::class)->findOneBy(['slug' => $shopSlug]);
  1948.         
  1949.         if (!$shop) {
  1950.             return new JsonResponse(['success' => false, 'message' => 'Boutique non trouvée'], 404);
  1951.         }
  1953.         if (!$shop->getManager()->contains($this->getUser())) {
  1954.             return new JsonResponse(['success' => false, 'message' => 'Vous n\'avez pas accès à cette boutique.'], 403);
  1955.         }
  1957.         $product = $em->getRepository(Product::class)->find($id);
  1958.         
  1959.         if (!$product || $product->getShop()->getId() !== $shop->getId()) {
  1960.             return new JsonResponse(['success' => false, 'message' => 'Produit non trouvé'], 404);
  1961.         }
  1963.         $documentPath = $request->request->get('document');
  1964.         if (!$documentPath) {
  1965.             return new JsonResponse(['success' => false, 'message' => 'Chemin de document manquant'], 400);
  1966.         }
  1968.         $normalizedPath = ltrim($documentPath, '/');
  1969.         $normalizedPath = '/' . $normalizedPath;
  1971.         $documents = $product->getDocuments() ?: [];
  1972.         
  1973.         $documentIndex = false;
  1974.         foreach ($documents as $index => $storedDocument) {
  1975.             $normalizedStored = ltrim($storedDocument, '/');
  1976.             $normalizedStored = '/' . $normalizedStored;
  1977.             
  1978.             if ($normalizedStored === $normalizedPath || 
  1979.                 $storedDocument === $documentPath || 
  1980.                 $storedDocument === $normalizedPath ||
  1981.                 $storedDocument === ltrim($documentPath, '/')) {
  1982.                 $documentIndex = $index;
  1983.                 $documentPath = $storedDocument;
  1984.                 break;
  1985.             }
  1986.         }
  1987.         
  1988.         if ($documentIndex === false) {
  1989.             return new JsonResponse(['success' => false, 'message' => 'Document non trouvé dans la liste'], 404);
  1990.         }
  1992.         unset($documents[$documentIndex]);
  1993.         $documents = array_values($documents);
  1994.         $product->setDocuments(empty($documents) ? null : $documents);
  1996.         $filePathToDelete = $this->getParameter('kernel.project_dir') . '/public' . $documentPath;
  1997.         if (!file_exists($filePathToDelete) && $documentPath !== $normalizedPath) {
  1998.             $filePathToDelete = $this->getParameter('kernel.project_dir') . '/public' . $normalizedPath;
  1999.         }
  2000.         
  2001.         if (file_exists($filePathToDelete)) {
  2002.             @unlink($filePathToDelete);
  2003.         }
  2005.         try {
  2006.             $em->flush();
  2007.             return new JsonResponse([
  2008.                 'success' => true,
  2009.                 'message' => 'Document supprimé avec succès',
  2010.                 'data' => [
  2011.                     'images' => $product->getImages(),
  2012.                     'videos' => $product->getVideos(),
  2013.                     'documents' => $product->getDocuments()
  2014.                 ]
  2015.             ]);
  2016.         } catch (\Throwable $e) {
  2017.             return new JsonResponse(['success' => false, 'message' => 'Erreur lors de la suppression: ' . $e->getMessage()], 500);
  2018.         }
  2019.     }
  2021.     #[Route('/shop/{slug}/banner-image/delete', name: 'shop_banner_image_delete', methods: ['POST'])]
  2022.     public function deleteShopBannerImage(string $slug, Request $request, EntityManagerInterface $em): JsonResponse
  2023.     {
  2024.         if (!$this->getUser() || !$this->isAuthorized()) {
  2025.             return new JsonResponse(['success' => false, 'message' => 'Non autorisé'], 401);
  2026.         }
  2028.         $shop = $em->getRepository(Shop::class)->findOneBy(['slug' => $slug]);
  2029.         
  2030.         if (!$shop) {
  2031.             return new JsonResponse(['success' => false, 'message' => 'Boutique non trouvée'], 404);
  2032.         }
  2034.         // Vérifier que la boutique appartient au vendeur
  2035.         if (!$shop->getManager()->contains($this->getUser())) {
  2036.             return new JsonResponse(['success' => false, 'message' => 'Vous n\'avez pas accès à cette boutique.'], 403);
  2037.         }
  2039.         $imagePath = $request->request->get('image');
  2040.         if (!$imagePath) {
  2041.             return new JsonResponse(['success' => false, 'message' => 'Chemin d\'image manquant'], 400);
  2042.         }
  2044.         $bannerImages = $shop->getAllBannerImages();
  2045.         $normalizedPath = ltrim($imagePath, '/');
  2046.         $imageIndex = -1;
  2047.         
  2048.         foreach ($bannerImages as $index => $bannerImage) {
  2049.             $normalizedBannerImage = ltrim($bannerImage, '/');
  2050.             if ($bannerImage === $imagePath || $normalizedBannerImage === $normalizedPath || $bannerImage === $normalizedPath || $normalizedBannerImage === $imagePath) {
  2051.                 $imageIndex = $index;
  2052.                 break;
  2053.             }
  2054.         }
  2056.         if ($imageIndex === -1) {
  2057.             return new JsonResponse(['success' => false, 'message' => 'Image non trouvée'], 404);
  2058.         }
  2060.         unset($bannerImages[$imageIndex]);
  2061.         $bannerImages = array_values($bannerImages);
  2062.         $shop->setBannerImages(empty($bannerImages) ? [] : $bannerImages);
  2064.         $filePathToDelete = $this->getParameter('kernel.project_dir') . '/public/' . ltrim($imagePath, '/');
  2065.         if (!file_exists($filePathToDelete) && $imagePath !== $normalizedPath) {
  2066.             $filePathToDelete = $this->getParameter('kernel.project_dir') . '/public/' . $normalizedPath;
  2067.         }
  2068.         
  2069.         if (file_exists($filePathToDelete)) {
  2070.             @unlink($filePathToDelete);
  2071.         }
  2073.         try {
  2074.             $em->flush();
  2075.             return new JsonResponse([
  2076.                 'success' => true,
  2077.                 'message' => 'Image de bannière supprimée avec succès',
  2078.                 'data' => [
  2079.                     'bannerImages' => $shop->getAllBannerImages()
  2080.                 ]
  2081.             ]);
  2082.         } catch (\Throwable $e) {
  2083.             return new JsonResponse(['success' => false, 'message' => 'Erreur lors de la suppression: ' . $e->getMessage()], 500);
  2084.         }
  2085.     }
  2087.     #[Route('/shop/{shopSlug}/products/{id}/delete', name: 'product_delete', methods: ['POST'])]
  2088.     public function deleteProduct(string $shopSlug, int $id, EntityManagerInterface $em): JsonResponse
  2089.     {
  2090.         if (!$this->getUser() || !$this->isAuthorized()) {
  2091.             return new JsonResponse(['success' => false, 'message' => 'Non autorisé'], 401);
  2092.         }
  2094.         $shop = $em->getRepository(Shop::class)->findOneBy(['slug' => $shopSlug]);
  2095.         
  2096.         if (!$shop) {
  2097.             return new JsonResponse(['success' => false, 'message' => 'Boutique non trouvée'], 404);
  2098.         }
  2100.         // Vérifier que la boutique appartient au vendeur
  2101.         if (!$shop->getManager()->contains($this->getUser())) {
  2102.             return new JsonResponse(['success' => false, 'message' => 'Vous n\'avez pas accès à cette boutique.'], 403);
  2103.         }
  2105.         $product = $em->getRepository(Product::class)->find($id);
  2106.         
  2107.         if (!$product || $product->getShop()->getId() !== $shop->getId()) {
  2108.             return new JsonResponse(['success' => false, 'message' => 'Produit non trouvé'], 404);
  2109.         }
  2111.         // Cacher le produit au lieu de le supprimer
  2112.         try {
  2113.             $product->setIsActive(false);
  2114.             $em->flush();
  2115.             
  2116.             return new JsonResponse([
  2117.                 'success' => true,
  2118.                 'message' => 'Produit supprimé avec succès',
  2119.                 'hidden' => true
  2120.             ]);
  2121.         } catch (\Throwable $e) {
  2122.             return new JsonResponse([
  2123.                 'success' => false, 
  2124.                 'message' => 'Erreur lors de la suppression: ' . $e->getMessage()
  2125.             ], 500);
  2126.         }
  2127.     }
  2129.     #[Route('/check-slug', name: 'shop_check_slug', methods: ['GET'])]
  2130.     public function checkSlug(Request $request, EntityManagerInterface $em): JsonResponse
  2131.     {
  2132.         $slug = $request->query->get('slug');
  2134.         if (!$slug) {
  2135.             return new JsonResponse(['valid' => false, 'message' => 'Slug manquant'], 400);
  2136.         }
  2138.         $exists = $em->getRepository(Shop::class)->findOneBy(['slug' => $slug]);
  2140.         return new JsonResponse([
  2141.             'valid' => $exists ? false : true,
  2142.             'message' => $exists ? 'Ce slug est déjà utilisé' : 'Slug disponible'
  2143.         ]);
  2144.     }
  2146.     #[Route('/pricing', name: 'pricing')]
  2147.     public function pricingSeller(ShopPlanRepository $shopPlanRepository): Response
  2148.     {
  2149.         if (!$this->getUser()) {
  2150.             return $this->redirectToRoute('ui_app_login');
  2151.         }
  2152.         if (!$this->isAuthorized()) {
  2153.             return $this->render('misc/access_denied.html.twig');
  2154.         }
  2155.         $allPlans = $shopPlanRepository->findAll();
  2156.         return $this->render('seller/pricing.html.twig', [
  2157.             'current_menu' => 'pricing',
  2158.             'allPlans' => $allPlans
  2159.         ]);
  2160.     }
  2162.     #[Route('/faq', name: 'faq')]
  2163.     public function faqSeller(): Response
  2164.     {
  2165.         if (!$this->getUser()) {
  2166.             return $this->redirectToRoute('ui_app_login');
  2167.         }
  2168.         if (!$this->isAuthorized()) {
  2169.             return $this->render('misc/access_denied.html.twig');
  2170.         }
  2171.         return $this->render('seller/faq.html.twig', [
  2172.             'current_menu' => 'faq'
  2173.         ]);
  2174.     }
  2176.     #[Route('/terms', name: 'terms')]
  2177.     public function terms(): Response
  2178.     {
  2179.         if (!$this->getUser()) {
  2180.             return $this->redirectToRoute('ui_app_login');
  2181.         }
  2182.         if (!$this->isAuthorized()) {
  2183.             return $this->render('misc/access_denied.html.twig');
  2184.         }
  2185.         return $this->render('seller/terms.html.twig', [
  2186.             'current_menu' => 'shop'
  2187.         ]);
  2188.     }
  2190.     #[Route('/privacy', name: 'privacy')]
  2191.     public function privacy(): Response
  2192.     {
  2193.         if (!$this->getUser()) {
  2194.             return $this->redirectToRoute('ui_app_login');
  2195.         }
  2196.         if (!$this->isAuthorized()) {
  2197.             return $this->render('misc/access_denied.html.twig');
  2198.         }
  2199.         return $this->render('seller/privacy.html.twig', [
  2200.             'current_menu' => 'shop'
  2201.         ]);
  2202.     }
  2204.     #[Route('/shop/{slug}/orders', name: 'shop_orders')]
  2205.     public function shopOrders(string $slug, EntityManagerInterface $em): Response
  2206.     {
  2207.         if (!$this->getUser()) {
  2208.             return $this->redirectToRoute('ui_app_login');
  2209.         }
  2210.         if (!$this->isAuthorized()) {
  2211.             return $this->render('misc/access_denied.html.twig');
  2212.         }
  2214.         $shop = $em->getRepository(Shop::class)->findOneBy(['slug' => $slug]);
  2215.         
  2216.         if (!$shop) {
  2217.             $this->addFlash('error', 'Boutique non trouvée.');
  2218.             return $this->redirectToRoute('seller_index');
  2219.         }
  2221.         // Vérifier que la boutique appartient à l'utilisateur connecté
  2222.         if (!$shop->getManager()->contains($this->getUser())) {
  2223.             $this->addFlash('error', 'Vous n\'avez pas accès à cette boutique.');
  2224.             return $this->redirectToRoute('seller_index');
  2225.         }
  2227.         // TODO: Implémenter la logique pour afficher les commandes
  2228.         return $this->render('seller/orders.html.twig', [
  2229.             'shop' => $shop,
  2230.             'current_menu' => 'shop'
  2231.         ]);
  2232.     }
  2234.     #[Route('/shop/{slug}/transactions', name: 'shop_transactions')]
  2235.     public function shopTransactions(string $slug, EntityManagerInterface $em): Response
  2236.     {
  2237.         if (!$this->getUser()) {
  2238.             return $this->redirectToRoute('ui_app_login');
  2239.         }
  2240.         if (!$this->isAuthorized()) {
  2241.             return $this->render('misc/access_denied.html.twig');
  2242.         }
  2244.         $shop = $em->getRepository(Shop::class)->findOneBy(['slug' => $slug]);
  2245.         
  2246.         if (!$shop) {
  2247.             $this->addFlash('error', 'Boutique non trouvée.');
  2248.             return $this->redirectToRoute('seller_index');
  2249.         }
  2251.         // Vérifier que la boutique appartient à l'utilisateur connecté
  2252.         if (!$shop->getManager()->contains($this->getUser())) {
  2253.             $this->addFlash('error', 'Vous n\'avez pas accès à cette boutique.');
  2254.             return $this->redirectToRoute('seller_index');
  2255.         }
  2257.         // TODO: Implémenter la logique pour afficher les transactions
  2258.         return $this->render('seller/transactions.html.twig', [
  2259.             'shop' => $shop,
  2260.             'current_menu' => 'shop'
  2261.         ]);
  2262.     }
  2264.     #[Route('/shop/{slug}/team', name: 'shop_team')]
  2265.     public function shopTeam(string $slug, Request $request, EntityManagerInterface $em, ShopLimitService $shopLimitService): Response
  2266.     {
  2267.         if (!$this->getUser()) {
  2268.             return $this->redirectToRoute('ui_app_login');
  2269.         }
  2270.         if (!$this->isAuthorized()) {
  2271.             return $this->render('misc/access_denied.html.twig');
  2272.         }
  2274.         $shop = $em->getRepository(Shop::class)->findOneBy(['slug' => $slug]);
  2275.         
  2276.         if (!$shop) {
  2277.             $this->addFlash('error', 'Boutique non trouvée.');
  2278.             return $this->redirectToRoute('seller_index');
  2279.         }
  2281.         // Vérifier que la boutique appartient à l'utilisateur connecté
  2282.         if (!$shop->getManager()->contains($this->getUser())) {
  2283.             $this->addFlash('error', 'Vous n\'avez pas accès à cette boutique.');
  2284.             return $this->redirectToRoute('seller_index');
  2285.         }
  2287.         // Gérer l'ajout d'un membre
  2288.         if ($request->isMethod('POST') && $request->request->has('add_member')) {
  2289.             $email = trim($request->request->get('email', ''));
  2290.             
  2291.             if (empty($email)) {
  2292.                 $this->addFlash('error', 'L\'email est requis.');
  2293.             } else {
  2294.                 // Vérifier la limite d'employés avec le service
  2295.                 $employeeLimitCheck = $shopLimitService->canShopAddEmployee($shop);
  2296.                 if (!$employeeLimitCheck['allowed']) {
  2297.                     $this->addFlash('error', $employeeLimitCheck['message']);
  2298.                     return $this->redirectToRoute('seller_shop_team', ['slug' => $slug]);
  2299.                 }
  2300.                 
  2301.                 // Vérifier aussi que l'utilisateur à ajouter n'a pas atteint sa limite de boutiques
  2302.                 $userRepo = $em->getRepository(User::class);
  2303.                 $userToAdd = $userRepo->findOneBy(['email' => $email]);
  2304.                 
  2305.                 if (!$userToAdd) {
  2306.                     $this->addFlash('error', 'Aucun utilisateur trouvé avec cet email.');
  2307.                 } elseif ($shop->getManager()->contains($userToAdd)) {
  2308.                     $this->addFlash('warning', 'Cet utilisateur fait déjà partie de l\'équipe.');
  2309.                 } else {
  2310.                     // Vérifier que l'utilisateur peut être membre d'une nouvelle boutique
  2311.                     $userShopLimitCheck = $shopLimitService->canUserCreateShop($userToAdd);
  2312.                     if (!$userShopLimitCheck['allowed']) {
  2313.                         $this->addFlash('error', sprintf(
  2314.                             'Cet utilisateur a déjà atteint sa limite de %d boutiques. Il ne peut pas être ajouté à une nouvelle boutique.',
  2315.                             $userShopLimitCheck['max_count']
  2316.                         ));
  2317.                     } else {
  2318.                         $shop->addManager($userToAdd);
  2319.                         $shop->setCurrentEmployees($shop->getManager()->count());
  2320.                         $em->flush();
  2321.                         $this->addFlash('success', 'Membre ajouté à l\'équipe avec succès.');
  2322.                     }
  2323.                 }
  2324.             }
  2325.             
  2326.             return $this->redirectToRoute('seller_shop_team', ['slug' => $slug]);
  2327.         }
  2329.         // Gérer la suppression d'un membre
  2330.         if ($request->isMethod('POST') && $request->request->has('remove_member')) {
  2331.             $memberId = (int) $request->request->get('member_id');
  2332.             $userRepo = $em->getRepository(User::class);
  2333.             $member = $userRepo->find($memberId);
  2334.             $currentUser = $this->getUser();
  2335.             
  2336.             if (!$member) {
  2337.                 $this->addFlash('error', 'Membre non trouvé.');
  2338.             } elseif ($currentUser instanceof User && $member->getId() === $currentUser->getId()) {
  2339.                 $this->addFlash('error', 'Vous ne pouvez pas vous retirer vous-même de l\'équipe.');
  2340.             } elseif (!$shop->getManager()->contains($member)) {
  2341.                 $this->addFlash('error', 'Ce membre ne fait pas partie de l\'équipe.');
  2342.             } else {
  2343.                 $shop->removeManager($member);
  2344.                 $shop->setCurrentEmployees($shop->getManager()->count());
  2345.                 $em->flush();
  2346.                 $this->addFlash('success', 'Membre retiré de l\'équipe avec succès.');
  2347.             }
  2348.             
  2349.             return $this->redirectToRoute('seller_shop_team', ['slug' => $slug]);
  2350.         }
  2352.         // Récupérer tous les membres de l'équipe
  2353.         $teamMembers = $shop->getManager()->toArray();
  2354.         
  2355.         // Récupérer les informations du plan pour l'affichage
  2356.         $plan = $shop->getPlan();
  2357.         $maxEmployees = $plan ? $plan->getMaxEmployees() : null;
  2358.         $currentEmployeesCount = count($teamMembers);
  2359.         $canAddMore = $maxEmployees === null || $currentEmployeesCount < $maxEmployees;
  2361.         return $this->render('seller/team.html.twig', [
  2362.             'shop' => $shop,
  2363.             'teamMembers' => $teamMembers,
  2364.             'plan' => $plan,
  2365.             'maxEmployees' => $maxEmployees,
  2366.             'currentEmployeesCount' => $currentEmployeesCount,
  2367.             'canAddMore' => $canAddMore,
  2368.             'current_menu' => 'shop'
  2369.         ]);
  2370.     }
  2372.     private function isAuthorized(): bool
  2373.     {
  2374.         if (!$this->isGranted('IS_AUTHENTICATED_FULLY')) {
  2375.             return false;
  2376.         }
  2377.         $user = $this->getUser();
  2378.         return $user && in_array('ROLE_SELLER', $user->getRoles());
  2379.     }
  2380. }