src/Controller/ThemeController.php line 275

  1. <?php
  3. namespace App\Controller;
  5. use App\Repository\ThemeSousCategorieRepository;
  6. use App\Repository\ThemeCategorieRepository;
  7. use App\Repository\ThemeRepository;
  8. use Symfony\Component\HttpFoundation\Request;
  9. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  10. use Symfony\Component\HttpFoundation\Response;
  11. use Symfony\Component\Routing\Annotation\Route;
  12. use Symfony\Component\HttpFoundation\File\File;
  13. use Symfony\Component\HttpFoundation\File\UploadedFile;
  14. use App\Entity\Theme;
  15. use App\Entity\ThemeSousCategorie;
  16. use Doctrine\ORM\EntityManagerInterface;
  18. class ThemeController extends AbstractController
  19. {
  20.     #[Route('/theme/index', name: 'app_theme')]
  21.     public function index(ThemeSousCategorieRepository $themeSousCategorieRepository, ThemeCategorieRepository $themeCategorieRepository): Response
  22.     {
  23.         $sousCategories = $themeSousCategorieRepository->findAll();
  24.         $themeCategories = $themeCategorieRepository->findAll();
  26.         return $this->render('theme/index.html.twig', [
  27.             'sous_categories' => $sousCategories,
  28.             'theme_categories' => $themeCategories,
  29.         ]);
  30.     }
  32.     #[Route('/theme/list', name: 'app_theme_list')]
  33.     public function list(ThemeRepository $themeRepository): Response
  34.     {
  35.      $themes = $themeRepository->findBy([], ['id' => 'DESC'], 200);
  36.         //$themes = $themeRepository->findAll();
  37.         return $this->render('theme/list.html.twig', [
  38.             'themes' => $themes,
  39.         ]);
  40.     }
  42.     #[Route('/theme/manuelle', name: 'app_theme_manuelle')]
  43.     public function manuelle(ThemeSousCategorieRepository $themeSousCategorieRepository, ThemeCategorieRepository $themeCategorieRepository): Response
  44.     {
  45.         $sousCategories = $themeSousCategorieRepository->findAll();
  46.         $themeCategories = $themeCategorieRepository->findAll();
  48.         return $this->render('theme/manuelle.html.twig', [
  49.             'sous_categories' => $sousCategories,
  50.             'theme_categories' => $themeCategories,
  51.         ]);
  52.     }
  55.     #[Route('/theme/delete/{id}', name: 'app_theme_delete')]
  56.     public function delete(Request $request, ThemeRepository $themeRepository, $id,  EntityManagerInterface $entityManager): Response
  57.     {
  58.         $theme = $themeRepository->find($id);
  59.         if (!$theme) {
  60.             return $this->json([
  61.                 'error' => 'Le thème spécifié n\'existe pas.'
  62.             ], Response::HTTP_NOT_FOUND);
  63.         }
  65.         $entityManager->remove($theme);
  66.         $entityManager->flush();
  68.         //redirect to list
  69.         return $this->redirectToRoute('app_theme_list');
  70.     }
  72.     #[Route('/theme/save', name: 'app_theme_save')]
  73.     public function saveData(Request $request, ThemeRepository $themeRepository, ThemeSousCategorieRepository $themeSousCategorieRepository): Response
  74.     {
  75.         $data = json_decode($request->getContent(), true);
  77.         $uniqueId = $data['ref'];
  79.         $existingTheme = $themeRepository->findOneBy(['ref' => $uniqueId]);
  81.         if ($existingTheme) {
  82.             return $this->json([
  83.                 'code' => 'error',
  84.                 'message' => 'non unique'
  85.             ]);
  86.         }
  88.         // Créer le répertoire s'il n'existe pas
  89.         $outputDirectory = $this->getParameter('kernel.project_dir') . '/public/theme/' . $uniqueId;
  90.         if (!file_exists($outputDirectory)) {
  91.             mkdir($outputDirectory, 0755, true);
  92.         }
  94.         $base64Image = $data['image'];
  95.         $outputFile = $outputDirectory . '/image.png';
  96.         $this->saveBase64AsImage($base64Image, $outputFile);
  98.         // Enregistrer toutes les miniatures non vides
  99.         $miniatures = $data['miniatures'];
  101.         foreach ($miniatures as $miniatureName => $base64Miniature) {
  102.             if (!empty($base64Miniature)) {
  103.                 $outputMiniatureFile = $outputDirectory . '/' . $miniatureName . '.png';
  104.                 $this->saveBase64AsImage($base64Miniature, $outputMiniatureFile);
  105.             }
  106.         }
  108.         // Convertir le tableau des positions en chaîne JSON
  109.         $textData = json_encode($data['positions']);
  112.         // Traiter les données reçues (sauvegarde en base de données, etc.)
  113.         $theme = new Theme();
  115.         $sousCategorieId = $data['sousCategorie'];
  116.         $sousCategorie = $themeSousCategorieRepository->find($sousCategorieId);
  118.         $theme->setRef($uniqueId);
  119.         $theme->setSoussCategorie($sousCategorie);
  120.         $theme->setImageData('theme/' . $uniqueId . '/image.png');
  121.         $theme->setTextData($textData);
  123.         // Vérifier si la miniature est présente avant de l'enregistrer
  124.         if (!empty($data['miniatures']['eco40'])) {
  125.             $theme->setEco40('theme/' . $uniqueId . '/eco40.png');
  126.         }
  128.         if (!empty($data['miniatures']['eco180'])) {
  129.             $theme->setEco180('theme/' . $uniqueId . '/eco180.png');
  130.         }
  132.         if (!empty($data['miniatures']['eco200'])) {
  133.             $theme->setEco200('theme/' . $uniqueId . '/eco200.png');
  134.         }
  136.         if (!empty($data['miniatures']['eco300'])) {
  137.             $theme->setEco300('theme/' . $uniqueId . '/eco300.png');
  138.         }
  140.         if (!empty($data['miniatures']['eco400'])) {
  141.             $theme->setEco400('theme/' . $uniqueId . '/eco400.png');
  142.         }
  144.         if (!empty($data['miniatures']['eco500'])) {
  145.             $theme->setEco500('theme/' . $uniqueId . '/eco500.png');
  146.         }
  148.         if (!empty($data['miniatures']['ecovin'])) {
  149.             $theme->setEcovin('theme/' . $uniqueId . '/ecovin.png');
  150.         }
  152.         $themeRepository->save($theme, true);
  154.         // Retourner une réponse JSON avec un message de succès
  155.         return $this->json([
  156.             'code' => 'ok',
  157.             'message' => 'Données sauvegardées avec succès
  158.         '
  159.         ]);
  160.     }
  162.     #[Route('/theme/save/manuelle', name: 'app_theme_save_manuelle')]
  163.     public function saveDataManuelle(Request $request, ThemeRepository $themeRepository, ThemeSousCategorieRepository $themeSousCategorieRepository): Response
  164.     {
  165.         $data = json_decode($request->getContent(), true);
  167.         $uniqueId = $data['ref'];
  169.         $theme = $themeRepository->findOneBy(['ref' => $uniqueId]);
  171.         // Créer le répertoire s'il n'existe pas
  172.         $outputDirectory = $this->getParameter('kernel.project_dir') . '/public/theme/' . $uniqueId;
  173.         if (!file_exists($outputDirectory)) {
  174.             mkdir($outputDirectory, 0755, true);
  175.         }
  177.         // Enregistrer toutes les miniatures non vides
  178.         $miniatures = $data['miniatures'];
  179.         foreach ($miniatures as $miniatureName => $base64Miniature) {
  180.             if (!empty($base64Miniature)) {
  181.                 $outputMiniatureFile = $outputDirectory . '/' . $miniatureName . '.png';
  182.                 $this->saveBase64AsImage($base64Miniature, $outputMiniatureFile);
  183.             }
  184.         }
  186.         if ($theme) {
  187.             // Si le thème existe déjà, mettez à jour ses miniatures
  188.             if (!empty($data['miniatures']['eco180'])) {
  189.                 $theme->setEco180('theme/' . $uniqueId . '/eco180.png');
  190.             }
  192.             if (!empty($data['miniatures']['eco200'])) {
  193.                 $theme->setEco200('theme/' . $uniqueId . '/eco200.png');
  194.             }
  196.             if (!empty($data['miniatures']['eco300'])) {
  197.                 $theme->setEco300('theme/' . $uniqueId . '/eco300.png');
  198.             }
  200.             if (!empty($data['miniatures']['eco400'])) {
  201.                 $theme->setEco400('theme/' . $uniqueId . '/eco400.png');
  202.             }
  204.             if (!empty($data['miniatures']['eco500'])) {
  205.                 $theme->setEco500('theme/' . $uniqueId . '/eco500.png');
  206.             }
  208.             if (!empty($data['miniatures']['ecovin'])) {
  209.                 $theme->setEcovin('theme/' . $uniqueId . '/ecovin.png');
  210.             }
  211.         } else {
  212.             // Si le thème n'existe pas, créez un nouveau thème
  213.             $theme = new Theme();
  215.             $sousCategorieId = $data['sousCategorie'];
  216.             $sousCategorie = $themeSousCategorieRepository->find($sousCategorieId);
  218.             $theme->setRef($uniqueId);
  219.             $theme->setSoussCategorie($sousCategorie);
  221.             // Convertir le tableau des positions en chaîne JSON
  222.             $textData = json_encode($data['positions']);
  223.             $theme->setTextData($textData);
  225.             $imageData = json_encode(($data['image']));
  226.             $theme->setImageData($imageData);
  228.             foreach ($miniatures as $miniatureName => $base64Miniature) {
  229.                 if (!empty($base64Miniature)) {
  230.                     $setterMethod = 'set' . ucfirst($miniatureName);
  231.                     $theme->$setterMethod('theme/' . $uniqueId . '/' . $miniatureName . '.png');
  232.                 }
  233.             }
  234.         }
  237.         //$base64Image = $data['image'];
  238.         //$outputFile = $outputDirectory . '/image.png';
  239.         //$this->saveBase64AsImage($base64Image, $outputFile);
  241.         //$theme->setImageData('theme/' . $uniqueId . '/image.png');
  243.         $themeRepository->save($theme, true);
  245.         // Retourner une réponse JSON avec un message de succès
  246.         return $this->json([
  247.             'code' => 'ok',
  248.             'message' => 'Données sauvegardées avec succès'
  249.         ]);
  250.     }
  253.     private function saveBase64AsImage($base64, $outputFile)
  254.     {
  255.         $data = base64_decode(preg_replace('#^data:image/\w+;base64,#i', '', $base64));
  256.         file_put_contents($outputFile, $data);
  257.     }
  261.     #[Route('/search/theme', name: 'app_theme_search', methods: ['GET'])]
  262.     public function search(Request $request, ThemeRepository $themeRepository): Response
  263.     {
  264.         $searchTerm = $request->query->get('search');
  266.         $themes = $themeRepository->findBySearchTerm($searchTerm);
  268.         return new Response($this->renderView('theme/_search_results.html.twig', [
  269.             'themes' => $themes,
  270.         ]));
  271.     }
  274.     #[Route('/{id}', name: 'app_theme_show', methods: ['GET'])]
  275.     public function show(Theme $theme): Response
  276.     {
  277.         return $this->render('theme/show.html.twig', [
  278.             'theme' => $theme,
  279.         ]);
  280.     }
  283. /*
  285.     #[Route('theme/moulinette', name: 'app_theme_moulinette', methods: ['GET'])]
  286.     public function moulinette(EntityManagerInterface $entityManager): Response
  287.     {
  288.         $themes = $entityManager->getRepository(Theme::class)
  289.             ->findThemesBySousCategorie('ANIMAUX CUTE');
  291.         $validation = []; // Initialisation de la variable de validation
  293.         foreach ($themes as $theme) {
  294.             $modifier = true; // Réinitialiser pour chaque thème
  295.             $data = json_decode($theme->getTextData(), true);
  297.             if ($data) {
  298.                 $count = count($data);
  299.                 $orientations = ["gauche", "droite", "centre"];
  300.                 for ($i = 0; $i < $count; $i++) {
  301.                     // Vérifier si 'orientationText' existe déjà avant de modifier
  302.                     if (!isset($data[$i]['orientationText'])) {
  303.                         $data[$i]['orientationText'] = $orientations[$i % 3];
  304.                     } else {
  305.                         $modifier = false;
  306.                     }
  307.                 }
  309.                 if ($modifier) {
  310.                     $theme->setTextData(json_encode($data));
  311.                     $entityManager->persist($theme);
  312.                 }
  314.                 // Stocker les informations de validation
  315.                 $validation[] = [
  316.                     'id' => $theme->getId(),
  317.                     'text_data' => json_encode($data),
  318.                     'modifie' => $modifier
  319.                 ];
  320.             }
  321.         }
  323.         //test validation
  324.         //dd($validation);
  326.         $entityManager->flush();
  328.         return new Response('terminé');
  329.     }
  330.     */
  331. }