entité pour table intermédiaire à 3 champs entre NodeData et Asset, table Asset repensée

5 files changed, 140 insertions, 61 deletions

diff --git a/src/model/Model.php b/src/model/Model.php
index 16061e7..68c4c08 100644
--- a/src/model/Model.php
+++ b/src/model/Model.php
@@ -203,6 +203,17 @@ class Model
             return true;
         }
     }
+    public function getWhatever(string $class, string $field, string $value): array
+    {
+        // penser au entityManager "repository"
+        $queryBuilder = $this->entityManager->createQueryBuilder();
+        $queryBuilder
+            ->select('n')
+            ->from($class, 'n')
+            ->where("n.$field = :value")
+            ->setParameter('value', $value);
+        return $queryBuilder->getQuery()->getResult();
+    }
 
     // récupération d'un article pour modification
     public function makeArticleNode(string $id = '', bool $get_section = false): bool
diff --git a/src/model/entities/Asset.php b/src/model/entities/Asset.php
index e359e21..5400db4 100644
--- a/src/model/entities/Asset.php
+++ b/src/model/entities/Asset.php
@@ -6,6 +6,7 @@ declare(strict_types=1);
 namespace App\Entity;
 
 use Doctrine\ORM\Mapping as ORM;
+use Doctrine\Common\Collections\Collection;
 
 #[ORM\Entity]
 #[ORM\Table(name: TABLE_PREFIX . "asset")]
@@ -13,71 +14,55 @@ class Asset
 {
     const PATH = 'assets/';
     const USER_PATH = 'user_data/assets/';
+    // choisir un répertoire du genre /var/www/html/uploads/? ou au moins hors de /src? j'en sais rien
 
     #[ORM\Id]
     #[ORM\GeneratedValue]
     #[ORM\Column(type: "integer")]
     private int $id_asset;
 
-    #[ORM\Column(type: "string", length: 255, unique: true)] // nom d'image UNIQUE
+    #[ORM\Column(type: "string", length: 255)] // nom de fichier modifié avec uniqid (fichiers différents de même nom)
     private string $file_name;
 
-    // choisir un répertoire du genre /var/www/html/uploads/, au moins hors de /src
-    #[ORM\Column(type: "string", length: 255, unique: true, nullable: true)]
-    private ?string $file_path;
-
     #[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\Column(type: "string", length: 64, unique: true)] // doctrine n'a pas d'équivalent au type CHAR des BDD (on voulait CHAR(64)), c'est pas grave!
+    private string $hash; // pour détecter deux fichiers identiques, même si leurs noms et les métadonnées changent
 
-    #[ORM\ManyToMany(targetEntity: NodeData::class, mappedBy: "assets")]
-    private $node_data;
+    #[ORM\OneToMany(mappedBy: 'asset', targetEntity: NodeDataAsset::class)]
+    private Collection $nda_collection;
 
-    public function __construct(string $name, ?string $path, string $mime_type, string $alt)
+    public function __construct(string $name, string $mime_type, string $hash)
     {
         $this->file_name = $name;
-        $this->file_path = $path;
         $this->mime_type = $mime_type;
-        $this->alt = $alt;
+        $this->hash = $hash;
     }
 
     public function getFileName(): string
     {
         return $this->file_name;
     }
-    public function getFilePath(): string
+    public function setFileName(string $name): void
     {
-        return $this->file_path;
+        $this->file_name = $name;
     }
-    public function getAlt(): string
+    public function getMimeType(): string
     {
-        return $this->alt;
+        return $this->mime_type;
     }
-
-
-    // pour ViewBuilderController?
-    /*public function displayImage($imageId): void
+    public function setMimeType(string $mime_type): void
     {
-        //$imageId = 1; // Exemple d'ID d'image
-        $stmt = $pdo->prepare("SELECT file_path FROM images WHERE id = ?");
-        $stmt->execute([$imageId]);
-        $image = $stmt->fetch();
+        $this->mime_type = $mime_type;
+    }
+    public function getHash(): string
+    {
+        return $this->hash;
+    }
 
-        if ($image) {
-            echo "<img src='" . $image['file_path'] . "' alt='Image'>";
-        } else {
-            echo "Image non trouvée.";
-        }
-    }*/
+    public function getNodeDataAssets(): Collection
+    {
+        return $this->nda_collection;
+    }
 }
diff --git a/src/model/entities/Image.php b/src/model/entities/Image.php
index e867a5f..2ee379a 100644
--- a/src/model/entities/Image.php
+++ b/src/model/entities/Image.php
@@ -5,6 +5,7 @@ declare(strict_types=1);
 
 namespace App\Entity;
 
+use Doctrine\Common\Collections\Collection;
 use Doctrine\ORM\Mapping as ORM;
 
 #[ORM\Entity]
@@ -42,7 +43,7 @@ class Image
     => Enregistrement dans la base de données : On enregistre les informations de l'image dans la base de données. */
 
     #[ORM\ManyToMany(targetEntity: Article::class, mappedBy: "images")]
-    private $article;
+    private Collection $article;
 
     public function __construct(string $name, ?string $path, ?string $path_mini, string $mime_type, string $alt)
     {
diff --git a/src/model/entities/NodeData.php b/src/model/entities/NodeData.php
index 9db866e..47e7208 100644
--- a/src/model/entities/NodeData.php
+++ b/src/model/entities/NodeData.php
@@ -39,21 +39,16 @@ class NodeData
     #[ORM\Column(type: "integer", nullable: true)]
     private ?int $pagination_limit = null; // pour les post_block et news_block
 
-    #[ORM\ManyToMany(targetEntity: Asset::class, inversedBy: "node_data")] // cascade: ['remove'] = très dangereux!
-    #[ORM\JoinTable(
-        name: TABLE_PREFIX . "nodedata_asset",
-        joinColumns: [new ORM\JoinColumn(name: "node_data_id", referencedColumnName: "id_node_data", onDelete: "CASCADE")], // onDelete: "CASCADE": très utile
-        inverseJoinColumns: [new ORM\JoinColumn(name: "asset_id", referencedColumnName: "id_asset", onDelete: "CASCADE")]
-    )]
-    private Collection $assets;
+    #[ORM\OneToMany(mappedBy: 'node_data', targetEntity: NodeDataAsset::class, cascade: ['persist', 'remove'])]
+    private Collection $nda_collection;
 
     private int $nb_pages = 1;
 
-    public function __construct(array $data, Node $node, Collection $assets = new ArrayCollection, ?string $presentation = null, ?bool $chrono_order = null)
+    public function __construct(array $data, Node $node, Collection $nda_collection = new ArrayCollection, ?string $presentation = null, ?bool $chrono_order = null)
     {
         $this->data = $data;
         $this->node = $node;
-        $this->assets = $assets;
+        $this->nda_collection = $nda_collection;
         if(!empty($presentation) && $presentation === 'grid'){
             $this->grid_cols_min_width = 250;
         }
@@ -132,22 +127,54 @@ class NodeData
     {
         $this->node = $node;
     }*/
-    public function getAssets(): Collection
+
+
+    public function getNodeDataAssets(): Collection
     {
-        return $this->assets;
+        return $this->nda_collection;
     }
-    public function addAsset(Asset $asset): void
+    public function getNodeDataAssetByRole(string $role): ?NodeDataAsset
     {
-        if(!$this->assets->contains($asset)){
-            $this->assets->add($asset);
-            //$asset->addNodeData($this); // autre sens
+        foreach($this->nda_collection as $nda){
+            if($nda->getRole() === $role){
+                return $nda;
+            }
         }
+        return null;
     }
-     public function removeAsset(Asset $asset): void
+    public function getAssetByRole(string $role): ?Asset
     {
-        $this->assets->removeElement($asset);
-        /*if($this->assets->removeElement($asset)){ // autre sens
-            $asset->removeNodeData($this);
-        }*/
+        $nda = $this->getNodeDataAssetByRole($role);
+        if($nda === null){
+            return null;
+        }
+        return $nda->getAsset() ?? null;
     }
-}
+    /*public function addNodeDataAsset(NodeDataAsset $nda): self
+    {
+        if(!$this->nda_collection->contains($nda)){ // sécurité contrainte UNIQUE
+            $this->nda_collection->add($nda);
+        }
+        return $this;
+    }*/
+    /*public function removeNodeDataAsset(NodeDataAsset $nda): self // inutile on peut faire: $node_data->getNodeDataAssets()->removeElement($nda);
+    {
+        $this->nda_collection->removeElement($nda);
+        // pas de synchro dans NodeDataAsset, les champs de cette table ne sont pas nullables
+        return $this;
+    }*/
+
+    // LE setter, sélectionne l'asset à utiliser en remplaçant l'entrée dans NodeDataAsset en fonction du rôle
+    // à mettre théoriquement dans une classe metier dans "service"
+    /*public function replaceAssetForRole(string $role, Asset $asset): void
+    {
+        foreach($this->nda_collection as $nda){
+            if($nda->getRole() === $role){
+                $this->removeNodeDataAsset($nda);
+                break;
+            }
+        }
+        $this->new_nda = new NodeDataAsset($this, $asset, $role);
+        $this->addNodeDataAsset($this->new_nda);
+    }*/
+}
\ No newline at end of file
diff --git a/src/model/entities/NodeDataAsset.php b/src/model/entities/NodeDataAsset.php
new file mode 100644
index 0000000..7f7008e
--- /dev/null
+++ b/src/model/entities/NodeDataAsset.php
@@ -0,0 +1,55 @@
+<?php
+// src/model/entities/NodeDataAsset.php
+//
+// entité intermédiaire avec 3 colonnes
+
+declare(strict_types=1);
+
+namespace App\Entity;
+
+use Doctrine\ORM\Mapping as ORM;
+
+#[ORM\Entity]
+#[ORM\Table(name: TABLE_PREFIX . 'nodedata_asset')]
+#[ORM\UniqueConstraint(name: 'unique_role_per_node', columns: ['node_data_id', 'role'])] // un rôle UNIQUE pour chaque node_data_id, excellent!
+class NodeDataAsset
+{
+    // clé primaire double
+    // inconvénient: impossible d'utiliser deux fois la même paire node_data/asset, même pour des rôles différents
+    #[ORM\Id]
+    #[ORM\ManyToOne(targetEntity: NodeData::class, inversedBy: 'nda_collection')]
+    #[ORM\JoinColumn(name: 'node_data_id', referencedColumnName: 'id_node_data', onDelete: 'CASCADE')]
+    private NodeData $node_data;
+
+    #[ORM\Id]
+    #[ORM\ManyToOne(targetEntity: Asset::class)]
+    #[ORM\JoinColumn(name: 'asset_id', referencedColumnName: 'id_asset', onDelete: 'CASCADE')]
+    private Asset $asset;
+
+    #[ORM\Column(type: 'string', length: 50)]
+    private string $role;
+
+    public function __construct(NodeData $node_data, Asset $asset, string $role){
+        $this->node_data = $node_data;
+        $this->asset = $asset;
+        $this->role = $role;
+    }
+
+    /*public function getNodeData(): NodeData
+    {
+        return $this->node_data;
+    }*/
+    public function getAsset(): Asset
+    {
+        return $this->asset;
+    }
+    public function setAsset(Asset $asset): self
+    {
+        $this->asset = $asset;
+        return $this;
+    }
+    public function getRole(): string
+    {
+        return $this->role;
+    }
+}