mise en ligne github

9 files changed, 710 insertions, 0 deletions

diff --git a/src/model/Menu.php b/src/model/Menu.php
new file mode 100644
index 0000000..624a0fc
--- /dev/null
+++ b/src/model/Menu.php
@@ -0,0 +1,53 @@
+<?php
+// src/controller/Menu.php
+
+declare(strict_types=1);
+
+use Doctrine\ORM\EntityManager;
+use App\Entity\Page;
+use Doctrine\Common\Collections\ArrayCollection;
+
+class Menu extends Page
+{
+        private EntityManager $entityManager;
+    private array $other_pages = []; // pages n'apparaissant pas dans le menu
+
+        public function __construct(EntityManager $entityManager){
+                $this->children = new ArrayCollection();
+
+                $bulk_data = $entityManager
+            ->createQuery('SELECT n FROM App\Entity\Page n WHERE n.parent IS null') // :Doctrine\ORM\Query
+            ->getResult(); // :array de Page
+
+        if(count($bulk_data) === 0){
+            makeStartPage($entityManager);
+        }
+
+        foreach($bulk_data as $first_level_entries){
+            // génération du menu
+            if($first_level_entries->getInMenu()){
+                $this->addChild($first_level_entries);
+            }
+            // autres pages
+            else{
+                // attention, seul le premier élément du chemin est pris en compte
+                $this->other_pages[] = $first_level_entries;
+            }
+        }
+
+        foreach($this->getChildren() as $page){
+                $page->fillChildrenPagePath();
+        }
+        
+        /*for($i = 0; $i < count($this->getChildren()[1]->getChildren()); $i++){
+                echo $this->getChildren()[1]->getChildren()[$i]->getEndOfPath() . ' - ';
+                echo $this->getChildren()[1]->getChildren()[$i]->getPageName() . '<br>';
+        }*/
+        //die;
+        }
+
+    public function getOtherPages(): array
+    {
+        return $this->other_pages;
+    }
+}
\ No newline at end of file
diff --git a/src/model/Path.php b/src/model/Path.php
new file mode 100644
index 0000000..6faadfd
--- /dev/null
+++ b/src/model/Path.php
@@ -0,0 +1,84 @@
+<?php
+// src/controller/Path.php
+
+declare(strict_types=1);
+
+use Doctrine\ORM\EntityManager;
+use App\Entity\Page;
+
+class Path extends Page
+{
+        private array $current_page = []; // tableau d'objets Page
+
+        public function __construct()
+        {
+        $path_array = explode('/', CURRENT_PAGE);
+        try{
+                $this->findPage(Director::$menu_data, $path_array); // remplit $this->current_page
+        }
+                catch(Exception $e){}
+                /*echo "nb d'autres pages: " . count(Director::$menu_data->getOtherPages()) . '<br>';
+                echo 'longueur du chemin: ' . count($this->current_page) . '<br>';
+                foreach($this->current_page as $current){
+                        echo $current->getEndOfPath() . ' ';
+                }
+                die;*/
+        }
+
+        // produit un tableau de Page en comparant le chemin demandé avec les données dans Menu
+        // succès => une exception est lancée pour sortir des fonctions imbriquées
+        // echec => redirection vers la page erreur 404
+        private function findPage(Page|Menu $menu, array $path_array)
+        {
+                // recherche dans les autres pages
+                if($menu instanceof Menu){
+                        foreach($menu->getOtherPages() as $page)
+                        {
+                                if($path_array[0] === $page->getEndOfPath())
+                                {
+                                        $this->current_page[] = $page;
+                                        throw new Exception();
+                                }
+                        }
+                }
+                // recherche dans le menu
+                foreach($menu->getChildren() as $page)
+                {
+                        if($path_array[0] === $page->getEndOfPath())
+                        {
+                                $this->current_page[] = $page;
+                                if(count($path_array) > 1)
+                                {
+                                        array_shift($path_array); // $this->path_array n'est pas modifié, un tableau PHP est passé à une fonction par copie
+                                        $this->findPage($page, $path_array);
+                                }
+                                else{
+                                        throw new Exception(); // sortir de tous les findPage() en même temps
+                                }
+                        }
+                }
+                // rien trouvé
+                URL::setPath('erreur404.html');
+        header('Location: '. new URL);
+        die;
+        }
+
+        public function getString(): string
+    {
+        $path_string = "";
+        foreach($this->current_page as $one_page){
+                $path_string .= $one_page->getEndOfPath() . '/';
+        }
+        return rtrim($path_string, '/');
+    }
+    public function getArray(): array
+    {
+        return $this->current_page;
+    }
+
+    // c'est là qu'on est quoi
+    public function getLast(): Page
+    {
+        return $this->current_page[count($this->current_page) - 1];
+    }
+}
\ No newline at end of file
diff --git a/src/model/doctrine-bootstrap.php b/src/model/doctrine-bootstrap.php
new file mode 100644
index 0000000..139f410
--- /dev/null
+++ b/src/model/doctrine-bootstrap.php
@@ -0,0 +1,31 @@
+<?php
+// src/model/doctrine-bootstrap.php
+
+use Doctrine\ORM\ORMSetup;
+use Doctrine\DBAL\DriverManager;
+use Doctrine\ORM\EntityManager;
+
+require_once "../vendor/autoload.php";
+
+// Create a simple "default" Doctrine ORM configuration for Attributes
+$config = ORMSetup::createAttributeMetadataConfiguration(
+    //paths: array(__DIR__.'/entities'),
+    paths: array('../src/model/entities'),
+    isDevMode: true,
+    // true: cache en mémoire vive
+    // false: utilisation de APCu ou redis ou memcache
+);
+
+// configuring the database connection
+$connection = DriverManager::getConnection([
+    'driver'   => Config::$db_driver,
+    'user'     => Config::$user,
+    'password' => Config::$password,
+    'host'     => Config::$db_host,
+    'dbname'   => Config::$database,
+], $config);
+
+// obtaining the entity manager
+$entityManager = new EntityManager($connection, $config);
+
+foreach($entityManager->getMetadataFactory()->getAllMetadata() as $class){}
\ No newline at end of file
diff --git a/src/model/entities/Article.php b/src/model/entities/Article.php
new file mode 100644
index 0000000..3b846da
--- /dev/null
+++ b/src/model/entities/Article.php
@@ -0,0 +1,77 @@
+<?php
+// src/model/entities/Article.php
+
+declare(strict_types=1);
+
+namespace App\Entity;
+
+use Doctrine\ORM\Mapping as ORM;
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\Collections\Collection;
+
+#[ORM\Entity]
+#[ORM\Table(name: TABLE_PREFIX . "article")]
+class Article
+{
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    #[ORM\Column(type: "integer")]
+    private int $id_article;
+
+    // datetime_immutable permet à la base de toujours gérer cette clé primaire correctement
+    #[ORM\Column(type: 'datetime', options: ['default' => 'CURRENT_TIMESTAMP'], unique: true)]
+    private \DateTime $date_time; // le type datetime de doctrine convertit en type \DateTime de PHP
+
+    #[ORM\Column(type: "string")]
+    private string $title;
+
+    #[ORM\Column(type: "text")]
+    private string $preview; // une simple textarea
+
+    #[ORM\Column(type: "text")]
+    private string $content; // de l'éditeur html
+
+    // liaison avec table intermédiaire
+    #[ORM\ManyToMany(targetEntity: Image::class, inversedBy: "article")]
+    #[ORM\JoinTable(
+        name: "nb_article_image",
+        joinColumns: [new ORM\JoinColumn(name: "article_id", referencedColumnName: "id_article", onDelete: "CASCADE")],
+        inverseJoinColumns: [new ORM\JoinColumn(name: "image_id", referencedColumnName: "id_image", onDelete: "CASCADE")]
+    )]
+    private Collection $images;
+
+    public function __construct()
+    {
+        $this->images = new ArrayCollection(); // initialisation nécessaire
+    }
+
+    public function getDateTime(): \DateTime
+    {
+        return $this->date_time;
+    }
+    public function getTimestamp(): int
+    {
+        return $this->date_time->getTimestamp();
+    }
+    public function getTitle(): string
+    {
+        return $this->title;
+    }
+    public function getPreview(): string
+    {
+        return $this->preview;
+    }
+    public function getContent(): string
+    {
+        return $this->content;
+    }
+    public function setContent(string $data): void
+    {
+        $this->content = $data;
+    }
+
+    public function getImages(): Collection
+    {
+        return $this->images;
+    }
+}
diff --git a/src/model/entities/Image.php b/src/model/entities/Image.php
new file mode 100644
index 0000000..181c137
--- /dev/null
+++ b/src/model/entities/Image.php
@@ -0,0 +1,91 @@
+<?php
+// src/model/entities/Image.php
+
+declare(strict_types=1);
+
+namespace App\Entity;
+
+use Doctrine\ORM\Mapping as ORM;
+
+#[ORM\Entity]
+#[ORM\Table(name: TABLE_PREFIX . "image")]
+class Image
+{
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    #[ORM\Column(type: "integer")]
+    private int $id_image;
+
+    #[ORM\Column(type: "string", length: 255, unique: true)] // nom d'image UNIQUE
+    private string $file_name;
+
+    // choisir un répertoire du genre /var/www/html/uploads/ de préférence hors de /src
+    #[ORM\Column(type: "string", length: 255, unique: true, nullable: true)]
+    private ?string $file_path;
+
+    #[ORM\Column(type: "string", length: 255, unique: true, nullable: true)]
+    private ?string $file_path_mini;
+
+    #[ORM\Column(type: "string", length: 255, nullable: true)]
+    private string $mime_type; // image/jpeg, image/png, etc
+
+    #[ORM\Column(type: "string", length: 255, nullable: true)]
+    private string $alt; // texte alternatif
+
+    // autre champs optionnels: file_size, date (default current timestamp)
+
+    /* étapes au téléchargement:
+    => Validation du type de fichier : On vérifie que le fichier est bien une image en utilisant le type MIME. On peut aussi vérifier la taille du fichier.
+    => Création d'un répertoire structuré : On génère un chemin dynamique basé sur la date (uploads/2024/12/24/) pour organiser les images.
+    => Génération d'un nom de fichier unique : On utilise uniqid() pour générer un nom unique et éviter les conflits de nom.
+    => Déplacement du fichier sur le serveur : Le fichier est déplacé depuis son emplacement temporaire vers le répertoire uploads/.
+    => Enregistrement dans la base de données : On enregistre les informations de l'image dans la base de données. */
+
+    #[ORM\ManyToMany(targetEntity: NodeData::class, mappedBy: "images")]
+    private $node_data;
+
+    #[ORM\ManyToMany(targetEntity: Article::class, mappedBy: "images")]
+    private $article;
+
+    public function __construct(string $name, ?string $path, ?string $path_mini, string $mime_type, string $alt)
+    {
+        $this->file_name = $name;
+        $this->file_path = $path;
+        $this->file_path_mini = $path_mini;
+        $this->mime_type = $mime_type;
+        $this->alt = $alt;
+    }
+
+    public function getFileName(): string
+    {
+        return $this->file_name;
+    }
+    public function getFilePath(): string
+    {
+        return $this->file_path;
+    }
+    public function getFilePathMini(): string
+    {
+        return $this->file_path_mini;
+    }
+    public function getAlt(): string
+    {
+        return $this->alt;
+    }
+
+
+    // pour ViewBuilder?
+    /*public function displayImage($imageId): void
+    {
+        //$imageId = 1; // Exemple d'ID d'image
+        $stmt = $pdo->prepare("SELECT file_path FROM images WHERE id = ?");
+        $stmt->execute([$imageId]);
+        $image = $stmt->fetch();
+
+        if ($image) {
+            echo "<img src='" . $image['file_path'] . "' alt='Image'>";
+        } else {
+            echo "Image non trouvée.";
+        }
+    }*/
+}
diff --git a/src/model/entities/Node.php b/src/model/entities/Node.php
new file mode 100644
index 0000000..49e16ba
--- /dev/null
+++ b/src/model/entities/Node.php
@@ -0,0 +1,168 @@
+<?php
+// src/model/entities/Node.php
+
+declare(strict_types=1);
+
+namespace App\Entity;
+
+use Config;
+use Doctrine\ORM\Mapping as ORM;
+
+#[ORM\Entity]
+#[ORM\Table(name: TABLE_PREFIX . "node")]
+class Node
+{
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    #[ORM\Column(type: "integer")]
+    private int $id_node;
+
+    #[ORM\Column(type: "string", length: 255)]
+    private string $name_node;
+
+    #[ORM\Column(type: "string", length: 255, unique: true, nullable: true)]
+    private ?string $article_timestamp;
+
+    #[ORM\Column(type: "json", nullable: true)] // type: "json" crée un longtext avec mariadb
+    private ?array $attributes = null;
+
+    #[ORM\Column(type: "integer")]
+    private int $position;
+
+    #[ORM\ManyToOne(targetEntity: self::class)]
+    //#[ORM\ManyToOne(targetEntity: self::class, fetch: 'EAGER')] // À TESTER
+    #[ORM\JoinColumn(name: "parent_id", referencedColumnName: "id_node", onDelete: "SET NULL", nullable: true)]
+    private ?self $parent = null;
+
+    #[ORM\ManyToOne(targetEntity: Page::class)]
+    #[ORM\JoinColumn(name: "page_id", referencedColumnName: "id_page", onDelete: "SET DEFAULT", nullable: true)]
+    private ?Page $page;
+
+    #[ORM\ManyToOne(targetEntity: Article::class, cascade: ['persist'])]
+    #[ORM\JoinColumn(name: "article_id", referencedColumnName: "id_article", onDelete: "SET NULL", nullable: true)]
+    private ?Article $article = null;
+
+    // propriété non mappée dans la table "node", la jointure est décrite dans NodeData
+    // elle sert à persister ou supprimer des données par cascade
+    // "mappedBy" permet de cibler $node dans l'autre classe, qui elle possède un "inversedBy"
+    #[ORM\OneToOne(targetEntity: NodeData::class, mappedBy: "node", cascade: ['persist', 'remove'])]
+    private ?NodeData $node_data = null;
+
+
+    // -- fin des attributs destinés à doctrine, début du code utilisateur --
+    
+    private array $children = []; // tableau de Node
+    private ?self $temp_child = null; // = "new" est l'enfant de "main" lorsque la page est "article"
+
+    public function __construct(string $name = '', ?string $article_timestamp = null, array $attributes = [], int $position = 0, ?self $parent = null, ?Page $page = null, ?Article $article = null)
+    {
+        $this->name_node = $name;
+        $this->article_timestamp = $article_timestamp;
+        $this->attributes = $attributes;
+        $this->position = $position;
+        $this->parent = $parent;
+        $this->page = $page;
+        $this->article = $article;
+    }
+
+    public function addChild(self $child): void
+    {
+        $this->children[] = $child;
+        $this->sortChildren();
+    }
+
+    // utiliser $position pour afficher les éléments dans l'ordre
+    private function sortChildren(): void
+    {
+        $iteration = count($this->children);
+        while($iteration > 1)
+        {
+            for($i = 0; $i < $iteration - 1; $i++)
+            {
+                //echo '<br>' . $this->children[$i]->getPosition() . ' - ' . $this->children[$i + 1]->getPosition();
+                if($this->children[$i]->getPosition() > $this->children[$i + 1]->getPosition())
+                {
+                    $tmp = $this->children[$i];
+                    $this->children[$i] = $this->children[$i + 1];
+                    $this->children[$i + 1] = $tmp;
+                }
+            }
+            $iteration--;
+        }
+    }
+
+    // pfff...
+    public function getId(): int
+    {
+        return $this->id_node;
+    }
+    public function getName(): string
+    {
+        return $this->name_node;
+    }
+    /*public function setName(string $name): void
+    {
+        $this->name_node = $name;
+    }*/
+    public function getArticleTimestamp(): string
+    {
+        return $this->article_timestamp;
+    }
+    public function getAttributes(): array
+    {
+        return $this->attributes;
+    }
+    /*public function setAttributes(array $attributes): void
+    {
+        $this->attributes = $attributes;
+    }*/
+    public function getParent(): ?self
+    {
+        return $this->parent;
+    }
+    /*public function setParent(?self $parent): void
+    {
+        $this->parent = $parent;
+    }*/
+    public function getPosition(): int
+    {
+        return $this->position;
+    }
+    /*public function setPosition(int $position): void
+    {
+        $this->position = $position;
+    }*/
+    public function getPage(): Page
+    {
+        return $this->page;
+    }
+    /*public function setPage(Page $page): void
+    {
+        $this->page = $page;
+    }*/
+    public function getArticle(): Article
+    {
+        return $this->article;
+    }
+    /*public function setArticle(Article $article): void
+    {
+        $this->article = $article;
+    }*/
+    public function getNodeData(): ?NodeData
+    {
+        return $this->node_data;
+    }
+    public function getChildren(): array
+    {
+        return $this->children;
+    }
+
+    public function getTempChild(): ?self // peut renvoyer null
+    {
+        return $this->temp_child;
+    }
+    public function setTempChild(self $child): void
+    {
+        $this->temp_child = $child;
+    }
+}
diff --git a/src/model/entities/NodeData.php b/src/model/entities/NodeData.php
new file mode 100644
index 0000000..ddf6083
--- /dev/null
+++ b/src/model/entities/NodeData.php
@@ -0,0 +1,62 @@
+<?php
+// src/model/entities/NodeData.php
+
+declare(strict_types=1);
+
+namespace App\Entity;
+
+use Doctrine\ORM\Mapping as ORM;
+use Doctrine\Common\Collections\ArrayCollection; // classe
+use Doctrine\Common\Collections\Collection; // interface
+
+#[ORM\Entity]
+#[ORM\Table(name: TABLE_PREFIX . "node_data")]
+class NodeData
+{
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    #[ORM\Column(type: "integer")]
+    private int $id_node_data;
+
+    // onDelete: "CASCADE" supprime les données si le noeud est supprimé
+    // inverseBy fait le lien avec $node_data dans Node (qui a "mappedBy")
+    #[ORM\OneToOne(targetEntity: Node::class, inversedBy: "node_data")]
+    #[ORM\JoinColumn(name: "node_id", referencedColumnName: "id_node", onDelete: "CASCADE")]
+    private Node $node;
+
+    #[ORM\Column(type: "json")]
+    private array $data;
+
+    // liaison avec table intermédiaire
+    #[ORM\ManyToMany(targetEntity: Image::class, inversedBy: "id_image")]
+    #[ORM\JoinTable(
+        name: "nb_node_image",
+        joinColumns: [new ORM\JoinColumn(name: "node_data_id", referencedColumnName: "id_node_data", onDelete: "CASCADE")],
+        inverseJoinColumns: [new ORM\JoinColumn(name: "image_id", referencedColumnName: "id_image", onDelete: "CASCADE")]
+    )]
+    private Collection $images;
+
+    public function __construct(array $data, Node $node, Collection $images = new ArrayCollection)
+    {
+        $this->data = $data;
+        $this->node = $node;
+        $this->images = $images;
+    }
+
+    public function getData(): array
+    {
+        return $this->data;
+    }
+    /*public function setData(array $data): void
+    {
+        $this->data = $data;
+    }
+    public function setNode(Node $node): void
+    {
+        $this->node = $node;
+    }*/
+    public function getImages(): Collection
+    {
+        return $this->images;
+    }
+}
diff --git a/src/model/entities/Page.php b/src/model/entities/Page.php
new file mode 100644
index 0000000..d7d8098
--- /dev/null
+++ b/src/model/entities/Page.php
@@ -0,0 +1,97 @@
+<?php
+// src/model/entities/Page.php
+
+declare(strict_types=1);
+
+namespace App\Entity;
+
+use Doctrine\ORM\Mapping as ORM;
+use Doctrine\Common\Collections\Collection;
+use Doctrine\Common\Collections\ArrayCollection;
+
+#[ORM\Entity]
+#[ORM\Table(name: TABLE_PREFIX . "page")]
+class Page
+{
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    #[ORM\Column(type: "integer")]
+    private int $id_page;
+    
+    #[ORM\Column(type: "string", length: 255)]
+    private string $name_page;
+
+    #[ORM\Column(type: "string", length: 255)]
+    private string $end_of_path; // morceau d'URL plus exactement
+
+    private string $page_path;
+
+    #[ORM\Column(type: "boolean")]
+    private bool $reachable;
+
+    #[ORM\Column(type: "boolean")]
+    private bool $in_menu;
+
+    #[ORM\ManyToOne(targetEntity: self::class)]
+    #[ORM\JoinColumn(name: "parent_id", referencedColumnName: "id_page", onDelete: "SET NULL", nullable: true)]
+    private ?self $parent = null;
+
+    #[ORM\OneToMany(targetEntity: self::class, mappedBy: 'parent')]
+    protected Collection $children;
+    
+    /*#[ORM\Column(type: "json", nullable: true)]
+    private ?array $metadata = null;*/
+
+    public function __construct(string $name, string $eop, bool $reachable, bool $in_menu, ?Page $parent)
+    {
+        $this->name_page = $name;
+        $this->end_of_path = $eop;
+        $this->reachable = $reachable;
+        $this->in_menu = $in_menu;
+        $this->parent = $parent;
+        $this->children = new ArrayCollection();
+    }
+    
+    // getters
+    /*public function getId(): int
+    {
+        return $this->id_page;
+    }*/
+    public function getPageName(): string
+    {
+        return $this->name_page;
+    }
+    public function getPagePath(): string
+    {
+        return $this->page_path;
+    }
+    public function getEndOfPath(): string
+    {
+        return $this->end_of_path;
+    }
+    public function getInMenu(): bool
+    {
+        return $this->in_menu;
+    }
+    public function getParent(): ?Page
+    {
+        return $this->parent;
+    }
+    public function getChildren(): Collection
+    {
+        return $this->children;
+    }
+
+    public function fillChildrenPagePath(string $parent_path = ''): void
+    {
+        $this->page_path = $parent_path != '' ? $parent_path . '/' . $this->end_of_path : $this->end_of_path;
+        foreach($this->getChildren() as $page){
+            $page->fillChildrenPagePath($this->page_path);
+        }
+    }
+
+    public function addChild(self $child): void
+    {
+        $this->children[] = $child;
+    }
+}
diff --git a/src/model/entities/User.php b/src/model/entities/User.php
new file mode 100644
index 0000000..4b1dcb8
--- /dev/null
+++ b/src/model/entities/User.php
@@ -0,0 +1,47 @@
+<?php
+// src/model/entities/User.php
+
+declare(strict_types=1);
+
+namespace App\Entity;
+
+use Doctrine\ORM\Mapping as ORM;
+
+#[ORM\Entity]
+#[ORM\Table(name: TABLE_PREFIX . "user")]
+class User
+{
+    #[ORM\Id]
+    #[ORM\GeneratedValue]
+    #[ORM\Column(type: "integer")]
+    private int $id_user;
+
+    /*#[ORM\Column(type: "string", length: 255)]
+    private string $name;*/
+
+    #[ORM\Column(type: "string", length: 255, unique: true)] // risque de modifier son mot de passe sans s'apercevoir qu'il fonctionne encore sur un autre compte
+    private string $login;
+
+    #[ORM\Column(type: "string", length: 255)]
+    private string $password;
+
+    public function __construct(string $login, string $password)
+    {
+        $this->login = $login;
+        $this->password = $password;
+    }
+
+    public function getLogin(): string
+    {
+        return $this->login;
+    }
+    public function getPassword(): string
+    {
+        return $this->password;
+    }
+
+    public function setPassword(string $password): void
+    {
+        $this->password = $password;
+    }
+}
\ No newline at end of file