src/Controller/SellerController.php line 30

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 Symfony\Bridge\Doctrine\Attribute\MapEntity;
  10. use App\Entity\User;
  11. use App\Form\SellerShopType;
  12. use App\Repository\ShopPlanRepository;
  13. use App\Service\NotificationService;
  14. use Doctrine\ORM\EntityManagerInterface;
  15. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  16. use Symfony\Component\HttpFoundation\JsonResponse;
  17. use Symfony\Component\HttpFoundation\Request;
  18. use Symfony\Component\HttpFoundation\Response;
  19. use Symfony\Component\Mailer\MailerInterface;
  20. use Symfony\Bridge\Twig\Mime\TemplatedEmail;
  21. use Symfony\Component\Mime\Address as EmailAddress;
  22. use Symfony\Component\Routing\Annotation\Route;
  23. use Symfony\Component\String\Slugger\AsciiSlugger;
  24. use function Symfony\Component\String\s;
  26. #[Route('/seller_space', name: 'seller_')]
  27. class SellerController extends AbstractController
  28. {
  29.     #[Route('/', name: 'index')]
  30.     public function indexSeller(): Response
  31.     {
  32.         if (!$this->getUser()) {
  33.             return $this->redirectToRoute('ui_app_login');
  34.         }
  35.         if (!$this->isAuthorized()) {
  36.             return $this->render('misc/access_denied.html.twig');
  37.         }
  38.         return $this->render('seller/index.html.twig', [
  39.             'current_menu' => 'home'
  40.         ]);
  41.     }
  43.     #[Route('/help/how-to-sell', name: 'help_how_to_sell')]
  44.     public function howToSell(): Response
  45.     {
  46.         return $this->render('seller/help/how_to_sell.html.twig', [
  47.             'current_menu' => 'help'
  48.         ]);
  49.     }
  51.     #[Route('/help/pricing', name: 'help_pricing')]
  52.     public function pricing(EntityManagerInterface $em): Response
  53.     {
  54.         $shopPlans = $em->getRepository(ShopPlan::class)->findAll();
  55.         return $this->render('seller/help/pricing.html.twig', [
  56.             'current_menu' => 'help',
  57.             'shopPlans' => $shopPlans
  58.         ]);
  59.     }
  61.     #[Route('/help/support', name: 'help_support')]
  62.     public function support(): Response
  63.     {
  64.         return $this->render('seller/help/support.html.twig', [
  65.             'current_menu' => 'help'
  66.         ]);
  67.     }
  69.     #[Route('/shop/new', name: 'shop_new')]
  70.     public function newShopSeller(Request $request, EntityManagerInterface $entityManager, NotificationService $notificationService, MailerInterface $mailer): Response
  71.     {
  72.         if (!$this->getUser()) {
  73.             return $this->redirectToRoute('ui_app_login');
  74.         }
  75.         if (!$this->isAuthorized()) {
  76.             return $this->render('misc/access_denied.html.twig');
  77.         }
  78.         $shop = new Shop();
  79.         $form = $this->createForm(SellerShopType::class, $shop);
  80.         $form->handleRequest($request);
  82.         if ($form->isSubmitted() && $form->isValid()) {
  83.             $authenticatedUser = $this->getUser();
  84.             if (!$authenticatedUser instanceof User) {
  85.                 return $this->redirectToRoute('ui_app_login');
  86.             }
  88.             $userId = $authenticatedUser->getId();
  89.             $user = $entityManager->getRepository(User::class)->find($userId);
  91.             if (!$user) {
  92.                 throw $this->createNotFoundException('Utilisateur introuvable');
  93.             }
  95.             // Configuration de base
  96.             $shop->setIsActive(true);
  97.             $shop->setCreatedAt(new \DateTimeImmutable('now'));
  98.             $shop->setCurrentEmployees(1);
  99.             
  100.             // Génération automatique du slug si nécessaire
  101.             if ($shop->getName()) {
  102.                 $slugger = new AsciiSlugger();
  103.                 $shop->setSlug(strtolower($slugger->slug($shop->getName())->toString()));
  104.             }
  105.             
  106.             // Initialisation des compteurs
  107.             $shop->setCurrentOrders(0);
  108.             $shop->setCurrentProducts(0);
  109.             $shop->setCurrentCaLimit(0);
  110.             $shop->setCurrentRevenue('0.000');
  111.             $shop->setCurrentStorage(0);
  112.             
  113.             // Initialisation des statistiques
  114.             $shop->setViewCount(0);
  115.             $shop->setFollowerCount(0);
  116.             $shop->setAverageRating(0.0);
  117.             $shop->setReviewCount(0);
  118.             
  119.             // Configuration des statuts par défaut
  120.             if (!$shop->getStatus()) {
  121.                 $shop->setStatus('pending');
  122.             }
  123.             if (!$shop->getVerificationStatus()) {
  124.                 $shop->setVerificationStatus('unverified');
  125.             }
  126.             
  127.             // Configuration des options par défaut (uniquement pour les champs modifiables par le vendeur)
  128.             if ($shop->isIsActive() === null) {
  129.                 $shop->setIsActive(true);
  130.             }
  131.             if ($shop->isAllowReviews() === null) {
  132.                 $shop->setAllowReviews(true);
  133.             }
  134.             if ($shop->isAllowMessages() === null) {
  135.                 $shop->setAllowMessages(true);
  136.             }
  137.             if ($shop->isShowContactInfo() === null) {
  138.                 $shop->setShowContactInfo(true);
  139.             }
  140.             if ($shop->isShowSocialLinks() === null) {
  141.                 $shop->setShowSocialLinks(true);
  142.             }
  143.             
  144.             // Champs gérés uniquement par l'administrateur (ne pas modifier)
  145.             // isVerified, isPremium, status, verificationStatus sont gérés par l'admin
  146.             if (!$shop->getStatus()) {
  147.                 $shop->setStatus('pending');
  148.             }
  149.             if (!$shop->getVerificationStatus()) {
  150.                 $shop->setVerificationStatus('unverified');
  151.             }
  152.             if ($shop->isIsVerified() === null) {
  153.                 $shop->setIsVerified(false);
  154.             }
  155.             if ($shop->isIsPremium() === null) {
  156.                 $shop->setIsPremium(false);
  157.             }
  158.             
  159.             // Gestion des fichiers uploadés
  160.             $logoFile = $form->get('logo')->getData();
  161.             if ($logoFile && $logoFile->isValid()) {
  162.                 $maxSize = 15 * 1024 * 1024; // 15MB
  163.                 if ($logoFile->getSize() > $maxSize) {
  164.                     $this->addFlash('error', 'Le logo est trop volumineux. Taille maximale : 15MB.');
  165.                 } else {
  166.                     $newFilename = uniqid().'.'.$logoFile->guessExtension();
  167.                     $logoFile->move(
  168.                         $this->getParameter('kernel.project_dir').'/public/uploads/shops/',
  169.                         $newFilename
  170.                     );
  171.                     $shop->setLogo('uploads/shops/'.$newFilename);
  172.                 }
  173.             }
  174.             
  175.             // Gestion des images de bannière (jusqu'à 7 images, 15MB max chacune)
  176.             $allBannerImages = $shop->getAllBannerImages();
  177.             
  178.             // Gestion des nouvelles images multiples de bannière
  179.             $bannerImagesFile = $form->get('bannerImages')->getData();
  180.             if ($bannerImagesFile) {
  181.                 $maxSize = 15 * 1024 * 1024; // 15MB
  182.                 foreach ($bannerImagesFile as $file) {
  183.                     if ($file && $file->isValid()) {
  184.                         // Vérifier la taille du fichier
  185.                         if ($file->getSize() > $maxSize) {
  186.                             $this->addFlash('error', 'Le fichier "' . $file->getClientOriginalName() . '" est trop volumineux. Taille maximale : 15MB.');
  187.                             continue;
  188.                         }
  189.                         
  190.                         $newFilename = uniqid().'.'.$file->guessExtension();
  191.                         $file->move(
  192.                             $this->getParameter('kernel.project_dir').'/public/uploads/shops/',
  193.                             $newFilename
  194.                         );
  195.                         $allBannerImages[] = 'uploads/shops/'.$newFilename;
  196.                     }
  197.                 }
  198.             }
  200.             // Dédupliquer et limiter à 7 images max
  201.             $allBannerImages = array_values(array_unique($allBannerImages));
  202.             if (count($allBannerImages) > 7) {
  203.                 $this->addFlash('error', 'Maximum 7 images de bannière autorisées. Les images supplémentaires ont été ignorées.');
  204.                 $allBannerImages = array_slice($allBannerImages, 0, 7);
  205.             }
  206.             $shop->setBannerImages($allBannerImages);
  207.             
  208.             // Contraintes basées sur le plan sélectionné
  209.             if ($shop->getPlan()) {
  210.                 $plan = $shop->getPlan();
  211.                 $errors = [];
  212.                 
  213.                 // Vérifier les champs requis par le plan
  214.                 if ($plan->isRequireSiretNif() && !$shop->getSiretNif()) {
  215.                     $errors[] = 'Votre plan exige un SIRET/NIF. Veuillez le renseigner.';
  216.                 }
  217.                 
  218.                 if ($plan->isRequireIban() && !$shop->getIban()) {
  219.                     $errors[] = 'Votre plan exige un IBAN. Veuillez le renseigner.';
  220.                 }
  221.                 
  222.                 // Si des erreurs, retourner au formulaire
  223.                 if (!empty($errors)) {
  224.                     foreach ($errors as $error) {
  225.                         $this->addFlash('error', $error);
  226.                     }
  227.                     return $this->render('seller/new_shop_simple.html.twig', [
  228.                         'current_menu' => 'shop',
  229.                         'current' => 'shopNew',
  230.                         'shop' => $shop,
  231.                         'form' => $form->createView()
  232.                     ]);
  233.                 }
  234.             }
  235.             
  236.             $shop->addManager($user);
  237.             $entityManager->persist($shop);
  238.             $entityManager->flush();
  240.             // Créer une notification de félicitations
  241.             $notificationService->createShopCreatedNotification($user, $shop);
  243.             // Envoyer un email de félicitations
  244.             try {
  245.                 $email = (new TemplatedEmail())
  246.                     ->from(new EmailAddress('noreply@maketou.com', 'MaketOu'))
  247.                     ->to(new EmailAddress($user->getEmail(), $user->getFirstname() . ' ' . $user->getLastname()))
  248.                     ->subject('Félicitations ! Votre boutique "' . $shop->getName() . '" a été créée')
  249.                     ->htmlTemplate('emails/shop_created.html.twig')
  250.                     ->context([
  251.                         'user' => $user,
  252.                         'shop' => $shop,
  253.                     ]);
  255.                 $mailer->send($email);
  256.             } catch (\Exception $e) {
  257.                 // Log l'erreur mais ne bloque pas la création de la boutique
  258.                 // On peut logger l'erreur ici si nécessaire
  259.             }
  261.             $this->addFlash('success', 'Boutique créée avec succès ! Vous avez reçu un email de confirmation.');
  262.             return $this->redirectToRoute('seller_index', [], Response::HTTP_SEE_OTHER);
  263.         }
  264.         // Récupérer tous les plans pour les contraintes JavaScript
  265.         $shopPlans = $entityManager->getRepository(ShopPlan::class)->findAll();
  266.         $plansData = [];
  267.         foreach ($shopPlans as $plan) {
  268.             $plansData[$plan->getId()] = [
  269.                 'id' => $plan->getId(),
  270.                 'name' => $plan->getName(),
  271.                 'requireSiretNif' => $plan->isRequireSiretNif(),
  272.                 'requireIban' => $plan->isRequireIban(),
  273.                 'maxProducts' => $plan->getMaxProducts(),
  274.                 'maxEmployees' => $plan->getMaxEmployees(),
  275.             ];
  276.         }
  277.         
  278.         return $this->render('seller/new_shop_simple.html.twig', [
  279.             'current_menu' => 'shop',
  280.             'current' => 'shopNew',
  281.             'shop' => $shop,
  282.             'form' => $form->createView(),
  283.             'plansData' => $plansData
  284.         ]);
  285.     }
  287.     #[Route('/shop/{slug}/show', name: 'shop_show')]
  288.     public function showShopSeller(#[MapEntity(mapping: ['slug' => 'slug'])] Shop $shop, Request $request, EntityManagerInterface $em): Response
  289.     {
  290.         if (!$this->getUser()) {
  291.             return $this->redirectToRoute('ui_app_login');
  292.         }
  293.         if (!$this->isAuthorized()) {
  294.             return $this->render('misc/access_denied.html.twig');
  295.         }
  297.         // Vérifier que la boutique appartient à l'utilisateur connecté
  298.         $canEdit = $shop->getManager()->contains($this->getUser());
  300.         // Calculer les statistiques dynamiques
  301.         $productsCount = $shop->getActiveProductsCount();
  302.         $totalProducts = $shop->getProducts()->count();
  303.         $ordersCount = $shop->getCurrentOrders() ?? 0;
  304.         $revenue = (float)($shop->getCurrentRevenue() ?? 0);
  305.         
  306.         // Calculer le solde disponible (revenue - dépenses potentielles)
  307.         // Pour l'instant, on utilise le revenue comme solde disponible
  308.         $availableBalance = $revenue;
  309.         
  310.         // Calculer la date de dernière mise à jour (date de création ou dernière commande)
  311.         $lastUpdate = $shop->getCreatedAt();
  312.         if ($ordersCount > 0) {
  313.             // Essayer de trouver la dernière commande via les produits
  314.             // Pour l'instant, on utilise la date de création
  315.         }
  316.         
  317.         // Calculer le temps depuis la dernière mise à jour
  318.         $updateText = 'Aujourd\'hui';
  319.         if ($lastUpdate) {
  320.             $now = new \DateTimeImmutable();
  321.             $diff = $now->diff($lastUpdate);
  322.             if ($diff->days > 0) {
  323.                 if ($diff->days == 1) {
  324.                     $updateText = 'Hier';
  325.                 } elseif ($diff->days < 7) {
  326.                     $updateText = 'Il y a ' . $diff->days . ' jours';
  327.                 } elseif ($diff->days < 30) {
  328.                     $weeks = floor($diff->days / 7);
  329.                     $updateText = 'Il y a ' . $weeks . ' semaine' . ($weeks > 1 ? 's' : '');
  330.                 } else {
  331.                     $months = floor($diff->days / 30);
  332.                     $updateText = 'Il y a ' . $months . ' mois';
  333.                 }
  334.             }
  335.         }
  337.         // Récupérer les commandes récentes de la boutique (si l'entité Order existe)
  338.         $recentOrders = [];
  339.         try {
  340.             $orderRepo = $em->getRepository(\App\Entity\Order::class);
  341.             $recentOrders = $orderRepo->createQueryBuilder('o')
  342.                 ->join('o.items', 'oi')
  343.                 ->join('oi.product', 'p')
  344.                 ->where('p.shop = :shop')
  345.                 ->setParameter('shop', $shop)
  346.                 ->orderBy('o.orderedAt', 'DESC')
  347.                 ->setMaxResults(10)
  348.                 ->getQuery()
  349.                 ->getResult();
  350.         } catch (\Exception $e) {
  351.             // Si l'entité Order n'existe pas encore, on continue sans
  352.         }
  354.         // Calculer les statistiques de vues par période (derniers 30 jours)
  355.         $viewsLast30Days = 0;
  356.         try {
  357.             // Pour l'instant, on utilise viewCount comme approximation
  358.             $viewsLast30Days = (int)($shop->getViewCount() * 0.3); // Approximation
  359.         } catch (\Exception $e) {
  360.             // Ignorer si erreur
  361.         }
  363.         return $this->render('seller/show_shop.html.twig', [
  364.             'current_menu' => 'shop',
  365.             'slugShop' => $shop->getSlug(),
  366.             'shop' => $shop,
  367.             'canEdit' => $canEdit,
  368.             'recentOrders' => $recentOrders,
  369.             'viewsLast30Days' => $viewsLast30Days,
  370.             'stats' => [
  371.                 'productsCount' => $productsCount,
  372.                 'totalProducts' => $totalProducts,
  373.                 'ordersCount' => $ordersCount,
  374.                 'revenue' => $revenue,
  375.                 'availableBalance' => $availableBalance,
  376.                 'lastUpdate' => $updateText
  377.             ]
  378.         ]);
  379.     }
  381.     #[Route('/shop/{slug}/edit', name: 'shop_edit')]
  382.     public function editShopSeller(#[MapEntity(mapping: ['slug' => 'slug'])] Shop $shop, Request $request, EntityManagerInterface $entityManager): Response
  383.     {
  384.         if (!$this->getUser()) {
  385.             return $this->redirectToRoute('ui_app_login');
  386.         }
  387.         if (!$this->isAuthorized()) {
  388.             return $this->render('misc/access_denied.html.twig');
  389.         }
  391.         // Vérifier que la boutique appartient à l'utilisateur connecté
  392.         if (!$shop->getManager()->contains($this->getUser())) {
  393.             $this->addFlash('error', 'Vous n\'avez pas la permission de modifier cette boutique.');
  394.             return $this->redirectToRoute('seller_shop_show', ['slug' => $shop->getSlug()]);
  395.         }
  397.         $form = $this->createForm(SellerShopType::class, $shop);
  398.         $form->handleRequest($request);
  400.         if ($form->isSubmitted() && $form->isValid()) {
  401.             // Génération automatique du slug si le nom a changé
  402.             if ($shop->getName()) {
  403.                 $slugger = new AsciiSlugger();
  404.                 $newSlug = strtolower($slugger->slug($shop->getName())->toString());
  405.                 // Vérifier si le slug existe déjà pour une autre boutique
  406.                 $existingShop = $entityManager->getRepository(Shop::class)->findOneBy(['slug' => $newSlug]);
  407.                 if (!$existingShop || $existingShop->getId() === $shop->getId()) {
  408.                     $shop->setSlug($newSlug);
  409.                 }
  410.             }
  411.             
  412.             // Gestion des fichiers uploadés
  413.             $logoFile = $form->get('logo')->getData();
  414.             if ($logoFile && $logoFile->isValid()) {
  415.                 $maxSize = 15 * 1024 * 1024; // 15MB
  416.                 if ($logoFile->getSize() > $maxSize) {
  417.                     $this->addFlash('error', 'Le logo est trop volumineux. Taille maximale : 15MB.');
  418.                 } else {
  419.                     $newFilename = uniqid().'.'.$logoFile->guessExtension();
  420.                     $logoFile->move(
  421.                         $this->getParameter('kernel.project_dir').'/public/uploads/shops/',
  422.                         $newFilename
  423.                     );
  424.                     $shop->setLogo('uploads/shops/'.$newFilename);
  425.                 }
  426.             }
  427.             
  428.             // Gestion des images de bannière (jusqu'à 7 images, 15MB max chacune)
  429.             $allBannerImages = $shop->getAllBannerImages();
  430.             
  431.             // Gérer la suppression d'images existantes
  432.             $removeBannerImages = $request->request->all('removeBannerImages');
  433.             if ($removeBannerImages) {
  434.                 foreach ($removeBannerImages as $imageToRemove) {
  435.                     $allBannerImages = array_filter($allBannerImages, function($img) use ($imageToRemove) {
  436.                         return $img !== $imageToRemove;
  437.                     });
  438.                 }
  439.                 $allBannerImages = array_values($allBannerImages);
  440.             }
  441.             
  442.             // Gestion des nouvelles images multiples de bannière
  443.             $bannerImagesFile = $form->get('bannerImages')->getData();
  444.             if ($bannerImagesFile) {
  445.                 $maxSize = 15 * 1024 * 1024; // 15MB
  446.                 foreach ($bannerImagesFile as $file) {
  447.                     if ($file && $file->isValid()) {
  448.                         // Vérifier la taille du fichier
  449.                         if ($file->getSize() > $maxSize) {
  450.                             $this->addFlash('error', 'Le fichier "' . $file->getClientOriginalName() . '" est trop volumineux. Taille maximale : 15MB.');
  451.                             continue;
  452.                         }
  453.                         
  454.                         $newFilename = uniqid().'.'.$file->guessExtension();
  455.                         $file->move(
  456.                             $this->getParameter('kernel.project_dir').'/public/uploads/shops/',
  457.                             $newFilename
  458.                         );
  459.                         $allBannerImages[] = 'uploads/shops/'.$newFilename;
  460.                     }
  461.                 }
  462.             }
  464.             // Dédupliquer et limiter à 7 images max
  465.             $allBannerImages = array_values(array_unique($allBannerImages));
  466.             if (count($allBannerImages) > 7) {
  467.                 $this->addFlash('error', 'Maximum 7 images de bannière autorisées. Les images supplémentaires ont été ignorées.');
  468.                 $allBannerImages = array_slice($allBannerImages, 0, 7);
  469.             }
  470.             $shop->setBannerImages($allBannerImages);
  471.             
  472.             // Contraintes basées sur le plan sélectionné
  473.             if ($shop->getPlan()) {
  474.                 $plan = $shop->getPlan();
  475.                 $errors = [];
  476.                 
  477.                 // Vérifier les champs requis par le plan
  478.                 if ($plan->isRequireSiretNif() && !$shop->getSiretNif()) {
  479.                     $errors[] = 'Votre plan exige un SIRET/NIF. Veuillez le renseigner.';
  480.                 }
  481.                 
  482.                 if ($plan->isRequireIban() && !$shop->getIban()) {
  483.                     $errors[] = 'Votre plan exige un IBAN. Veuillez le renseigner.';
  484.                 }
  485.                 
  486.                 // Si des erreurs, retourner au formulaire
  487.                 if (!empty($errors)) {
  488.                     foreach ($errors as $error) {
  489.                         $this->addFlash('error', $error);
  490.                     }
  491.                     // Récupérer tous les plans pour les contraintes JavaScript
  492.                     $shopPlans = $entityManager->getRepository(ShopPlan::class)->findAll();
  493.                     $plansData = [];
  494.                     foreach ($shopPlans as $planItem) {
  495.                         $plansData[$planItem->getId()] = [
  496.                             'id' => $planItem->getId(),
  497.                             'name' => $planItem->getName(),
  498.                             'requireSiretNif' => $planItem->isRequireSiretNif(),
  499.                             'requireIban' => $planItem->isRequireIban(),
  500.                             'maxProducts' => $planItem->getMaxProducts(),
  501.                             'maxEmployees' => $planItem->getMaxEmployees(),
  502.                         ];
  503.                     }
  504.                     return $this->render('seller/new_shop_simple.html.twig', [
  505.                         'current_menu' => 'shop',
  506.                         'current' => 'shopEdit',
  507.                         'shop' => $shop,
  508.                         'form' => $form->createView(),
  509.                         'plansData' => $plansData
  510.                     ]);
  511.                 }
  512.             }
  513.             
  514.             $entityManager->flush();
  516.             $this->addFlash('success', 'Boutique modifiée avec succès !');
  517.             return $this->redirectToRoute('seller_shop_show', ['slug' => $shop->getSlug()], Response::HTTP_SEE_OTHER);
  518.         }
  520.         // Récupérer tous les plans pour les contraintes JavaScript
  521.         $shopPlans = $entityManager->getRepository(ShopPlan::class)->findAll();
  522.         $plansData = [];
  523.         foreach ($shopPlans as $plan) {
  524.             $plansData[$plan->getId()] = [
  525.                 'id' => $plan->getId(),
  526.                 'name' => $plan->getName(),
  527.                 'requireSiretNif' => $plan->isRequireSiretNif(),
  528.                 'requireIban' => $plan->isRequireIban(),
  529.                 'maxProducts' => $plan->getMaxProducts(),
  530.                 'maxEmployees' => $plan->getMaxEmployees(),
  531.             ];
  532.         }
  533.         
  534.         return $this->render('seller/new_shop_simple.html.twig', [
  535.             'current_menu' => 'shop',
  536.             'current' => 'shopEdit',
  537.             'shop' => $shop,
  538.             'form' => $form->createView(),
  539.             'plansData' => $plansData
  540.         ]);
  541.     }
  543.     #[Route('/shop/{slug}/show/products', name: 'shop_show_products')]
  544.     public function showProductsSeller(#[MapEntity(mapping: ['slug' => 'slug'])] Shop $shop, Request $request, EntityManagerInterface $em): Response
  545.     {
  546.         if (!$this->getUser()) {
  547.             return $this->redirectToRoute('ui_app_login');
  548.         }
  549.         if (!$this->isAuthorized()) {
  550.             return $this->render('misc/access_denied.html.twig');
  551.         }
  552.         $products = $shop->getProducts();
  553.         $categories = $em->getRepository(Category::class)->findAll();
  555.         $data = [];
  556.         foreach ($products as $product) {
  557.             $tierPrices = $product->getTierPrices();
  558.             $hasTierPricing = $product->hasTierPricing() || ($tierPrices && count($tierPrices) > 0);
  559.             
  560.             $data[] = [
  561.                 'id' => $product->getId(),
  562.                 'slug' => $product->getSlug(),
  563.                 'image' => $product->getImages()[0] ?? null,
  564.                 'name' => $product->getName(),
  565.                 'price' => $product->getPrice(),
  566.                 'stock' => $product->getStock(),
  567.                 'status' => $product->getStockStatus(),
  568.                 'hasTierPricing' => $hasTierPricing,
  569.             ];
  570.         }
  572.         return $this->render('seller/show_products.html.twig', [
  573.             'current_menu' => 'shop',
  574.             'current' => 'products',
  575.             'productsJson' => json_encode($data),
  576.             'categoriesJson' => json_encode(array_map(static function(Category $c){
  577.                 return ['id' => $c->getId(), 'name' => $c->getName()];
  578.             }, $categories)),
  579.             'slugShop' => $shop->getSlug(),
  580.             'shop' => $shop
  581.         ]);
  582.     }
  584.     #[Route('/shop/{slug}/products/new', name: 'shop_products_new', methods: ['POST'])]
  585.     public function createProductForShop(#[MapEntity(mapping: ['slug' => 'slug'])] Shop $shop, Request $request, EntityManagerInterface $em): Response
  586.     {
  587.         if (!$this->getUser() || !$this->isAuthorized()) {
  588.             return new JsonResponse(['ok' => false, 'message' => 'Non autorisé'], 401);
  589.         }
  591.         $product = new Product();
  593.         $name = trim((string) $request->request->get('name'));
  594.         $description = (string) $request->request->get('description');
  595.         $price = (float) $request->request->get('price');
  596.         $compareAtPrice = $request->request->get('compareAtPrice') !== null ? (float) $request->request->get('compareAtPrice') : null;
  597.         $stock = (int) $request->request->get('stock');
  598.         $minStockAlert = $request->request->get('minStockAlert') !== null ? (int) $request->request->get('minStockAlert') : 0;
  599.         $manageStock = (bool) $request->request->get('manageStock');
  600.         $allowBackorders = (bool) $request->request->get('allowBackorders');
  601.         $isFeatured = (bool) $request->request->get('isFeatured');
  602.         $isDigital = (bool) $request->request->get('isDigital');
  603.         $stockStatus = (string) $request->request->get('stockStatus');
  604.         $categoryId = (int) $request->request->get('category');
  606.         if ($name === '' || $price <= 0 || $stock < 0 || !$categoryId) {
  607.             return new JsonResponse(['ok' => false, 'message' => 'Champs requis manquants'], 400);
  608.         }
  610.         $category = $em->getRepository(Category::class)->find($categoryId);
  611.         if (!$category) {
  612.             return new JsonResponse(['ok' => false, 'message' => 'Catégorie invalide'], 400);
  613.         }
  615.         $slugger = new AsciiSlugger();
  616.         $slug = strtolower($slugger->slug($name)->toString());
  617.         $sku = 'SKU-' . strtoupper(substr(md5($name.microtime()), 0, 8));
  619.         $product->setName($name);
  620.         $product->setDescription($description ?: null);
  621.         $product->setPrice($price);
  622.         $product->setCompareAtPrice($compareAtPrice);
  623.         $product->setStock($stock);
  624.         $product->setMinStockAlert($minStockAlert);
  625.         $product->setManageStock($manageStock);
  626.         $product->setAllowBackorders($allowBackorders);
  627.         $product->setIsFeatured($isFeatured);
  628.         $product->setIsDigital($isDigital);
  629.         $product->setStockStatus($stockStatus ?: 'In stock');
  630.         $product->setCategory($category);
  631.         $product->setShop($shop);
  632.         $product->setSlug($slug);
  633.         $product->setSku($sku);
  634.         $product->setIsActive(true);
  635.         $product->setPublishedAt(new \DateTimeImmutable('now'));
  636.         $product->setViewCount(0);
  637.         $product->setSalesCount(0);
  638.         $product->setAverageRating(0);
  639.         $product->setReviewCount(0);
  641.         // Prix de gros (facultatif, à l'initiative du vendeur)
  642.         $enableTierPricing = (bool) $request->request->get('enableTierPricing');
  643.         $tierMins = $request->request->all('tierMin');
  644.         $tierPrices = $request->request->all('tierPrice');
  645.         $normalizedTiers = [];
  646.         if ($enableTierPricing && is_array($tierMins) && is_array($tierPrices)) {
  647.             $count = min(count($tierMins), count($tierPrices));
  648.             for ($i = 0; $i < $count; $i++) {
  649.                 $m = (int) ($tierMins[$i] ?? 0);
  650.                 $p = (float) ($tierPrices[$i] ?? 0);
  651.                 if ($m >= 1 && $p > 0) {
  652.                     $normalizedTiers[$m] = $p; // utiliser la quantité min comme clé pour dédupliquer
  653.                 }
  654.             }
  655.             if (!empty($normalizedTiers)) {
  656.                 ksort($normalizedTiers, SORT_NUMERIC);
  657.                 $tiersArray = [];
  658.                 foreach ($normalizedTiers as $minQty => $priceVal) {
  659.                     $tiersArray[] = [ 'min' => (int)$minQty, 'price' => (float)$priceVal ];
  660.                 }
  661.                 $product->setHasTierPricing(true);
  662.                 $product->setTierPrices($tiersArray);
  663.             } else {
  664.                 $product->setHasTierPricing(false);
  665.                 $product->setTierPrices(null);
  666.             }
  667.         } else {
  668.             $product->setHasTierPricing(false);
  669.             $product->setTierPrices(null);
  670.         }
  672.         // Uploads
  673.         try {
  674.             $projectDir = $this->getParameter('kernel.project_dir');
  675.             $baseUploadDir = $projectDir . '/public/uploads/products/' . $shop->getSlug();
  676.             $imagesDir = $baseUploadDir . '/images';
  677.             $videosDir = $baseUploadDir . '/videos';
  678.             $documentsDir = $baseUploadDir . '/documents';
  680.             foreach ([$imagesDir, $videosDir, $documentsDir] as $dir) {
  681.                 if (!is_dir($dir) && !@mkdir($dir, 0777, true) && !is_dir($dir)) {
  682.                     throw new \RuntimeException('Impossible de créer le dossier: ' . $dir);
  683.                 }
  684.             }
  686.             $sluggerFile = new AsciiSlugger();
  688.             $images = [];
  689.             $filesImages = $request->files->get('images', []);
  690.             if ($filesImages instanceof \Symfony\Component\HttpFoundation\File\UploadedFile) {
  691.                 $filesImages = [$filesImages];
  692.             }
  693.             foreach ($filesImages as $file) {
  694.                 if (!$file || !($file instanceof \Symfony\Component\HttpFoundation\File\UploadedFile) || !$file->isValid()) continue;
  695.                 $ext = $file->guessExtension() ?: $file->getClientOriginalExtension() ?: 'bin';
  696.                 $orig = pathinfo((string)$file->getClientOriginalName(), PATHINFO_FILENAME);
  697.                 $safeOrig = strtolower($sluggerFile->slug($orig)->toString());
  698.                 $unique = bin2hex(random_bytes(8)) . '_' . str_replace('.', '', (string) microtime(true));
  699.                 $filename = $safeOrig . '_' . $unique . '.' . $ext;
  700.                 $file->move($imagesDir, $filename);
  701.                 $images[] = '/uploads/products/' . $shop->getSlug() . '/images/' . $filename;
  702.             }
  703.             $videos = [];
  704.             $filesVideos = $request->files->get('videos', []);
  705.             if ($filesVideos instanceof \Symfony\Component\HttpFoundation\File\UploadedFile) {
  706.                 $filesVideos = [$filesVideos];
  707.             }
  708.             foreach ($filesVideos as $file) {
  709.                 if (!$file || !($file instanceof \Symfony\Component\HttpFoundation\File\UploadedFile) || !$file->isValid()) continue;
  710.                 $ext = $file->guessExtension() ?: $file->getClientOriginalExtension() ?: 'bin';
  711.                 $orig = pathinfo((string)$file->getClientOriginalName(), PATHINFO_FILENAME);
  712.                 $safeOrig = strtolower($sluggerFile->slug($orig)->toString());
  713.                 $unique = bin2hex(random_bytes(8)) . '_' . str_replace('.', '', (string) microtime(true));
  714.                 $filename = $safeOrig . '_' . $unique . '.' . $ext;
  715.                 $file->move($videosDir, $filename);
  716.                 $videos[] = '/uploads/products/' . $shop->getSlug() . '/videos/' . $filename;
  717.             }
  718.             $documents = [];
  719.             $filesDocuments = $request->files->get('documents', []);
  720.             if ($filesDocuments instanceof \Symfony\Component\HttpFoundation\File\UploadedFile) {
  721.                 $filesDocuments = [$filesDocuments];
  722.             }
  723.             foreach ($filesDocuments as $file) {
  724.                 if (!$file || !($file instanceof \Symfony\Component\HttpFoundation\File\UploadedFile) || !$file->isValid()) continue;
  725.                 $ext = $file->guessExtension() ?: $file->getClientOriginalExtension() ?: 'bin';
  726.                 $orig = pathinfo((string)$file->getClientOriginalName(), PATHINFO_FILENAME);
  727.                 $safeOrig = strtolower($sluggerFile->slug($orig)->toString());
  728.                 $unique = bin2hex(random_bytes(8)) . '_' . str_replace('.', '', (string) microtime(true));
  729.                 $filename = $safeOrig . '_' . $unique . '.' . $ext;
  730.                 $file->move($documentsDir, $filename);
  731.                 $documents[] = '/uploads/products/' . $shop->getSlug() . '/documents/' . $filename;
  732.             }
  733.         } catch (\Throwable $e) {
  734.             return new JsonResponse(['ok' => false, 'message' => 'Upload échoué: '.$e->getMessage()], 500);
  735.         }
  737.         $product->setImages($images);
  738.         $product->setVideos($videos ?: null);
  739.         $product->setDocuments($documents ?: null);
  741.         try {
  742.             // Incrémente le compteur de produits de la catégorie sélectionnée
  743.             if ($category) {
  744.                 $category->incrementProductCount();
  745.                 $em->persist($category);
  746.             }
  747.             $em->persist($product);
  748.             $em->flush();
  749.         } catch (\Throwable $e) {
  750.             return new JsonResponse(['ok' => false, 'message' => 'Erreur enregistrement: '.$e->getMessage()], 500);
  751.         }
  753.         return new JsonResponse([
  754.             'ok' => true,
  755.             'product' => [
  756.                 'id' => $product->getId(),
  757.                 'image' => $images[0] ?? null,
  758.                 'name' => $product->getName(),
  759.                 'price' => $product->getPrice(),
  760.                 'stock' => $product->getStock(),
  761.                 'status' => $product->getStockStatus(),
  762.                 'hasTierPricing' => $product->hasTierPricing(),
  763.             ]
  764.         ]);
  765.     }
  767.     #[Route('/shop/{shopSlug}/products/{id}/show', name: 'product_show')]
  768.     // Note: Le préfixe 'seller_' fait que la route finale est 'seller_product_show'
  769.     public function showProductSeller(#[MapEntity(mapping: ['shopSlug' => 'slug'])] Shop $shop, int $id, EntityManagerInterface $em): Response
  770.     {
  771.         if (!$this->getUser() || !$this->isAuthorized()) {
  772.             return $this->redirectToRoute('ui_app_login');
  773.         }
  775.         // Vérifier que la boutique appartient au vendeur
  776.         if (!$shop->getManager()->contains($this->getUser())) {
  777.             $this->addFlash('error', 'Vous n\'avez pas accès à cette boutique.');
  778.             return $this->redirectToRoute('seller_index');
  779.         }
  781.         $product = $em->getRepository(Product::class)->find($id);
  782.         
  783.         if (!$product || $product->getShop()->getId() !== $shop->getId()) {
  784.             throw $this->createNotFoundException('Produit non trouvé');
  785.         }
  787.         // Rendre le template seller pour voir le produit
  788.         return $this->render('seller/product/show.html.twig', [
  789.             'product' => $product,
  790.             'shop' => $shop,
  791.         ]);
  792.     }
  794.     #[Route('/shop/{shopSlug}/products/{id}/edit', name: 'product_edit', methods: ['GET', 'POST'])]
  795.     // Note: Le préfixe 'seller_' fait que la route finale est 'seller_product_edit'
  796.     public function editProductSeller(#[MapEntity(mapping: ['shopSlug' => 'slug'])] Shop $shop, int $id, Request $request, EntityManagerInterface $em): Response
  797.     {
  798.         if (!$this->getUser() || !$this->isAuthorized()) {
  799.             return $this->redirectToRoute('ui_app_login');
  800.         }
  802.         // Vérifier que la boutique appartient au vendeur
  803.         if (!$shop->getManager()->contains($this->getUser())) {
  804.             $this->addFlash('error', 'Vous n\'avez pas accès à cette boutique.');
  805.             return $this->redirectToRoute('seller_index');
  806.         }
  808.         $product = $em->getRepository(Product::class)->find($id);
  809.         
  810.         if (!$product || $product->getShop()->getId() !== $shop->getId()) {
  811.             throw $this->createNotFoundException('Produit non trouvé');
  812.         }
  814.         // Traitement de la soumission du formulaire (POST)
  815.         if ($request->isMethod('POST')) {
  816.             $name = trim((string) $request->request->get('name'));
  817.             $description = (string) $request->request->get('description');
  818.             $price = (float) $request->request->get('price');
  819.             $compareAtPrice = $request->request->get('compareAtPrice') !== null && $request->request->get('compareAtPrice') !== '' ? (float) $request->request->get('compareAtPrice') : null;
  820.             $stock = (int) $request->request->get('stock');
  821.             $minStockAlert = $request->request->get('minStockAlert') !== null ? (int) $request->request->get('minStockAlert') : 0;
  822.             $manageStock = (bool) $request->request->get('manageStock');
  823.             $allowBackorders = (bool) $request->request->get('allowBackorders');
  824.             $isFeatured = (bool) $request->request->get('isFeatured');
  825.             $isDigital = (bool) $request->request->get('isDigital');
  826.             $stockStatus = (string) $request->request->get('stockStatus');
  827.             $categoryId = (int) $request->request->get('category');
  828.             $isActive = (bool) $request->request->get('isActive');
  830.             if ($name === '' || $price <= 0 || $stock < 0 || !$categoryId) {
  831.                 $this->addFlash('error', 'Champs requis manquants ou invalides.');
  832.                 return $this->redirectToRoute('seller_product_edit', ['shopSlug' => $shop->getSlug(), 'id' => $product->getId()]);
  833.             }
  835.             $category = $em->getRepository(Category::class)->find($categoryId);
  836.             if (!$category) {
  837.                 $this->addFlash('error', 'Catégorie invalide.');
  838.                 return $this->redirectToRoute('seller_product_edit', ['shopSlug' => $shop->getSlug(), 'id' => $product->getId()]);
  839.             }
  841.             // Mettre à jour le slug si le nom a changé
  842.             if ($product->getName() !== $name) {
  843.                 $slugger = new AsciiSlugger();
  844.                 $slug = strtolower($slugger->slug($name)->toString());
  845.                 $product->setSlug($slug);
  846.             }
  848.             $product->setName($name);
  849.             $product->setDescription($description ?: null);
  850.             $product->setPrice($price);
  851.             $product->setCompareAtPrice($compareAtPrice);
  852.             $product->setStock($stock);
  853.             $product->setMinStockAlert($minStockAlert);
  854.             $product->setManageStock($manageStock);
  855.             $product->setAllowBackorders($allowBackorders);
  856.             $product->setIsFeatured($isFeatured);
  857.             $product->setIsDigital($isDigital);
  858.             $product->setStockStatus($stockStatus ?: 'In stock');
  859.             $product->setCategory($category);
  860.             $product->setIsActive($isActive);
  862.             // Prix de gros (Tier Pricing)
  863.             $enableTierPricing = (bool) $request->request->get('enableTierPricing');
  864.             $tierMins = $request->request->all('tierMin');
  865.             $tierPrices = $request->request->all('tierPrice');
  866.             $normalizedTiers = [];
  867.             if ($enableTierPricing && is_array($tierMins) && is_array($tierPrices)) {
  868.                 $count = min(count($tierMins), count($tierPrices));
  869.                 for ($i = 0; $i < $count; $i++) {
  870.                     $m = (int) ($tierMins[$i] ?? 0);
  871.                     $p = (float) ($tierPrices[$i] ?? 0);
  872.                     if ($m >= 1 && $p > 0) {
  873.                         $normalizedTiers[$m] = $p;
  874.                     }
  875.                 }
  876.                 if (!empty($normalizedTiers)) {
  877.                     ksort($normalizedTiers, SORT_NUMERIC);
  878.                     $tiersArray = [];
  879.                     foreach ($normalizedTiers as $minQty => $priceVal) {
  880.                         $tiersArray[] = [ 'min' => (int)$minQty, 'price' => (float)$priceVal ];
  881.                     }
  882.                     $product->setHasTierPricing(true);
  883.                     $product->setTierPrices($tiersArray);
  884.                 } else {
  885.                     $product->setHasTierPricing(false);
  886.                     $product->setTierPrices(null);
  887.                 }
  888.             } else {
  889.                 $product->setHasTierPricing(false);
  890.                 $product->setTierPrices(null);
  891.             }
  893.             // Gestion des fichiers (images, vidéos, documents)
  894.             $images = $product->getImages();
  895.             $videos = $product->getVideos();
  896.             $documents = $product->getDocuments();
  898.             // Upload des nouvelles images
  899.             $uploadedImages = $request->files->all('images');
  900.             if (!empty($uploadedImages)) {
  901.                 $productDir = $this->getParameter('kernel.project_dir') . '/public/uploads/products/' . $product->getId();
  902.                 if (!is_dir($productDir)) {
  903.                     mkdir($productDir, 0755, true);
  904.                 }
  905.                 foreach ($uploadedImages as $file) {
  906.                     if ($file && $file->isValid()) {
  907.                         $filename = uniqid() . '.' . $file->guessExtension();
  908.                         $file->move($productDir, $filename);
  909.                         $images[] = '/uploads/products/' . $product->getId() . '/' . $filename;
  910.                     }
  911.                 }
  912.             }
  914.             // Upload des nouvelles vidéos
  915.             $uploadedVideos = $request->files->all('videos');
  916.             if (!empty($uploadedVideos)) {
  917.                 if ($videos === null) $videos = [];
  918.                 $productDir = $this->getParameter('kernel.project_dir') . '/public/uploads/products/' . $product->getId() . '/videos';
  919.                 if (!is_dir($productDir)) {
  920.                     mkdir($productDir, 0755, true);
  921.                 }
  922.                 foreach ($uploadedVideos as $file) {
  923.                     if ($file && $file->isValid()) {
  924.                         $filename = uniqid() . '.' . $file->guessExtension();
  925.                         $file->move($productDir, $filename);
  926.                         $videos[] = '/uploads/products/' . $product->getId() . '/videos/' . $filename;
  927.                     }
  928.                 }
  929.             }
  931.             // Upload des nouveaux documents
  932.             $uploadedDocuments = $request->files->all('documents');
  933.             if (!empty($uploadedDocuments)) {
  934.                 if ($documents === null) $documents = [];
  935.                 $productDir = $this->getParameter('kernel.project_dir') . '/public/uploads/products/' . $product->getId() . '/documents';
  936.                 if (!is_dir($productDir)) {
  937.                     mkdir($productDir, 0755, true);
  938.                 }
  939.                 foreach ($uploadedDocuments as $file) {
  940.                     if ($file && $file->isValid()) {
  941.                         $filename = uniqid() . '.' . $file->guessExtension();
  942.                         $file->move($productDir, $filename);
  943.                         $documents[] = '/uploads/products/' . $product->getId() . '/documents/' . $filename;
  944.                     }
  945.                 }
  946.             }
  948.             $product->setImages($images);
  949.             $product->setVideos($videos ?: null);
  950.             $product->setDocuments($documents ?: null);
  952.             try {
  953.                 $em->flush();
  954.                 $this->addFlash('success', 'Produit modifié avec succès.');
  955.                 return $this->redirectToRoute('seller_product_show', ['shopSlug' => $shop->getSlug(), 'id' => $product->getId()]);
  956.             } catch (\Throwable $e) {
  957.                 $this->addFlash('error', 'Erreur lors de la modification: ' . $e->getMessage());
  958.             }
  959.         }
  961.         // Récupérer les catégories pour le formulaire
  962.         $categories = $em->getRepository(Category::class)->findAll();
  964.         // Rendre le template seller pour modifier le produit
  965.         return $this->render('seller/product/edit.html.twig', [
  966.             'product' => $product,
  967.             'shop' => $shop,
  968.             'categories' => $categories,
  969.         ]);
  970.     }
  972.     #[Route('/shop/{shopSlug}/products/{id}/image/delete', name: 'product_image_delete', methods: ['POST'])]
  973.     public function deleteProductImage(#[MapEntity(mapping: ['shopSlug' => 'slug'])] Shop $shop, int $id, Request $request, EntityManagerInterface $em): JsonResponse
  974.     {
  975.         if (!$this->getUser() || !$this->isAuthorized()) {
  976.             return new JsonResponse(['success' => false, 'message' => 'Non autorisé'], 401);
  977.         }
  979.         // Vérifier que la boutique appartient au vendeur
  980.         if (!$shop->getManager()->contains($this->getUser())) {
  981.             return new JsonResponse(['success' => false, 'message' => 'Vous n\'avez pas accès à cette boutique.'], 403);
  982.         }
  984.         $product = $em->getRepository(Product::class)->find($id);
  985.         
  986.         if (!$product || $product->getShop()->getId() !== $shop->getId()) {
  987.             return new JsonResponse(['success' => false, 'message' => 'Produit non trouvé'], 404);
  988.         }
  990.         $imagePath = $request->request->get('image');
  991.         if (!$imagePath) {
  992.             return new JsonResponse(['success' => false, 'message' => 'Chemin d\'image manquant'], 400);
  993.         }
  995.         $images = $product->getImages();
  996.         $imageIndex = array_search($imagePath, $images);
  997.         
  998.         if ($imageIndex === false) {
  999.             return new JsonResponse(['success' => false, 'message' => 'Image non trouvée'], 404);
  1000.         }
  1002.         // Supprimer l'image du tableau
  1003.         unset($images[$imageIndex]);
  1004.         $images = array_values($images); // Réindexer le tableau
  1005.         $product->setImages($images);
  1007.         // Supprimer le fichier physique
  1008.         $filePath = $this->getParameter('kernel.project_dir') . '/public' . $imagePath;
  1009.         if (file_exists($filePath)) {
  1010.             @unlink($filePath);
  1011.         }
  1013.         try {
  1014.             $em->flush();
  1015.             return new JsonResponse([
  1016.                 'success' => true,
  1017.                 'message' => 'Image supprimée avec succès',
  1018.                 'remainingImages' => count($images)
  1019.             ]);
  1020.         } catch (\Throwable $e) {
  1021.             return new JsonResponse(['success' => false, 'message' => 'Erreur lors de la suppression: ' . $e->getMessage()], 500);
  1022.         }
  1023.     }
  1025.     #[Route('/check-slug', name: 'shop_check_slug', methods: ['GET'])]
  1026.     public function checkSlug(Request $request, EntityManagerInterface $em): JsonResponse
  1027.     {
  1028.         $slug = $request->query->get('slug');
  1030.         if (!$slug) {
  1031.             return new JsonResponse(['valid' => false, 'message' => 'Slug manquant'], 400);
  1032.         }
  1034.         $exists = $em->getRepository(Shop::class)->findOneBy(['slug' => $slug]);
  1036.         return new JsonResponse([
  1037.             'valid' => $exists ? false : true,
  1038.             'message' => $exists ? 'Ce slug est déjà utilisé' : 'Slug disponible'
  1039.         ]);
  1040.     }
  1042.     #[Route('/pricing', name: 'pricing')]
  1043.     public function pricingSeller(ShopPlanRepository $shopPlanRepository): Response
  1044.     {
  1045.         if (!$this->getUser()) {
  1046.             return $this->redirectToRoute('ui_app_login');
  1047.         }
  1048.         if (!$this->isAuthorized()) {
  1049.             return $this->render('misc/access_denied.html.twig');
  1050.         }
  1051.         $allPlans = $shopPlanRepository->findAll();
  1052.         return $this->render('seller/pricing.html.twig', [
  1053.             'current_menu' => 'pricing',
  1054.             'allPlans' => $allPlans
  1055.         ]);
  1056.     }
  1058.     #[Route('/faq', name: 'faq')]
  1059.     public function faqSeller(): Response
  1060.     {
  1061.         if (!$this->getUser()) {
  1062.             return $this->redirectToRoute('ui_app_login');
  1063.         }
  1064.         if (!$this->isAuthorized()) {
  1065.             return $this->render('misc/access_denied.html.twig');
  1066.         }
  1067.         return $this->render('seller/faq.html.twig', [
  1068.             'current_menu' => 'faq'
  1069.         ]);
  1070.     }
  1072.     #[Route('/terms', name: 'terms')]
  1073.     public function terms(): Response
  1074.     {
  1075.         if (!$this->getUser()) {
  1076.             return $this->redirectToRoute('ui_app_login');
  1077.         }
  1078.         if (!$this->isAuthorized()) {
  1079.             return $this->render('misc/access_denied.html.twig');
  1080.         }
  1081.         return $this->render('seller/terms.html.twig', [
  1082.             'current_menu' => 'shop'
  1083.         ]);
  1084.     }
  1086.     #[Route('/privacy', name: 'privacy')]
  1087.     public function privacy(): Response
  1088.     {
  1089.         if (!$this->getUser()) {
  1090.             return $this->redirectToRoute('ui_app_login');
  1091.         }
  1092.         if (!$this->isAuthorized()) {
  1093.             return $this->render('misc/access_denied.html.twig');
  1094.         }
  1095.         return $this->render('seller/privacy.html.twig', [
  1096.             'current_menu' => 'shop'
  1097.         ]);
  1098.     }
  1100.     private function isAuthorized(): bool
  1101.     {
  1102.         if (!$this->isGranted('IS_AUTHENTICATED_FULLY')) {
  1103.             return false;
  1104.         }
  1105.         $user = $this->getUser();
  1106.         return $user && in_array('ROLE_SELLER', $user->getRoles());
  1107.     }
  1108. }