From f27cca08ff786ceff1870147f6d6bad14d71117f Mon Sep 17 00:00:00 2001 From: polo Date: Fri, 23 Oct 2026 00:47:32 +0200 Subject: =?UTF-8?q?dossiers=20avec=20majuscule,=20namespace=20pour=20toute?= =?UTF-8?q?s=20les=20classes,=20autoload=20psr-4,=20UserDataService::creat?= =?UTF-8?q?eZip=20d=C3=A9plac=C3=A9=20dans=20Backup?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/Controller/ArticleController.php | 244 ++++++++++++++++++ src/Controller/CalendarController.php | 77 ++++++ src/Controller/ContactFormController.php | 107 ++++++++ src/Controller/FileUploadController.php | 68 +++++ src/Controller/HeadFootController.php | 146 +++++++++++ src/Controller/ImageUploadController.php | 194 +++++++++++++++ src/Controller/MaintenanceController.php | 152 ++++++++++++ src/Controller/MenuAndPathsController.php | 226 +++++++++++++++++ src/Controller/PageManagementController.php | 368 ++++++++++++++++++++++++++++ src/Controller/UserController.php | 237 ++++++++++++++++++ src/Controller/ViewController.php | 70 ++++++ 11 files changed, 1889 insertions(+) create mode 100644 src/Controller/ArticleController.php create mode 100644 src/Controller/CalendarController.php create mode 100644 src/Controller/ContactFormController.php create mode 100644 src/Controller/FileUploadController.php create mode 100644 src/Controller/HeadFootController.php create mode 100644 src/Controller/ImageUploadController.php create mode 100644 src/Controller/MaintenanceController.php create mode 100644 src/Controller/MenuAndPathsController.php create mode 100644 src/Controller/PageManagementController.php create mode 100644 src/Controller/UserController.php create mode 100644 src/Controller/ViewController.php (limited to 'src/Controller') diff --git a/src/Controller/ArticleController.php b/src/Controller/ArticleController.php new file mode 100644 index 0000000..075e3b4 --- /dev/null +++ b/src/Controller/ArticleController.php @@ -0,0 +1,244 @@ +query->has('id') && !empty($request->query->get('id')) && $request->query->has('last_article')){ + $id = (int)$request->get('id'); // type et nettoie + $model = new Model($entityManager); + $model->findNodeById($id); + $parent_block = $model->getNode(); + + if(Presentation::hasPresentation($parent_block->getName())){ + $get_articles_return = $model->getNextArticles($parent_block, $request); + $bulk_data = $get_articles_return[0]; + + if($parent_block->getName() === 'post_block'){ + $builder_name = 'App\View\PostBuilder'; + } + elseif($parent_block->getName() === 'news_block'){ + $builder_name = 'App\View\NewBuilder'; + } + else{ + return new JsonResponse(['success' => false, 'error' => 'server side error'], JsonResponse::HTTP_INTERNAL_SERVER_ERROR); + } + + $html = ''; + foreach($bulk_data as $article){ + $builder = new $builder_name($article); + $html .= $builder->render(); + } + + return new JsonResponse(['success' => true, 'html' => $html, 'truncated' => $get_articles_return[1]]); + } + else{ + return new JsonResponse(['success' => false, 'error' => 'server side error'], JsonResponse::HTTP_INTERNAL_SERVER_ERROR); + } + } + else{ + return new JsonResponse(['success' => false, 'error' => 'bad parameters'], JsonResponse::HTTP_BAD_REQUEST); + } + } + + static public function editorSubmit(EntityManager $entityManager, array $json): JsonResponse + { + if(json_last_error() === JSON_ERROR_NONE){ + $id = $json['id']; + if(in_array($id[0], ['t', 'p', 'i', 'd'])){ + $id = substr($id, 1); + } + + $model = new Model($entityManager); + $content = $json['content']; + + // nettoyage + if(is_array($content)){ // cas d'une nouvelle "news" + foreach($content as $one_input){ + $one_input = Security::secureHTML($one_input); + } + } + else{ // autres cas + $content = Security::secureHTML($json['content']); + } + + // nouvel article + if($json['id'][0] === 'n'){ // ici $id est un bloc + $section_id = (int)substr($id, 1); // id du bloc
+ if(!$model->findNodeById($section_id)){ // erreur mauvais id + return new JsonResponse(['success' => false, 'error' => 'article_not_saved, bad id']); + } + $model->makeSectionNode(); + $section = $model->getNode(); + + // ajout d'une news + if(is_array($content)){ + if($section->getPage()->getEndOfPath() !== $json['from']){ // erreur mauvais from + return new JsonResponse(['success' => false, 'error' => 'article_not_saved, bad from']); + } + + $date = new \DateTime($content['d'] . ':' . (new \DateTime)->format('s')); // l'input type="datetime-local" ne donne pas les secondes, on les ajoute: 'hh:mm' . ':ss' + $article = new Article($content['i'], $date, $content['t'], $content['p']); + $article_node = new Node('new', count($section->getChildren()) + 1, $section, $section->getPage(), $article); + } + // ajout d'un post + else{ + $timestamp = time(); + $date = new \DateTime; + $date->setTimestamp($timestamp); + + $article = new Article($content, $date); + $placement = $json['placement'] === 'first' ? 0 : count($section->getChildren()) + 1; // + $article_node = new Node('post', $placement, $section, $section->getPage(), $article); + + if($json['placement'] === 'first'){ + $section->addChild($article_node); + $section->sortChildren(true); // mettre $article_node au début du tableau puis régénérer les positions (0 devient 1, 1 devient 2...) + } + } + + $entityManager->persist($article_node); + $entityManager->flush(); + + return new JsonResponse(['success' => true, 'article_id' => $article_node->getId()]); + } + // modification article + //else{} + + if($model->makeArticleNode($id)){ // une entrée est trouvée + $node = $model->getArticleNode(); + switch($json['id'][0]){ + case 'i': + $node->getArticle()->setContent($content); + break; + case 'p': + $node->getArticle()->setPreview($content); // html de l'éditeur + break; + case 't': + $node->getArticle()->setTitle($content); // html de l'éditeur + break; + case 'd': + return new JsonResponse(['success' => false, 'message' => 'l\'action editor_submit ne supporte pas les dates, utiliser date_submit.']); + default: // modif article simple (id sans lettre devant) + $node->getArticle()->setContent($content); + } + $entityManager->flush(); + return new JsonResponse(['success' => true]); + } + else{ + return new JsonResponse(['success' => false, 'message' => 'article non identifié']); + } + } + else{ + return new JsonResponse(['success' => false, 'message' => 'Erreur de décodage JSON']); + } + } + + static public function deleteArticle(EntityManager $entityManager, Request $request): Response + { + $model = new Model($entityManager); + + if($request->headers->get('Content-Type') === 'application/json'){ + $id = json_decode($request->getContent(), true)['id']; + } + elseif($request->headers->get('Content-Type') === 'application/x-www-form-urlencoded'){ + $id = $request->query->get('id'); + } + // ni JSON ni form, c'est quoi? un POST vide? + else{ + return new Response('la méthode deleteArticle ne peut être appelée de cette manière'); + } + + if(!$model->makeArticleNode($id, true)){ + $params = ['false', "Erreur 500 pas d\'article à supprimer"]; + } + else{ + $article = $model->getArticleNode(); + $section = $model->getNode(); + + $entityManager->remove($article); + $section->removeChild($article); + $section->sortChildren(true); // régénère les positions + + try{ + $entityManager->flush(); + $params = ['true', 'Article supprimé avec succès']; + } + catch(\Exception $e){ + $params = ['false', 'Erreur 500 ' . $e->getMessage()]; + } + } + + if($request->headers->get('Content-Type') === 'application/json'){ + return new JsonResponse( + ['success' => $params[0], 'message' => $params[1]], + $params[0] ? JsonResponse::HTTP_OK : JsonResponse::HTTP_INTERNAL_SERVER_ERROR + ); + } + elseif($request->headers->get('Content-Type') === 'application/x-www-form-urlencoded'){ + $url = new URL(['page' => $request->query->get('from') ?? '', 'success' => $params[0], 'message' => $params[1]]); + return new RedirectResponse((string)$url); + } + else{ + // cas inaccesible + throw new \Exception('la méthode deleteArticle ne peut être appelée de cette manière'); + } + } + + static public function switchPositions(EntityManager $entityManager, array $json): JsonResponse + { + $model = new Model($entityManager); + $model->makeArticleNode($json['id1'], true); + $article1 = $model->getArticleNode(); + $section = $model->getNode(); + + $section->sortChildren(true); // régénère les positions avant inversion + $article2 = null; + foreach($section->getChildren() as $child){ + if((string)$child->getId() === $json['id2']) // type string + { + $article2 = $child; + break; + } + } + + // inversion + $tmp = $article1->getPosition(); + $article1->setPosition($article2->getPosition()); + $article2->setPosition($tmp); + $entityManager->flush(); + + return new JsonResponse(['success' => true]); + } + + static public function dateSubmit(EntityManager $entityManager, array $json): JsonResponse + { + $id = substr($json['id'], 1); + $date = new \DateTime($json['date']); + + $model = new Model($entityManager); + $model->makeArticleNode($id); + $node = $model->getArticleNode(); + $node->getArticle()->setDateTime($date); + $entityManager->flush(); + + return new JsonResponse(['success' => true]); + } +} \ No newline at end of file diff --git a/src/Controller/CalendarController.php b/src/Controller/CalendarController.php new file mode 100644 index 0000000..679ff8a --- /dev/null +++ b/src/Controller/CalendarController.php @@ -0,0 +1,77 @@ +setTimezone(new \DateTimeZone('UTC')); + $end->setTimezone(new \DateTimeZone('UTC')); + + // affichage format ISO à l'heure UTC + //$date->format('Y-m-d\TH:i:s\Z'); + + // on prend les évènements se finissant après le début ou commençant avant la fin de la fourchette + $dql = 'SELECT e FROM App\Entity\Event e WHERE e.end >= :start AND e.start <= :end'; + $bulk_data = $entityManager->createQuery($dql) + ->setParameter('start', $start) + ->setParameter('end', $end) + ->getResult(); + + $events = []; + foreach($bulk_data as $one_entry){ + $event = new EventDTO($one_entry); + $events[] = $event->toArray(); + } + + return new JsonResponse($events); + } + + static public function newEvent(array $json, EntityManager $entityManager): JsonResponse + { + try{ + $event = new Event($json); + } + catch(\InvalidArgumentException $e){ + return new JsonResponse(['success' => false, 'error' => $e->getMessage()], JsonResponse::HTTP_BAD_REQUEST); // code 400 + } + $entityManager->persist($event); + $entityManager->flush(); + + return new JsonResponse(['success' => true, 'id' => $event->getId()]); + } + static public function updateEvent(array $json, EntityManager $entityManager): JsonResponse + { + $event = $entityManager->find('App\Entity\Event', (int)$json['id']); + try{ + $event->securedUpdateFromJSON($json); + } + catch(\InvalidArgumentException $e){ + return new JsonResponse(['success' => false, 'error' => $e->getMessage()], JsonResponse::HTTP_BAD_REQUEST); // code 400 + } + $entityManager->flush(); + + return new JsonResponse(['success' => true]); + } + static public function removeEvent(array $json, EntityManager $entityManager): JsonResponse + { + $event = $entityManager->find('App\Entity\Event', (int)$json['id']); + $entityManager->remove($event); + $entityManager->flush(); + + return new JsonResponse(['success' => true]); + } +} \ No newline at end of file diff --git a/src/Controller/ContactFormController.php b/src/Controller/ContactFormController.php new file mode 100644 index 0000000..56ef402 --- /dev/null +++ b/src/Controller/ContactFormController.php @@ -0,0 +1,107 @@ +find(EmailForm::class, $json['id']); + $form_data->updateData('keep_emails', $json['checked'] ? true : false); + $entityManager->persist($form_data); + $entityManager->flush(); + return new JsonResponse(['success' => true, 'checked' => $json['checked']]); + } + static public function setEmailsRetentionPeriod(EntityManager $entityManager, array $json): JsonResponse + { + $form_data = $entityManager->find(EmailForm::class, $json['id']); + $form_data->updateData($json['field'], (int)$json['months']); + $entityManager->persist($form_data); + $entityManager->flush(); + return new JsonResponse(['success' => true, 'months' => $json['months']]); + } + static public function setEmailParam(EntityManager $entityManager, array $json): JsonResponse + { + $form = new FormValidation($json, ValidationStrategy::EmailParam); + + if($form->validate()){ + $form_data = $entityManager->find(EmailForm::class, $json['id']); + $form_data->updateData($json['what_param'], trim($json['value'])); + $entityManager->persist($form_data); // ?? + $entityManager->flush(); + return new JsonResponse(['success' => true]); + } + else{ + return new JsonResponse(['success' => false, 'error' => $form->getError()]); + } + } + + // les deux méthodes suivantes sont "factorisables", elles ne se distinguent que par la gestion ou non du formulaire rempli par le visiteur + static public function sendVisitorEmail(EntityManager $entityManager, array $json): JsonResponse + { + $form = new FormValidation($json, ValidationStrategy::EmailSend); + + $error = ''; + if($form->validate()){ + // destinataire = e-mail par défaut dans config.ini OU choisi par l'utilisateur + $form_data = $entityManager->find(EmailForm::class, $json['id']); + if($form_data === null){ + return new JsonResponse(['success' => false, 'error' => 'server_error'], JsonResponse::HTTP_INTERNAL_SERVER_ERROR); // code 500 + } + + if(!EmailService::send($entityManager, $form_data, false, $form->getField('name'), $form->getField('email'), $form->getField('message'))){ + $error = 'email_not_sent'; + } + } + else{ + $error = $form->getError(); + } + + if(empty($error)){ + return new JsonResponse(['success' => true]); + } + else{ + return new JsonResponse(['success' => false, 'error' => $error]); + } + } + static public function sendTestEmail(EntityManager $entityManager, array $json): JsonResponse + { + // destinataire = e-mail par défaut dans config.ini OU choisi par l'utilisateur + $form_data = $entityManager->find(EmailForm::class, $json['id']); + if($form_data === null){ + return new JsonResponse(['success' => false, 'error' => 'server_error'], JsonResponse::HTTP_INTERNAL_SERVER_ERROR); + } + + if(EmailService::send($entityManager, $form_data, true, 'nom du visiteur', 'adresse@du_visiteur.fr', "TEST d'un envoi d'e-mail depuis le site web")){ + return new JsonResponse(['success' => true]); + } + else{ + return new JsonResponse(['success' => false, 'error' => 'email_not_sent']); + } + } + static public function deleteEmail(EntityManager $entityManager, array $json): JsonResponse + { + $email = $entityManager->find(Email::class, $json['id']); + $entityManager->remove($email); + $entityManager->flush(); + return new JsonResponse(['success' => true]); + } + static public function toggleSensitiveEmail(EntityManager $entityManager, array $json): JsonResponse + { + $email = $entityManager->find(Email::class, $json['id']); + $email->makeSensitive($json['checked']); + $entityManager->flush(); + return new JsonResponse(['success' => true, 'checked' => $json['checked'], 'deletion_date' => $email->getDeletionDate()->format('d/m/Y')]); + } +} \ No newline at end of file diff --git a/src/Controller/FileUploadController.php b/src/Controller/FileUploadController.php new file mode 100644 index 0000000..4627017 --- /dev/null +++ b/src/Controller/FileUploadController.php @@ -0,0 +1,68 @@ + $file_path]); + } + else{ + return new JsonResponse(['message' => 'Erreur enregistrement du fichier.'], JsonResponse::HTTP_INTERNAL_SERVER_ERROR); // code 500 + } + } + else{ + return new JsonResponse(['message' => 'Erreur 400: fichier non valide.'], JsonResponse::HTTP_BAD_REQUEST); // code 400 + } + } + else{ + return new JsonResponse(['message' => 'Erreur 400: Bad Request'], JsonResponse::HTTP_BAD_REQUEST); // code 400 + } + } +} \ No newline at end of file diff --git a/src/Controller/HeadFootController.php b/src/Controller/HeadFootController.php new file mode 100644 index 0000000..e39c07b --- /dev/null +++ b/src/Controller/HeadFootController.php @@ -0,0 +1,146 @@ + false]); + } + + $model = new Model($entityManager); + if($model->findWhateverNode('name_node', $params_array[0])){ + $node_data = $model->getNode()->getNodeData(); + + // liens réseaux sociaux + if(in_array($params_array[1], NodeData::$social_networks)){ + $social = $node_data->getData()['social'] ?? []; + $social[$params_array[1]] = $json['new_text']; + $node_data->updateData('social', $social); + } + // autres textes + else{ + $node_data->updateData($params_array[1], $json['new_text']); // $params_array[1] n'est pas contrôlé + } + + $entityManager->flush(); + return new JsonResponse(['success' => true]); + } + else{ + return new JsonResponse(['success' => false]); + } + } + static public function uploadAsset(EntityManager $entityManager, string $request_params): JsonResponse + { + if(empty($_FILES)){ + return new JsonResponse(['success' => false], JsonResponse::HTTP_BAD_REQUEST); // code 400 + } + else{ + if(!is_dir(Asset::USER_PATH)){ + mkdir(Asset::USER_PATH, 0777, true); + } + + /* -- téléchargement -- */ + $file = $_FILES['file']; + $allowed_extensions = ['jpg', 'jpeg', 'png', 'gif', 'webp', 'tiff', 'tif', 'ico', 'bmp']; // pas de SVG + $extension = strtolower(pathinfo($file['name'], PATHINFO_EXTENSION)); + if(!in_array($extension, $allowed_extensions) || $extension === 'jpg'){ + $extension = 'jpeg'; + } + $mime_type = mime_content_type($file['tmp_name']); + $hash = hash_file('sha256', $file['tmp_name']); + + /* -- instance d'Asset -- */ + $model = new Model($entityManager); + $result = $model->getWhatever('App\Entity\Asset', 'hash', $hash); + + if(count($result) > 0){ // asset existant trouvé + $asset = $result[0]; + + // correction des informations + $name = $asset->getFileName(); // permet à priori de réécrire par dessus le précédent fichier + //$asset->setFileName($name); + $asset->setMimeType($mime_type); + } + else{ + $name = Security::secureFileName(pathinfo($file['name'], PATHINFO_FILENAME)); + $name = uniqid($name . '_') . '.' . $extension; + $asset = new Asset($name, $mime_type, $hash); + } + + /* -- écriture du fichier sur le disque -- */ + if(!ImageUploadController::imagickCleanAndWriteImage(file_get_contents($file['tmp_name']), Asset::USER_PATH . $name)){ // recréer l’image pour la nettoyer + return new JsonResponse(['success' => false, 'message' => "Erreur de l'enregistrement de l'image: problème de permission ou format non valide.", 'format' => $extension], JsonResponse::HTTP_INTERNAL_SERVER_ERROR); // code 500 + } + else{ + $params_array = explode('_', $request_params); // head_favicon, header_logo, header_background, footer_logo + + /* -- table intermédiaire node_data/asset-- */ + if($model->findWhateverNode('name_node', $params_array[0])){ // noeud (head, header ou footer) + $node_data = $model->getNode()->getNodeData(); + + // recherche à l'aide du rôle + $old_nda = null; + foreach($node_data->getNodeDataAssets() as $nda){ + if($nda->getRole() === $request_params){ + $old_nda = $nda; + $old_nda->setAsset($asset); + break; + } + } + // entrée pas trouvée + if($old_nda === null){ + $new_nda = new AssetEmployment($node_data, $asset, $request_params); // $request_params sera le rôle de l'asset + $entityManager->persist($new_nda); + } + + if(count($result) === 0){ + $entityManager->persist($asset); + } + $entityManager->flush(); + return new JsonResponse(['success' => true, 'location' => Asset::USER_PATH . $name, 'mime_type' => $mime_type]); + } + else{ + return new JsonResponse(['success' => false, 'message' => "Erreur noeud non trouvé, c'est pas du tout normal!"], JsonResponse::HTTP_INTERNAL_SERVER_ERROR); // code 500 + } + } + } + } + + static public function displaySocialNetwork(EntityManager $entityManager, string $request_params, array $json): JsonResponse + { + $params_array = explode('_', $request_params); + if(count($params_array) !== 2){ + return new JsonResponse(['success' => false]); + } + + $model = new Model($entityManager); + if(in_array($params_array[1], NodeData::$social_networks) && $model->findWhateverNode('name_node', $params_array[0])){ + $node_data = $model->getNode()->getNodeData(); + $social_show = $node_data->getData()['social_show'] ?? []; + $social_show[$params_array[1]] = $json['checked']; + $node_data->updateData('social_show', $social_show); + + $entityManager->flush(); + return new JsonResponse(['success' => true, 'checked' => $json['checked']]); + } + else{ + return new JsonResponse(['success' => false]); + } + } +} \ No newline at end of file diff --git a/src/Controller/ImageUploadController.php b/src/Controller/ImageUploadController.php new file mode 100644 index 0000000..4ca9f48 --- /dev/null +++ b/src/Controller/ImageUploadController.php @@ -0,0 +1,194 @@ +readImageBlob($image_data); + $imagick->stripImage(); // nettoyage métadonnées + //$imagick->setImageFormat($format); // inutile, writeImage force la conversion + + // compression + switch($format){ + case 'jpeg': // particularité du switch, si 'jpeg' le test de 'jpg' est ignoré et on va jusqu'au break + case 'jpg': + $imagick->setImageCompression(\Imagick::COMPRESSION_JPEG); + $imagick->setImageCompressionQuality(85); + break; + case 'webp': + $imagick->setImageCompression(\Imagick::COMPRESSION_WEBP); + $imagick->setImageCompressionQuality(85); + break; + case 'png': + $imagick->setImageCompression(\Imagick::COMPRESSION_ZIP); + $imagick->setImageCompressionQuality(7); // 9 est sans perte + break; + case 'tiff': + $imagick->setImageCompression(\Imagick::COMPRESSION_LZW); // LZW est sans perte + break; + } + + // enregistrement + // writeImage utilise l'extension du fichier et ignore le format détecté + // imagemagick est à l'origine une appli console, elle considère que l'extension montre l'intention de l'utilisateur + $imagick->writeImage($local_path); // enregistrement + $imagick->clear(); + $imagick->destroy(); + return true; + } + catch(\Exception $e){ + return false; + } + } + static public function curlDownloadImage(string $url, int $maxRetries = 3, int $timeout = 10): string|false + { + $attempt = 0; + $imageData = false; + + while($attempt < $maxRetries){ + $ch = curl_init($url); // instance de CurlHandle + curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); + curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true); + curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $timeout); + curl_setopt($ch, CURLOPT_TIMEOUT, $timeout); + curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true); + curl_setopt($ch, CURLOPT_USERAGENT, 'TinyMCE-Image-Downloader'); + + $imageData = curl_exec($ch); + $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE); + //$curlError = curl_error($ch); + + if($imageData !== false && $httpCode >= 200 && $httpCode < 300){ + return $imageData; + } + + $attempt++; + sleep(1); + } + + return false; // échec après trois tentatives + } + + // téléchargement par le plugin (bouton "insérer une image") + static public function imageUploadTinyMce(): JsonResponse + { + if(!isset($_FILES['file'])){ + return new JsonResponse(['message' => 'Erreur 400: Bad Request'], JsonResponse::HTTP_BAD_REQUEST); // code 400 + } + if(!is_uploaded_file($_FILES['file']['tmp_name'])) { + return new JsonResponse(['message' => "Le fichier n'a pas été téléchargé correctement."], JsonResponse::HTTP_BAD_REQUEST); // code 400 + } + + $dest = 'user_data/images/'; + $dest_mini = 'user_data/images-mini/'; + + // Vérifier si les répertoires existent, sinon les créer + if(!is_dir($dest)){ + mkdir($dest, 0755, true); + } + if(!is_dir($dest_mini)){ + mkdir($dest_mini, 0755, true); + } + + $name = Security::secureFileName(pathinfo($_FILES['file']['name'], PATHINFO_FILENAME)); + $extension = strtolower(pathinfo($_FILES['file']['name'], PATHINFO_EXTENSION)); + $image_data = file_get_contents($_FILES['file']['tmp_name']); + if(!in_array($extension, self::ALLOWED_EXTENSIONS)){ + $extension = 'jpeg'; + } + $local_path = uniqid($dest . $name . '_') . '.' . $extension; + + // créer une miniature de l'image + // + + if(self::imagickCleanAndWriteImage($image_data, $local_path)){ // recréer l’image pour la nettoyer + return new JsonResponse(['location' => $local_path]); // renvoyer l'URL de l'image téléchargée + } + else{ + return new JsonResponse(['message' => 'Erreur image non valide'], JsonResponse::HTTP_INTERNAL_SERVER_ERROR); // code 500 + } + } + + // collage de HTML => recherche de balises , téléchargement côté serveur et renvoi de l'adresse sur le serveur + static public function uploadImageHtml(): JsonResponse + { + $json = json_decode(file_get_contents('php://input'), true); + + if(!isset($json['image_url'])){ + return new JsonResponse(['message' => "Erreur 400: Bad Request"], JsonResponse::HTTP_BAD_REQUEST); // code 400 + } + + $image_data = self::curlDownloadImage($json['image_url']); // téléchargement de l’image par le serveur avec cURL au lieu de file_get_contents + if(!$image_data){ + return new JsonResponse(['message' => "Erreur, le serveur n'a pas réussi à télécharger l'image."], JsonResponse::HTTP_BAD_REQUEST); // code 400 + } + + $dest = 'user_data/images/'; + if(!is_dir($dest)){ // Vérifier si le répertoire existe, sinon le créer + mkdir($dest, 0755, true); + } + + $url_path = parse_url($json['image_url'], PHP_URL_PATH); + $name = Security::secureFileName(pathinfo($url_path, PATHINFO_FILENAME)); + $extension = strtolower(pathinfo($url_path, PATHINFO_EXTENSION)); + if(!in_array($extension, self::ALLOWED_EXTENSIONS) || $extension === 'jpg'){ + $extension = 'jpeg'; + } + $local_path = uniqid($dest . $name . '_') . '.' . $extension; + + if(self::imagickCleanAndWriteImage($image_data, $local_path)){ // recréer l’image pour la nettoyer + return new JsonResponse(['location' => $local_path]); // nouvelle adresse + } + else{ + return new JsonResponse(['message' => 'Erreur image non valide', 'format' => $extension], JsonResponse::HTTP_INTERNAL_SERVER_ERROR); // code 500 + } + } + + // collage simple d'une image (base64 dans le presse-papier) non encapsulée dans du HTML + static public function uploadImageBase64(): JsonResponse + { + $json = json_decode(file_get_contents('php://input'), true); + $dest = 'user_data/images/'; + + if(!is_dir($dest)){ + mkdir($dest, 0755, true); + } + + // détection de data:image/ et de ;base64, et capture du format dans $type + if(!isset($json['image_base64']) || !preg_match('/^data:image\/(\w+);base64,/', $json['image_base64'], $type)){ + return new JsonResponse(['message' => 'Données image base64 manquantes ou invalides'], JsonResponse::HTTP_BAD_REQUEST); // code 400 + } + + $extension = strtolower($type[1]); // dans (\w+) + if(!in_array($extension, self::ALLOWED_EXTENSIONS)){ + $extension = 'jpeg'; + } + + $name = 'pasted_image'; + $image_data = base64_decode(substr($json['image_base64'], strpos($json['image_base64'], ',') + 1)); // découpe la chaine à la virgule puis convertit en binaire + if($image_data === false){ + return new JsonResponse(['message' => 'Décodage base64 invalide'], JsonResponse::HTTP_BAD_REQUEST); // code 400 + } + $local_path = uniqid($dest . $name . '_') . '.' . $extension; + + if(self::imagickCleanAndWriteImage($image_data, $local_path)){ + return new JsonResponse(['location' => $local_path]); + } + else{ + return new JsonResponse(['message' => 'Erreur image non valide', 'format' => $extension], JsonResponse::HTTP_INTERNAL_SERVER_ERROR); // code 500 + } + } +} \ No newline at end of file diff --git a/src/Controller/MaintenanceController.php b/src/Controller/MaintenanceController.php new file mode 100644 index 0000000..d3be2a1 --- /dev/null +++ b/src/Controller/MaintenanceController.php @@ -0,0 +1,152 @@ +getRepository(Log::class)->findAll(); + if(empty($data)){ + return new JsonResponse(['success' => false]); + } + else{ + $view = '

Table ' . TABLE_PREFIX . 'log de la base de données

+ + + + + + + + '; + foreach($data as $entry){ + $view .= ' + + + '; + } + $view .= '
date et heure (Greenwich)connexion réussie
' . $entry->getFormatedDate() . '' . ($entry->getSuccess() ? 'oui' : 'non') . '
'; + return new JsonResponse(['success' => true, 'view' => $view]); + } + } + static public function eraseLogs(EntityManager $entityManager): JsonResponse + { + try{ + $table = $entityManager->getClassMetadata(Log::class)->getTableName(); + $entityManager->getConnection()->executeStatement("TRUNCATE TABLE {$table}"); // SQL donné à DBAL + return new JsonResponse(['success' => true]); + } + catch(\Exception $e){ + return new JsonResponse(['success' => false, 'error' => $e->getMessage()]); + } + } + + static public function getLastDump(EntityManager $entityManager): BinaryFileResponse|RedirectResponse + { + try{ + $backup_list = Backup::getBackupList(); + $nb = count($backup_list); + + if($nb <= 0){ // se produit à la première connexion en mode admin pour une raison algorithimque + Backup::mySQLdump($entityManager, 'auto'); + $backup_list = Backup::getBackupList(); + $nb = count($backup_list); + if($nb <= 0){ // improbable, les dossiers devraient déjà avoir été créés + throw new \RuntimeException("Le serveur a rencontré une erreur: aucun backup n'est disponible et ce n'est pas normal."); + } + } + + $file_path = Backup::$backup_dir . '/' . $backup_list[$nb - 1]; + $response = new BinaryFileResponse($file_path); + $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT); // ne pas essayer de l'afficher dans le navigateur + } + catch(\RuntimeException $e){ + $_SESSION['flash_message'] = $e->getMessage(); + $response = new RedirectResponse((string) new URL(['page' => 'maintenance'])); + } + return $response; + } + static public function getAllMedia(): BinaryFileResponse|RedirectResponse + { + try{ + $file_path = '../var/' . Backup::createZip('all_media.zip', ['user_data/assets', 'user_data/images', 'user_data/media']); + $response = new BinaryFileResponse($file_path); + $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT); // ne pas essayer de l'afficher dans le navigateur + } + catch(\RuntimeException $e){ + $_SESSION['flash_message'] = $e->getMessage(); + $response = new RedirectResponse((string) new URL(['page' => 'maintenance'])); + } + return $response; + } + + // parce qu'il faut un contrôleur + static public function handleBackupSelection(EntityManager $entityManager, Request $request): RedirectResponse + { + $selected_file = $request->request->get('selected_sql'); + $url = new URL; + if($request->query->has('from')){ + $url->addParams(['page' => $request->query->get('from')]); + } + + try{ + if(pathinfo($selected_file)['extension'] !== 'sql'){ // pas censé se produire en fait + throw new \Exception("charger un fichier au format SQL"); + } + Backup::restoreDatabase($entityManager, $selected_file, ['user']); + + $_SESSION['flash_message'] = "La base de données a été restaurée avec succès !!"; + } + catch(\Exception $e){ + $_SESSION['flash_message'] = "Une erreur s'est produite: " . $e->getMessage(); + } + + return new RedirectResponse((string)$url); + } + + static public function downloadSQL(EntityManager $entityManager, Request $request): RedirectResponse + { + $uploaded_file = $request->files->get('uploaded_sql'); + $date = new \DateTime; + $server_place = Config::$database . '_' . $date->format('Y-m-d') . '_uploaded.sql'; + $url = new URL; + if($request->query->has('from')){ + $url->addParams(['page' => $request->query->get('from')]); + } + + try{ + if(pathinfo($uploaded_file->getClientOriginalName())['extension'] !== 'sql'){ + throw new \Exception("Charger un fichier au format SQL"); + } + //echo $uploaded_file->getSize(); // à garder de côté au cas où + + // enregistrer le fichier + $uploaded_file->move(Backup::$backup_dir, $server_place); + + // s'en servir + Backup::restoreDatabase($entityManager, $server_place, ['user']); + + $_SESSION['flash_message'] = "La base de données a été restaurée avec succès !!"; + } + catch(\Exception $e){ + $_SESSION['flash_message'] = "Une erreur s'est produite: " . $e->getMessage(); + } + + return new RedirectResponse((string)$url); + } +} \ No newline at end of file diff --git a/src/Controller/MenuAndPathsController.php b/src/Controller/MenuAndPathsController.php new file mode 100644 index 0000000..1916f06 --- /dev/null +++ b/src/Controller/MenuAndPathsController.php @@ -0,0 +1,226 @@ +findPageById((int)$_POST["location"]); // (int) à cause de declare(strict_types=1); + $parent = $previous_page->getParent(); + + $url_input = trim($_POST["url_input"]); // faire htmlspecialchars à l'affichage + if(!filter_var($url_input, FILTER_VALIDATE_URL) || !str_starts_with($url_input, 'http')){ + // utiliser une flash error + return new RedirectResponse((string)new URL(['page' => $_GET['from'], 'error' => 'invalide_url'])); + } + + $page = new Page( + trim(htmlspecialchars($_POST["label_input"])), + $url_input, '', + true, true, false, + $previous_page->getPosition(), + $parent); // peut et DOIT être null si on est au 1er niveau + + // on a donné à la nouvelle entrée la même position qu'à la précédente, + // addChild l'ajoute à la fin du tableau "children" puis on trie + // exemple avec 2 comme position demandée: 1 2 3 4 2 devient 1 2 3 4 5 et la nouvelle entrée sera en 3è position + if(!$parent){ + $parent = Model::$menu; + } + $parent->addChild($page); // true pour réindexer les positions en BDD + $parent->reindexPositions(); + + $entityManager->persist($page); + $entityManager->flush(); + return new RedirectResponse((string)new URL(['page' => $_GET['from']])); + } + + // on pourrait utiliser FormValidation ici + static public function editUrl(EntityManager $entityManager, array $json): JsonResponse + { + $url_data = trim($json['input_data']); // garder htmlspecialchars pour l'affichage + $page = $entityManager->find('App\Entity\Page', $json['id']); + + if(!$page){ + return new JsonResponse(['success' => false, 'message' => "id invalide"]); + } + elseif(!in_array($json['field'], ['url_name', 'url_content'])){ + return new JsonResponse(['success' => false, 'message' => "champ invalide"]); + } + elseif($json['field'] === 'url_content' && (!filter_var($url_data, FILTER_VALIDATE_URL) || !str_starts_with($url_data, 'http'))){ + return new JsonResponse(['success' => false, 'message' => "la chaîne envoyée n'est pas une URL valide"]); + } + else{ + if($json['field'] === 'url_name'){ + $page->setPageName($url_data); + } + elseif($json['field'] === 'url_content'){ + $page->setEndOfPath($url_data); + } + $entityManager->flush(); + return new JsonResponse(['success' => true, 'url_data' => $url_data]); + } + } + + static public function deleteUrlMenuEntry(EntityManager $entityManager): RedirectResponse + { + Model::$menu = new Menu($entityManager); + $page = Model::$menu->findPageById((int)$_POST["delete"]); + $parent = $page->getParent(); + if($parent == null){ + $parent = Model::$menu; + } + + $parent->removeChild($page); // suppression de $children avant de trier + $parent->reindexPositions(); + + $entityManager->remove($page); // suppression en BDD + $entityManager->flush(); + return new RedirectResponse((string)new URL(['page' => $_GET['from']])); + } + + static public function MoveOneLevelUp(EntityManager $entityManager, array $json): JsonResponse + { + $id = $json['id']; + $page = Model::$menu->findPageById((int)$id); + + $parent = $page->getParent(); // peut être null + if($parent === null){ + // 1er niveau: ne rien faire + return new JsonResponse(['success' => false, 'message' => 'nothing to do']); + } + // BDD + else{ + $page->setPosition($parent->getPosition() + 1); // nouvelle position + + // 2ème niveau: le parent devient $menu, puis null après tri + if($parent->getParent() === null){ + // connexion dans les deux sens + $page->setParent(Model::$menu); // => pour la persistance + + //Model::$menu->addChild($page); // => pour sortChildren + $page->getParent()->addChild($page); // => pour sortChildren + $page->getParent()->sortChildren(true); // positions décaléees des nouveaux petits frères + $page->setParent(null); + + // affichage + $page->setPagePath($page->getEndOfPath()); + $page->fillChildrenPagePath(); + } + // 3ème niveau et plus + else{ + $page->setParent($parent->getParent()); // nouveau parent + $page->getParent()->addChild($page); // => pour sortChildren + $page->getParent()->sortChildren(true); // positions décaléees des nouveaux petits frères + $page->fillChildrenPagePath($page->getParent()->getPagePath()); + } + $entityManager->flush(); + + // affichage + $parent->removeChild($page); + $nav_builder = new NavBuilder(); + $menu_builder = new MenuBuilder(null, false); + return new JsonResponse(['success' => true, 'nav' => $nav_builder->render(), 'menu_buttons' => $menu_builder->render()]); + } + } + + static public function MoveOneLevelDown(EntityManager $entityManager, array $json): JsonResponse + { + $id = $json['id']; + $page = Model::$menu->findPageById((int)$id); + + $parent = $page->getParent(); // peut être null + if($parent === null){ + $parent = Model::$menu; + } + + // BDD + $parent->sortChildren(true); // trie et réindexe par sécurité: 1, 2, 3... + if($page->getPosition() > 1){ + foreach($parent->getChildren() as $child){ + if($child->getPosition() === $page->getPosition() - 1){ + // refus si $parent est une adresse, ça va casser le lien, exemple: index.php?page=chemin/http://un_site_web.fr/vers/ici + if(str_starts_with($child->getEndOfPath(), 'http')){ + return new JsonResponse(['success' => false, 'error' => 'new_parent_is_a_link']); + } + + $page->setParent($child); + break; + } + } + $page->setPosition(count($page->getParent()->getChildren()) + 1); + } + $entityManager->flush(); + + // affichage + $parent->removeChild($page); + $page->getParent()->addChild($page); + $page->fillChildrenPagePath($page->getParent()->getPagePath()); // variable non mappée $page_path + $nav_builder = new NavBuilder(); + $menu_builder = new MenuBuilder(null, false); + + return new JsonResponse(['success' => true, 'nav' => $nav_builder->render(), 'menu_buttons' => $menu_builder->render()]); + } + + static public function SwitchPositions(EntityManager $entityManager, array $json): JsonResponse + { + $id1 = $json['id1']; + $id2 = $json['id2']; + + // vérifier qu'ils ont le même parent + $page1 = Model::$menu->findPageById((int)$id1); + $page2 = Model::$menu->findPageById((int)$id2); + + // double le contrôle fait en JS + if($page1->getParent() === $page2->getParent()) // comparaison stricte d'objet (même instance du parent?) + { + // inversion + $tmp = $page1->getPosition(); + $page1->setPosition($page2->getPosition()); + $page2->setPosition($tmp); + Model::$menu->sortChildren(true); // modifie tableau children + $entityManager->flush(); + + // nouveau menu + $nav_builder = new NavBuilder(); + return new JsonResponse(['success' => true, 'nav' => $nav_builder->render()]); + } + else{ + return new JsonResponse(['success' => false]); + } + } + + static public function displayInMenu(EntityManager $entityManager, array $json): JsonResponse + { + $id = $json['id']; + $checked = $json['checked']; + + $page = Model::$menu->findPageById((int)$id); + if($page->isHidden() === $checked){ + $page->setHidden(!$checked); + $entityManager->flush(); + + // nouveau menu + $nav_builder = new NavBuilder(); + return new JsonResponse(['success' => true, 'nav' => $nav_builder->render()]); + } + else{ + return new JsonResponse(['success' => false]); + } + } +} \ No newline at end of file diff --git a/src/Controller/PageManagementController.php b/src/Controller/PageManagementController.php new file mode 100644 index 0000000..02e6e6a --- /dev/null +++ b/src/Controller/PageManagementController.php @@ -0,0 +1,368 @@ +find('App\Entity\Page', $json['page_id']); + $page->setPageName(htmlspecialchars($json['title'])); + $entityManager->flush(); + return new JsonResponse(['success' => true, 'title' => $page->getPageName()]); + } + + static public function updatePageMenuPath(EntityManager $entityManager, string $page_menu_path): RedirectResponse + { + Model::$menu = new Menu($entityManager); + Model::$page_path = new Path(); + $page = Model::$page_path->getLast(); + $path = htmlspecialchars($page_menu_path); + + // mise en snake_case: filtre caractères non-alphanumériques, minuscule, doublons d'underscore, trim des underscores + $path = trim(preg_replace('/_+/', '_', strtolower(preg_replace('/[^a-zA-Z0-9]/', '_', $path))), '_'); + $page->setEndOfPath($path); + foreach(Model::$menu->getChildren() as $child){ + if($child->getEndOfPath() === Model::$page_path->getArray()[0]->getEndOfPath()){ + $child->fillChildrenPagePath(); // MAJ de $page_path + } + } + $entityManager->flush(); + return new RedirectResponse((string)new URL(['page' => $page->getPagePath(), 'mode' => 'page_modif'])); + } + + static public function setPageDescription(EntityManager $entityManager, array $json): JsonResponse + { + $page = $entityManager->find('App\Entity\Page', $json['page_id']); + $page->setDescription(htmlspecialchars($json['description'])); + $entityManager->flush(); + return new JsonResponse(['success' => true, 'description' => $page->getDescription()]); + } + + static public function newPage(EntityManager $entityManager, InputBag $post): RedirectResponse + { + // titre et chemin + Model::$menu = new Menu($entityManager); + $previous_page = Model::$menu->findPageById((int)$post->get("page_location")); // (int) à cause de declare(strict_types=1); + $parent = $previous_page->getParent(); + + $page = new Page( + trim(htmlspecialchars($post->get("page_name"))), + trim(htmlspecialchars($post->get("page_name_path"))), + trim(htmlspecialchars($post->get("page_description"))), + true, true, false, + $previous_page->getPosition(), + $parent); // peut et DOIT être null si on est au 1er niveau + + // on a donné à la nouvelle entrée la même position qu'à la précédente, + // addChild l'ajoute à la fin du tableau "children" puis on trie + // exemple avec 2 comme position demandée: 1 2 3 4 2 devient 1 2 3 4 5 et la nouvelle entrée sera en 3è position + if($parent == null){ + $parent = Model::$menu; + } + $parent->addChild($page); + $parent->reindexPositions(); + + $page->setPagePath(ltrim($parent->getPagePath() . '/' . $page->getEndOfPath(), '/')); + + $entityManager->persist($page); + $entityManager->flush(); + + // page créée, direction la page en mode modification pour ajouter des blocs + return new RedirectResponse((string)new URL(['page' => $page->getPagePath(), 'mode' => 'page_modif'])); + } + + static public function deletePage(EntityManager $entityManager, string $page_id): RedirectResponse + { + $menu = new Menu($entityManager); + $page = $menu->findPageById((int)$page_id); + $url = new URL; + + // test dernière page + // => $menu a un enfant et pas de petits enfants + // => $menu->getChildren()->isEmpty() n'est théoriquement pas possible + if($menu->getChildren()->isEmpty() || (count($menu->getChildren()) === 1 && $menu->getChildren()[0]->getChildren()->isEmpty())){ + $url->addParams(['page' => $page->getEndOfPath(), 'error' => 'you_tried_to_remove_the_last_page']); + } + else{ + $nodes = $entityManager->getRepository('App\Entity\Node')->findBy(['page' => $page]); + $data = []; + foreach($nodes as $node){ + $data[] = $entityManager->getRepository('App\Entity\NodeData')->findOneBy(['node' => $node]); + $entityManager->remove($node); + } + foreach($data as $one_data){ + $entityManager->remove($one_data); + } + $entityManager->remove($page); // suppression en BDD + $entityManager->flush(); + + // destination vers la première page dispo + // traite les cas prévus dans le if plus haut + $menu->removeChild($page); + $next_page = $menu->getChildren()->isEmpty() ? $next_page = $page->getChildren()[0] : $menu->getChildren()[0]; + $url->addParams(['page' => $next_page->getEndOfPath()]); + } + + return new RedirectResponse((string)$url); + } + + /* partie "blocs" */ + static public function addBloc(EntityManager $entityManager, Request $request): RedirectResponse + { + $model = new Model($entityManager); + $model->makeMenuAndPaths(); // on a besoin de page_path qui dépend de menu + $page = Model::$page_path->getLast(); + $model->findUniqueNodeByName('main'); + $model->findItsChildren(); + $main = $model->getNode(); + $position = count($main->getChildren()) + 1; // position dans la fraterie + + if(!in_array($request->request->get("bloc_select"), array_keys(Presentation::BLOCKS), true)){ // 3è param: contrôle du type + // utiliser une flash error + return new RedirectResponse((string)new URL(['page' => $request->query->get('page'), 'error' => 'bad_bloc_type'])); + } + + if(in_array($request->request->get("bloc_select"), ['calendar', 'form'])){ + $page->addCSS($request->request->get("bloc_select")); + if($request->request->get("bloc_select") === 'form'){ + $page->addJS($request->request->get("bloc_select")); + } + $entityManager->persist($page); + } + + $block = new Node($request->request->get("bloc_select"), $position, $main, $page); + + $DataClass = match($request->request->get("bloc_select")){ + 'form' => EmailForm::class, + 'post_block', 'news_block' => Presentation::class, + 'calendar' => NodeData::class, + default => throw new \InvalidArgumentException("Erreur: type de bloc inconnu"), + }; + $data = new $DataClass(['title' => trim(htmlspecialchars($request->request->get("bloc_title")))], $block); + + // valeurs par défaut + if($request->request->get("bloc_select") === 'post_block'){ + $data->setPresentation('fullwidth'); + } + elseif($request->request->get("bloc_select") === 'news_block'){ + $data->setPresentation('grid'); + } + elseif($request->request->get("bloc_select") === 'galery'){ + $data->setPresentation('mosaic'); // un jour on mettra carousel + } + // else = null par défaut + + $entityManager->persist($block); + $entityManager->persist($data); + $entityManager->flush(); + return new RedirectResponse((string)new URL(['page' => $request->query->get('page'), 'mode' => 'page_modif'])); + } + + static public function deleteBloc(EntityManager $entityManager, Request $request): RedirectResponse + { + $model = new Model($entityManager); + $model->makeMenuAndPaths(); + $model->findUniqueNodeByName('main'); + $model->findItsChildren(); + $main = $model->getNode(); + + $block = null; + $type = ''; + $nb_same_type = 0; + foreach($main->getChildren() as $child){ + if($child->getId() === (int)$request->request->get('delete_bloc_id')){ + $block = $child; + $type = $block->getName(); + } + if($child->getName() === $type){ + $nb_same_type++; + } + } + + // nettoyage fichiers CSS et JS si on retire le derner bloc de ce type + if($nb_same_type === 1 && in_array($block->getName(), ['calendar', 'form'])){ + $page = $block->getPage(); + $page->removeCSS($block->getName()); + if($block->getName() === 'form'){ + $page->removeJS($block->getName()); + } + } + + if(!empty($block)){ // si $block est null c'est que le HTML a été modifié volontairement + $main->removeChild($block); // réindex le tableau $children au passage + $main->reindexPositions(); + if(isset($page)){ + $entityManager->persist($page); + } + $block->getNodeData()->setNode(null); + $entityManager->remove($block); + try{ + $entityManager->flush(); + } + catch(\Exception $e){ + // utiliser une flash error + return new RedirectResponse((string)new URL(['page' => $request->query->get('page'), 'mode' => 'page_modif', 'error' => $e->getMessage()])); + } + } + + return new RedirectResponse((string)new URL(['page' => $request->query->get('page'), 'mode' => 'page_modif'])); + } + + static public function renameBloc(EntityManager $entityManager, array $json): JsonResponse + { + if(isset($json['bloc_title']) && $json['bloc_title'] !== null && isset($json['bloc_id']) && is_int($json['bloc_id'])){ + $model = new Model($entityManager); + $model->findNodeById($json['bloc_id']); + + // le titre (du JSON en BDD) est récupéré sous forme de tableau, modifié et renvoyé + $data = $model->getNode()->getNodeData()->getData(); + $data['title'] = htmlspecialchars($json['bloc_title']); + $model->getNode()->getNodeData()->updateData('title', htmlspecialchars($json['bloc_title'])); + + $entityManager->flush(); + return new JsonResponse(['success' => true, 'title' => $data['title']]); + } + else{ + return new JsonResponse(['success' => false]); + } + } + + static public function SwitchBlocsPositions(EntityManager $entityManager, array $json, string $page): JsonResponse + { + if(isset($json['id1']) && is_int($json['id1']) && isset($json['id2']) && is_int($json['id2']) && isset($page)){ + $model = new Model($entityManager); + $model->makeMenuAndPaths(); // true pour $model->findItsChildren(); + $model->findUniqueNodeByName('main'); + $model->findItsChildren(); + $main = $model->getNode(); + $main->sortChildren(true); // régénère les positions avant inversion + + $bloc1 = null; + $bloc2 = null; + foreach($main->getChildren() as $child){ + if($child->getId() === $json['id1']){ + $bloc1 = $child; + break; + } + } + foreach($main->getChildren() as $child){ + if($child->getId() === $json['id2']){ + $bloc2 = $child; + break; + } + } + + // inversion + $tmp = $bloc1->getPosition(); + $bloc1->setPosition($bloc2->getPosition()); + $bloc2->setPosition($tmp); + + $entityManager->flush(); + return new JsonResponse(['success' => true]); + } + else{ + return new JsonResponse(['success' => false]); + } + } + + static public function changeArticlesOrder(EntityManager $entityManager, array $json): JsonResponse + { + if(isset($json['id']) && isset($json['chrono_order'])){ + $model = new Model($entityManager); + $model->findNodeById($json['id']); + + if($json['chrono_order'] === 'chrono'){ + $chrono_order = true; + } + elseif($json['chrono_order'] === 'antichrono'){ + $chrono_order = false; + } + else{ + return new JsonResponse(['success' => false]); + } + $model->getNode()->getNodeData()->setChronoOrder($chrono_order); + $entityManager->flush(); + + return new JsonResponse(['success' => true, 'chrono_order' => $json['chrono_order']]); + } + else{ + return new JsonResponse(['success' => false]); + } + } + + static public function changePresentation(EntityManager $entityManager, array $json): JsonResponse + { + if(isset($json['id']) && isset($json['presentation'])){ + $model = new Model($entityManager); + $model->findNodeById($json['id']); + + if(in_array($json['presentation'], array_keys(Presentation::PRESENTATIONS))){ + $model->getNode()->getNodeData()->setPresentation($json['presentation']); + $entityManager->flush(); + + $response_data = ['success' => true, 'presentation' => $json['presentation']]; + if($json['presentation'] === 'grid'){ + $response_data['cols_min_width'] = $model->getNode()->getNodeData()->getColsMinWidth(); + } + return new JsonResponse($response_data); + } + else{ + return new JsonResponse(['success' => false]); + } + } + else{ + return new JsonResponse(['success' => false]); + } + } + static public function changeColsMinWidth(EntityManager $entityManager, array $json): JsonResponse + { + if(isset($json['id']) && isset($json['cols_min_width'])){ + $model = new Model($entityManager); + $model->findNodeById($json['id']); + $model->getNode()->getNodeData()->setColsMinWidth((int)$json['cols_min_width']); // attention conversion? + + $entityManager->flush(); + return new JsonResponse(['success' => true, 'cols_min_width' => $json['cols_min_width']]); + } + else{ + return new JsonResponse(['success' => false]); + } + } + static public function changePaginationLimit(EntityManager $entityManager, array $json): JsonResponse + { + if(isset($json['id']) && isset($json['pagination_limit'])){ + $model = new Model($entityManager); + $model->findNodeById($json['id']); + $old_limit = $model->getNode()->getNodeData()->getPaginationLimit() ?? 12; + $model->getNode()->getNodeData()->setPaginationLimit((int)$json['pagination_limit']); // attention conversion? + + $entityManager->flush(); + + return new JsonResponse(['success' => true, 'old_limit' => $old_limit, 'new_limit' => $json['pagination_limit']]); + } + else{ + return new JsonResponse(['success' => false]); + } + } +} \ No newline at end of file diff --git a/src/Controller/UserController.php b/src/Controller/UserController.php new file mode 100644 index 0000000..812a2da --- /dev/null +++ b/src/Controller/UserController.php @@ -0,0 +1,237 @@ + UserController devrait se limiter à gérer des requêtes et réponses (changement transparent pour le routeur) +il instancierait un classe correspondant au formulaire (prend POST et SESSION) et une classe "métier" UserService +=> UserService contiendrait des méthodes utilisant l'objet formulaire pour agir sur la BDD +=> les formulaires peuvent tenir dans une classe "UserUpdateForm" avec des stratégies ou plusieurs, les données y sont validées +=> il est aussi possible de découper UserController en contrôleurs par fonctionnalité: +Auth (connexion, deconnexion), User (infos, choix photo), Account (créer, supprimer compte), Avatar (upload photo...) +*/ + +declare(strict_types=1); + +namespace App\Controller; + +use Symfony\Component\HttpFoundation\RedirectResponse; +use Doctrine\ORM\EntityManager; +use App\Entity\User; +use App\Entity\Log; +use App\Service\FormValidation; +use App\Service\ValidationStrategy; +use App\Service\URL; +use App\Service\Backup; +use App\Service\EmailService; + +class UserController +{ + // account + static public function createAdminUser(EntityManager $entityManager): RedirectResponse + { + unset($_SESSION['user']); + + $form = new FormValidation($_POST, ValidationStrategy::CreateUser); + + $url = new URL; + $error = ''; + if($form->validate()){ + $password = password_hash($_POST['password'], PASSWORD_DEFAULT); + $user = new User($_POST['login'], 'admin', $password); + $entityManager->persist($user); + $entityManager->flush(); + } + else{ + $error = $form->getError(); + } + + if(!empty($error)){ + $url->addParams(['error' => $error]); + } + + return new RedirectResponse((string)$url); + } + + // account + //static public function createUser(EntityManager $entityManager){} + + // auth + static public function connect(EntityManager $entityManager): RedirectResponse + { + $url = new URL; + if(IS_ADMIN){ // déjà connecté? + return new RedirectResponse((string)$url); + } + unset($_SESSION['user']); + + $form = new FormValidation($_POST, ValidationStrategy::Connection); + + $error = ''; + if($form->validate()){ + // à mettre dans une classe métier UserService, Authentication, AuthService? + $user = self::getUserByName($_POST['login'], $entityManager); + if(!empty($user) && $_POST['login'] === $user->getLogin() && password_verify($_POST['password'], $user->getPassword())){ + $log = new Log(true); + + // protection fixation de session, si l'attaquant crée un cookie de session, il est remplacé + session_regenerate_id(true); + $_SESSION['user']['id'] = $user->getId(); + $_SESSION['user']['username'] = $user->getLogin(); + $_SESSION['user']['role'] = $user->getRole(); + + EmailService::cleanEmails($entityManager); + + try{ + if(file_exists('../var/backups')){ + Backup::mySQLdump($entityManager, 'auto'); // créer un nouveau backup, sauf si les dossiers nécessaires sont encore à créer + } + } + catch(\RuntimeException $e){ + echo ''; + } + + $url->addParams(isset($_GET['from']) ? ['page' => $_GET['from']] : []); + isset($_GET['id']) ? $url->addParams(['id' => $_GET['id']]) : ''; + } + else + { + $log = new Log(false); + $error = 'bad_login_or_password'; + } + $entityManager->persist($log); + $entityManager->flush(); + } + else{ + $error = $form->getError(); + } + + if(!empty($error)){ + sleep(1); // défense basique à la force brute + $url->addParams(['page' => 'connection']); + isset($_GET['from']) ? $url->addParams(['from' => $_GET['from']]) : null; + isset($_GET['id']) ? $url->addParams(['id' => $_GET['id']]) : null; + $url->addParams(['error' => $error]); + } + + return new RedirectResponse((string)$url); + } + + // auth + static public function disconnect(): RedirectResponse + { + // nettoyage complet + unset($_SESSION['user']); // mémoire vive + session_destroy(); // fichier côté serveur + setcookie('PHPSESSID', '', time() - 86400, '/'); // cookie de session + + // retour même page + $url = new URL; + isset($_GET['from']) ? $url->addParams(['page' => $_GET['from']]) : ''; + isset($_GET['id']) ? $url->addParams(['id' => $_GET['id']]) : ''; + return new RedirectResponse((string)$url); + } + + // user + static public function updateUsername(EntityManager $entityManager): RedirectResponse + { + if(!IS_ADMIN){ // superflux, fait dans le routeur + return self::disconnect(); + } + + $url = new URL(['page' => 'user_edit']); + isset($_GET['from']) ? $url->addParams(['from' => $_GET['from']]) : null; + + $form = new FormValidation($_POST, ValidationStrategy::UsernameUpdate); + + $error = ''; + if($form->validate()){ + // à mettre dans une classe métier UserService? + $user = self::getUserByName($_POST['login'], $entityManager); + if(password_verify($_POST['password'], $user->getPassword())){ + $user->setLogin($_POST['new_login']); + $entityManager->flush(); + $_SESSION['user']['username'] = $_POST['new_login']; + + $url->addParams(['success_username' => 'new_login']); + $error = ''; + } + else{ + $error = 'bad_login_or_password'; + } + } + else{ + $error = $form->getError(); + } + + if(!empty($error)){ + sleep(1); + $url->addParams(['error_username' => $error]); + } + return new RedirectResponse((string)$url); + } + + // user + static public function updatePassword(EntityManager $entityManager): RedirectResponse + { + if(!IS_ADMIN){ // superflux, fait dans le routeur + return self::disconnect(); + } + + $url = new URL(['page' => 'user_edit']); + isset($_GET['from']) ? $url->addParams(['from' => $_GET['from']]) : null; + + $form = new FormValidation($_POST, ValidationStrategy::PasswordUpdate); + + $error = ''; + if($form->validate()){ + // à mettre dans une classe métier UserService? + $user = self::getUserByName($_POST['login'], $entityManager); + if(password_verify($_POST['password'], $user->getPassword())){ + $new_password = password_hash($_POST['new_password'], PASSWORD_DEFAULT); + $user->setPassword($new_password); + $entityManager->flush(); + + $url->addParams(['success_password' => 'new_password']); + $error = ''; + } + else{ + $error = 'bad_login_or_password'; + } + } + else{ + $error = $form->getError(); + } + + if(!empty($error)){ + sleep(1); + $url->addParams(['error_password' => $error]); + } + return new RedirectResponse((string)$url); + } + + // dans une classe mère ou un trait après découpage de UserController? + static private function getUserByName(string $login, EntityManager $entityManager): ?User + { + $users = $entityManager->getRepository(User::class)->findBy(['login' => $login]); + foreach($users as $user){ + if($user->getLogin() === $login){ + return $user; + } + } + return null; + } + + static public function getUserById(int $id, EntityManager $entityManager): ?User + { + return $entityManager->find(User::class, $id); + } + + // dans une classe Form? + // erreurs à la création des mots de passe + static private function removeSpacesTabsCRLF(string $chaine): string + { + $cibles = [' ', "\t", "\n", "\r"]; // doubles quotes !! + return(str_replace($cibles, '', $chaine)); + } +} \ No newline at end of file diff --git a/src/Controller/ViewController.php b/src/Controller/ViewController.php new file mode 100644 index 0000000..1f13861 --- /dev/null +++ b/src/Controller/ViewController.php @@ -0,0 +1,70 @@ +query->has('mode') && $request->query->get('mode') === 'page_modif' + && !in_array(CURRENT_PAGE, self::SPECIAL_PAGES)) + { + MainBuilder::$modif_mode = true; + } + // page article: mode création et erreurs d'id + if(CURRENT_PAGE === 'article'){ + if(IS_ADMIN){ + if(!$request->query->has('id')){ + return new RedirectResponse((string)new URL(['page' => $request->query->get('from') ?? ''])); + } + else{ + // mode création d'article + // l'id du bloc et 'from=' sont vérifiés dans ArticleController::editorSubmit + if($request->query->get('id')[0] === 'n' && $request->query->has('from') && !empty($request->query->get('from'))){ + NewBuilder::$new_article_mode = true; + } + } + } + elseif($request->query->get('id')[0] === 'n'){ // accès page nouvelle article interdit sans être admin + return new RedirectResponse((string)new URL(['page' => $request->query->get('from') ?? ''])); + } + } + // pas de else, l'id dans l'URL n'a pas d'effet ailleurs + + + /* 2/ accès au modèle */ + $model = new Model($entityManager); + $model->makeMenuAndPaths(); + $model->getWholePageData($request); + + + /* 3/ 2ème contrôle des paramètres avec les données récupérées */ + + // article non trouvé en BDD + if(CURRENT_PAGE === 'article' && !IS_ADMIN && $model->getNode()->getNodeByName('main')->getAdoptedChild() === null){ + return new RedirectResponse((string)new URL(['page' => $request->query->get('from') ?? ''])); + } + + + /* 4/ construction de la page avec builders et vues */ + return new Response((new ViewDirector)->buildHTML($model->getNode())); + } +} \ No newline at end of file -- cgit v1.2.3