src/Controller/DevController.php line 92

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Service\Mailer;
  6. use App\Service\Notifier;
  7. use App\Entity\Notification;
  8. use App\Entity\User;
  9. use App\Repository\UserRepository;
  10. use Doctrine\ORM\EntityManagerInterface;
  11. use Exception;
  12. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  13. use Symfony\Bundle\FrameworkBundle\Console\Application;
  14. use Symfony\Component\Console\Input\ArrayInput;
  15. use Symfony\Component\Console\Output\BufferedOutput;
  16. use Symfony\Component\Filesystem\Filesystem;
  17. use Symfony\Component\Finder\Finder;
  18. use Symfony\Component\Form\Extension\Core\Type\TextType;
  19. use Symfony\Component\HttpFoundation\RedirectResponse;
  20. use Symfony\Component\HttpFoundation\Request;
  21. use Symfony\Component\HttpFoundation\Response;
  22. use Symfony\Component\HttpKernel\KernelInterface;
  23. use Symfony\Component\Mailer\Exception\TransportExceptionInterface;
  24. use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
  25. use Symfony\Component\Routing\Annotation\Route;
  26. use Symfony\Contracts\Service\Attribute\Required;
  28. #[Route("/dev")]
  29. class DevController extends AbstractController
  30. {
  31.     const DUMP_PATH = '../var/dump/';
  33.     #[Required]
  34.     public KernelInterface $kernel;
  36.     #[Required]
  37.     public Filesystem $filesystem;
  39.     #[Required]
  40.     public EntityManagerInterface $entityManager;
  43.     /**
  44.      * Contrôles :
  45.      *  - Intégrité de la base de donnée : projets/porteurs orphelins ?
  46.      *  - Post import : projets/porteurs incomplet ?
  47.      *  - Chmod des dossiers principaux..
  48.      */
  49.     #[Route("/checkup", name: "dev.data.checkup")]
  50.     public function controls()
  51.     {
  52.         $this->secureIfProd();
  54.         // Remonté des config php
  55.         $phps = [
  56.             'memory_limit'          => false,
  57.             'upload_max_filesize'   => false,
  58.             'post_max_size'         => false,
  59.             'max_execution_time'    => false,
  60.             'max_input_time'        => false,
  61.             'disable_functions'     => false
  62.         ];
  63.         foreach($phps as $php => $state){
  64.             $phps[$php] = ini_get($php);
  65.         }
  67.         // Check des droits d'écriture
  68.         $dirs = [
  69.             'var'           => false,
  70.             'var/export'    => false,
  71.             'var/yarn'      => false,
  72.             'var/log'       => false,
  73.             'var/dump'      => false,
  74.             'var/cache'     => false,
  75.             'var/upload'    => false,
  76.             'public/upload' => false,
  77.         ];
  78.         foreach($dirs as $dir => $state){
  79.             $dirs[$dir] = is_dir('../'.$dir) && is_writable('../'.$dir);
  80.         }
  82.         return $this->render('dev/data/controls.html.twig', [
  83.             'infoPhp' => $phps,
  84.             'infoChmod' => $dirs,
  85.         ]);
  86.     }
  88.     /**
  89.      * Listing complet des utilisateurs
  90.      */
  91.     #[Route("/data", name: "dev.data.users")]
  92.     public function users(EntityManagerInterface $em)
  93.     {
  94.         $this->secureIfProd();
  96.         /** @var UserRepository $userRepository */
  97.         $userRepository = $em->getRepository(User::class);
  99.         $roles = $this->getParameter('security.role_hierarchy.roles');
  100.         $users = [];
  101.         foreach($roles as $role) {
  102.             $role = $role[0];
  103.             if ($role === 'ROLE_USER') {
  104.                 continue;
  105.             }
  106.             $users[$role] = $userRepository->findAllByRolesOrderByStructure([$role]);
  107.         }
  109.         // Limiter à 1000 utilisateurs par rôle
  110.         $rolesTruncated = [];       // Afficher un message au niveau des rôles correspondants
  111.         $maxUsersDisplayed = 1000;  // Nombre maximum
  112.         foreach($users as $role => $usersHavingRole) {
  113.             if (count($usersHavingRole) > $maxUsersDisplayed) {
  114.                 $users[$role] = array_slice($usersHavingRole, 0, $maxUsersDisplayed);
  115.                 $rolesTruncated []= $role;
  116.             }
  117.         }
  119.         $git = [
  120.             'time' => file_exists('../.git/index') ? filectime('../.git/index') : 0,
  121.             'hash' => file_exists('../.git/ORIG_HEAD') ? file_get_contents('../.git/ORIG_HEAD') : '',
  122.         ];
  125.         return $this->render('dev/data/users.html.twig', [
  126.             'usersByRole' => $users,
  127.             'infoGit' => $git,
  128.             'rolesTruncated' => $rolesTruncated,
  129.             'maxUsersDisplayed' => $maxUsersDisplayed,
  130.         ]);
  131.     }
  134.     /**
  135.      * Permet de se connecter "en tant que"..
  136.      */
  137.     #[Route("/login/{id}", name: "dev.data.login")]
  138.     public function login($id, EntityManagerInterface $em)
  139.     {
  140.         $this->secureIfProd();
  142.         $user = $em->getRepository(User::class)->find($id);
  144.         if ($user) {
  145.             /** @var User $user */
  146.             $providerKey = 'main'; // La clé du firewall
  147.             $token = new UsernamePasswordToken($user, $user->getPassword(), $providerKey, $user->getRoles());
  148.             $this->get('security.token_storage')->setToken($token);
  149.             $this->get('session')->set('_security_' . $providerKey, serialize($token));
  151.             // N'existe plus ?
  152.             // $event = new InteractiveLoginEvent($request, $token);
  153.             // $dispatcher->dispatch('security.interactive_login', $event);
  155.             $this->addFlash('success','Désormais connecté en tant que "' . $user->getEmail() . '", rôle "' . implode(',', $user->getRoles()) . '"');
  157.             return $this->redirectToRoute('home');
  158.         }
  160.         $this->addFlash('warning', 'Utilisateur introuvable..');
  162.         return $this->redirectToRoute('dev.data.users');
  163.     }
  165.     /**
  166.      * Gestion des bases de données
  167.      */
  168.     #[Route("/dbmanager", name: "dev.data.dbmanager")]
  169.     public function dbmanager(): Response
  170.     {
  171.         $this->secureIfProd();
  173.         $dumps = new Finder();
  174.         $dumps->sortByModifiedTime();
  175.         $dumps->reverseSorting();
  177.         if(!file_exists(self::DUMP_PATH)) {
  178.             mkdir(self::DUMP_PATH);
  179.         }
  181.         $files = [];
  182.         foreach ($dumps->files()->in(self::DUMP_PATH) as $dump) {
  184.             if(preg_match('/.lock$/', $dump->getFilename())) {
  185.                 continue;
  186.             }
  187.             if ($this->filesystem->exists(self::DUMP_PATH . $dump->getFilename() . '.lock')) {
  188.                 $import = new Finder();
  189.                 $import->name($dump->getFilename() . '.lock');
  190.                 foreach ($import->in(self::DUMP_PATH) as $file) {
  191.                     $dump->import = (New \DateTime())->setTimestamp($file->getATime())->format('d/m/Y \\à H:i');
  192.                 }
  193.             } else {
  194.                 $dump->import = 'jamais';
  195.             }
  196.             $dump->filesize = $this->filesize($dump->getSize());
  197.             array_push($files, $dump);
  198.         }
  200.         $logs = [];
  201.         $dumps = new Finder();
  202.         $dumps->sortByModifiedTime();
  203.         $dumps->reverseSorting();
  204.         foreach ($dumps->files()->in('../var/log') as $log) {
  205.             $log->filesize = $this->filesize($log->getSize());
  206.             array_push($logs, $log);
  207.         }
  210.         return $this->render('dev/data/dbmanager.html.twig',[
  211.             'dumps' => $files,
  212.             'logs' => $logs,
  213.             'dbinfo' => $this->getDoctrine()->getConnection('default')->getParams()
  214.         ]);
  215.     }
  217.     /**
  218.      * Créer un dump
  219.      */
  220.     #[Route("/dbmanager/dump", name: "dev.data.dbmanager.dump")]
  221.     public function dump(Request $request): Response
  222.     {
  223.         $this->secureIfProd();
  225.         if ($request->getMethod() === 'GET') {
  226.             $form = $this->createFormBuilder()
  227.                 ->add('name', TextType::class, [
  228.                     'label' => 'Nom du dump',
  229.                     'required' => true
  230.                 ])
  231.                 ->getForm();
  233.             if ($request->isXmlHttpRequest()) {
  234.                 return $this->render('dev/data/partials/_create_dump.html.twig', [
  235.                     'form' => $form->createView()
  236.                 ]);
  237.             }
  238.         }
  240.         if ($request->getMethod() === 'POST') {
  241.             $form = $this->createFormBuilder()
  242.                 ->setMethod('POST')
  243.                 ->add('name', TextType::class, [
  244.                     'label' => 'Nom du dump',
  245.                     'required' => true
  246.                 ])
  247.                 ->getForm();
  249.             $form->handleRequest($request);
  251.             if ($form->isSubmitted() && $form->isValid()) {
  252.                 $name = strtolower(str_replace(' ', '_', $request->request->get('form')['name']));
  253.                 $filename = self::DUMP_PATH . $name . '.sql';
  255.                 if ($this->filesystem->exists($filename)) {
  256.                     $this->addFlash('icon@danger', 'Le nom de fichier existe déjà');
  257.                     return $this->redirectToRoute('dev.data.dbmanager');
  258.                 }
  260.                 $cfg = $this->getDoctrine()->getConnection('default')->getParams();
  262.                 try {
  263.                     passthru('mysqldump -h '.$cfg['host'].' -u'.$cfg['user'].' -p'.$cfg['password'].' '.$cfg['dbname'].' > '.$filename);
  264.                     if ($this->filesystem->exists($filename)) {
  265.                         $this->addFlash('icon@success', 'Dump effectué avec succès.');
  266.                     }
  267.                 } catch (Exception $exception){
  268.                     $this->addFlash('icon@danger', "Une erreur s'est produite.. : ".$exception->getMessage());
  269.                 }
  270.             }
  271.         }
  273.         return $this->redirectToRoute('dev.data.dbmanager');
  274.     }
  276.     /**
  277.      * Gestion des bases de données
  278.      */
  279.     #[Route("/dbmanager/download/{filename}", name: "dev.data.dbmanager.download")]
  280.     public function downloadDB(string $filename): Response
  281.     {
  282.         $this->secureIfProd();
  284.         $filename = self::DUMP_PATH . $filename;
  286.         if ($this->filesystem->exists($filename)) {
  288.             return $this->file($filename);
  289.         }
  291.         $this->addFlash('icon@danger', 'Fichier introuvable');
  293.         return $this->redirectToRoute('dev.data.dbmanager');
  294.     }
  296.     /**
  297.      * Téléchargement d'un fichier de log
  298.      */
  299.     #[Route("/dbmanager/log/download/{filename}", name: "dev.data.log.download")]
  300.     public function downloadLogFile(string $filename): Response
  301.     {
  302.         $this->secureIfProd();
  304.         $pathFile = '../var/log/' . $filename;
  306.         if ($this->filesystem->exists($pathFile) && preg_match('/^[0-9a-z\-\_]+\.log$/', $filename)) {
  308.             return $this->file($pathFile);
  309.         }
  311.         $this->addFlash('icon@danger', 'Fichier introuvable');
  313.         return $this->redirectToRoute('dev.data.dbmanager');
  314.     }
  316.     /**
  317.      * Suppression d'un fichier de log
  318.      */
  319.     #[Route("/dbmanager/log/remove/{filename}", name: "dev.data.log.remove")]
  320.     public function removeLogFile(string $filename): Response
  321.     {
  322.         $this->secureIfProd();
  324.         $pathFile = '../var/log/' . $filename;
  326.         if ($this->filesystem->exists($pathFile) && preg_match('/^[0-9a-z\-\_]+\.log$/', $filename)) {
  327.             $this->filesystem->remove($pathFile);
  328.             $this->addFlash('icon@success', 'Fichier supprimé avec succès');
  329.         } else {
  330.             $this->addFlash('icon@danger', 'Fichier introuvable');
  331.         }
  333.         return $this->redirectToRoute('dev.data.dbmanager');
  334.     }
  336.     /**
  337.      * Gestion des bases de données
  338.      */
  339.     #[Route("/dbmanager/{filename}/import", name: "dev.data.dbmanager.import")]
  340.     public function import(string $filename): Response
  341.     {
  342.         $this->secureIfProd();
  344.         $filename = self::DUMP_PATH . $filename;
  346.         $env = $this->getParameter('kernel.environment');
  347.         if($env == 'prod'){
  348.             $this->addFlash('icon@danger', 'Import impossible en mode Production..');
  349.             return $this->redirectToRoute('dev.data.dbmanager');
  350.         }
  352.         if ($this->filesystem->exists($filename)) {
  353.             // création du fichier de lock pour les informations de dernier import
  354.             $this->filesystem->touch( $filename . '.lock');
  356.             $cfg = $this->getDoctrine()->getConnection('default')->getParams();
  358.             passthru('mysql -h '.$cfg['host'].' -u'.$cfg['user'].' -p'.$cfg['password'].' '.$cfg['dbname'].' < '.$filename);
  360.             $this->addFlash('icon@success', 'Le dump '. $filename .' a correctement été importé dans votre base de données');
  362.             return $this->redirectToRoute('dev.data.dbmanager');
  363.         }
  365.         $this->addFlash('icon@danger', 'Fichier introuvable');
  367.         return $this->redirectToRoute('dev.data.dbmanager');
  368.     }
  370.     /**
  371.      * Affiche les 40 derniéres notifications
  372.      */
  373.     #[Route("/notifications", name: "dev.data.notifications")]
  374.     public function notifications(): Response
  375.     {
  376.         $this->secureIfProd();
  378.         return $this->render('dev/data/notifications.html.twig',[
  379.             'notifications' => $this->entityManager->getRepository(Notification::class)->findByNumber(200)
  380.         ]);
  381.     }
  383.     /**
  384.      * Affiche les templates des emails envoyé (objet/body)
  385.      */
  386.     #[Route("/notifications-templates", name: "dev.data.notifications.templates")]
  387.     public function showEmailsTemplate(): Response
  388.     {
  389.         $this->secureIfProd();
  391.         $templates = [];
  393.         $files = scandir('../templates/notification/email');
  394.         foreach($files as $file){
  395.             if($file[0] == '.' || $file == 'base.html.twig'){
  396.                 continue;
  397.             }
  399.             $raw = file_get_contents('../templates/notification/email/'.$file);
  401.             $subject = 'unknown';
  402.             $body    = 'unknown';
  404.             if(preg_match('#\{\% block subject \%\}(.*)\{\% endblock \%\}#isU', $raw, $match)){
  405.                 $subject = $match[1];
  406.             }
  407.             if(preg_match('#\{\% block body \%\}(.*)\{\% endblock \%\}#isU', $raw, $match)){
  408.                 $body = $match[1];
  409.             }
  411.             $templates[] = [
  412.                 'file' => $file,
  413.                 'subject' => $subject,
  414.                 'body' => $body
  415.             ];
  416.         }
  418.         return $this->render('dev/data/notifications-templates.html.twig',[
  419.             'templates' => $templates
  420.         ]);
  421.     }
  423.     /**
  424.      * Envoie les emails de notification sans passer par la commande (pour les faignants !)
  425.      * alias de la commande `php bin/console app:send-mail-notifications`
  426.      */
  427.     #[Route("/notifications-send", name: "dev.data.notifications.send")]
  428.     public function runSendNotification(KernelInterface $kernel): Response
  429.     {
  430.         $this->secureIfProd();
  432.         $application = new Application($kernel);
  433.         $application->setAutoExit(false);
  435.         $input = new ArrayInput([
  436.             'command' => 'app:send-mail-notifications'
  437.         ]);
  439.         $output = new BufferedOutput();
  440.         $application->run($input, $output);
  442.         $content = $output->fetch();
  444.         $this->addFlash('success', $content);
  446.         return $this->redirectToRoute('dev.data.notifications');
  447.     }
  449.     /**
  450.      * PoC du gestionnaire de notifications
  451.      */
  452.     #[Route("/test-service-notifier", name: "dev.test.notifier")]
  453.     public function testServiceNotifier(Notifier $notifier, UserRepository $userRepository): RedirectResponse
  454.     {
  455.         $this->secureIfProd();
  457.         $user = $userRepository->findOneBy(['enabled' => 1]);
  459.         $notification = $notifier->createMail($user, 'resetting_password', [
  460.             'username' => $user->getNiceName(),
  461.             'confirmation_url' => 'https://www.google.fr'
  462.         ]);
  464.         $this->addFlash('success', 'Nouvelle notification créee : #' . $notification->getId());
  465.         return $this->redirectToRoute('dev.data.notifications');
  466.     }
  468.     /**
  469.      * Envoi un email de test :
  470.      * http://symfony5.test/dev/test-mailer/mpommie@nowdigital.fr
  471.      */
  472.     #[Route("/test-mailer/{email}", name: "dev.test.mailer")]
  473.     public function testMailer(string $email, Mailer $mailer): RedirectResponse
  474.     {
  475.         $this->secureIfProd();
  477.         try {
  479.             $state = $mailer->send(
  480.                 $email,
  481.                 'Test mailing plateforme SYMFONY5',
  482.                 '<p><strong>Ceci est un test</strong> en <u>HTML</u></p>',
  483.                 ['debug' => true]
  484.             );
  486.             $this->addFlash($state ? 'success' : 'danger', 'Test mailing : ' . ($state ? 'Success' : 'Error'));
  488.         } catch (Exception $e) {
  489.             $this->addFlash('danger', $e->getMessage());
  490.         } catch (TransportExceptionInterface $e) {
  491.             $this->addFlash('danger', $e->getMessage());
  492.         }
  494.         return $this->redirectToRoute('dev.data.users');
  495.     }
  497.     /**
  498.      * Helper : Formate la taille des fichiers
  499.      *
  500.      * @param $bytes
  501.      * @param int $decimals
  502.      * @return string
  503.      */
  504.     private function filesize($bytes, $decimals = 2) {
  505.         $sz = 'BKMGTP';
  506.         $factor = floor((strlen($bytes) - 1) / 3);
  507.         return sprintf("%.{$decimals}f", $bytes / pow(1024, $factor)) . @$sz[$factor];
  508.     }
  510.     /**
  511.      * Voir configuration dans le .env
  512.      * - DEV_DATA_LOGIN
  513.      * - DEV_DATA_PASSWORD
  514.      */
  515.     private function secureIfProd()
  516.     {
  517.         // Exception pour la plateforme de livraison Groupement, déjà équipée d'un htaccess mais en env=Prod
  518.         if($_SERVER['HTTP_HOST'] == 'symfony5-recette.nowdigital.fr'){
  519.             return true;
  520.         }
  522.         if(isset($_COOKIE['key']) && md5($_COOKIE['key']) == '5bc75bd65c17d97b41c50caeeadaa47a'){
  523.             return true;
  524.         }
  526.         $env = $this->getParameter('kernel.environment');
  527.         $login = $this->getParameter('dev_data_login');
  528.         $password = $this->getParameter('dev_data_password');
  530.         if ($env !== 'dev' && !preg_match('/(nowdigital.fr|\.test)$/i', $_SERVER['HTTP_HOST'])) {
  531.             if (!isset($_SERVER['PHP_AUTH_USER']) || $_SERVER['PHP_AUTH_USER'] != $login || !isset($_SERVER['PHP_AUTH_PW']) || $_SERVER['PHP_AUTH_PW'] != $password) {
  532.                 header('WWW-Authenticate: Basic realm="HTACCESS"');
  533.                 header('HTTP/1.0 401 Unauthorized');
  534.                 exit;
  535.             }
  536.         }
  537.     }
  538. }