src/Entity/Objet.php line 19

Open in your IDE?
  1. <?php
  2. // src/Entity/Objet.php
  4. namespace App\Entity;
  6. use App\Repository\ObjetRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\DBAL\Types\Types;
  10. use Doctrine\ORM\Mapping as ORM;
  12. #[ORM\Entity(repositoryClass: ObjetRepository::class)]
  13. #[ORM\Table(name: 'objet')]
  14. #[ORM\UniqueConstraint(
  15.     name: 'uniq_objet_type_num',
  16.     columns: ['objet_type_id', 'numero']
  17. )]
  18. #[ORM\HasLifecycleCallbacks]
  19. class Objet
  20. {
  21.     #[ORM\Id]
  22.     #[ORM\GeneratedValue]
  23.     #[ORM\Column]
  24.     private ?int $id = null;
  26.     #[ORM\ManyToOne(inversedBy: 'objets')]
  27.     private ?Contact $contact = null;
  29.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  30.     private ?\DateTimeInterface $date_creation = null;
  32.     #[ORM\Column(name: 'date_modification', type: Types::DATETIME_MUTABLE, nullable: true)]
  33.     private ?\DateTimeInterface $datemodification = null;
  35.     #[ORM\OneToMany(mappedBy: 'objet', targetEntity: Dossier::class, cascade: ['remove'])]
  36.     private Collection $dossiers;
  38.     #[ORM\OneToMany(mappedBy: 'objet', targetEntity: VariableValue::class)]
  39.     private Collection $variableValues;
  41.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'objets')]
  42.     private ?Objet $objet = null;
  44.     #[ORM\OneToMany(mappedBy: 'objet', targetEntity: self::class, cascade: ['remove'])]
  45.     private Collection $objets;
  47.     #[ORM\ManyToOne(targetEntity: ObjetType::class, inversedBy: 'objets')]
  48.     #[ORM\JoinColumn(onDelete: 'CASCADE', nullable: true)]
  49.     private ?ObjetType $objet_type = null;
  51.     #[ORM\ManyToOne(inversedBy: 'objets')]
  52.     private ?User $utilisateur = null;
  54.     #[ORM\OneToMany(mappedBy: 'objet', targetEntity: Fichier::class)]
  55.     private Collection $fichiers;
  57.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  58.     private ?string $path = null;
  60.     #[ORM\Column(type: Types::INTEGER, options: ['default' => 1])]
  61.     private int $etat = 1;
  63.     #[ORM\Column(type: Types::BIGINT, nullable: true)]
  64.     private ?string $numero = null;
  66.     #[ORM\Column(type: Types::JSON, nullable: true)]
  67.     private ?array $data = null;
  70.     private ?array $groupObjetTypeVariables = null;
  71.     private ?array $groupContactVariables = null;
  72.     private ?array $ancestors = null;
  74.     public function __construct()
  75.     {
  76.         $this->dossiers = new ArrayCollection();
  77.         $this->variableValues = new ArrayCollection();
  78.         $this->fichiers = new ArrayCollection();
  79.         $this->objets = new ArrayCollection();
  80.     }
  82.     // ---------------------
  83.     // Getters & Setters
  84.     // ---------------------
  86.     public function getId(): ?int
  87.     {
  88.         return $this->id;
  89.     }
  91.     public function getContact(): ?Contact
  92.     {
  93.         return $this->contact;
  94.     }
  96.     public function setContact(?Contact $contact): static
  97.     {
  98.         $this->contact = $contact;
  99.         return $this;
  100.     }
  103.     public function getDateCreation(): ?\DateTimeInterface
  104.     {
  105.         return $this->date_creation;
  106.     }
  108.     public function setDateCreation(\DateTimeInterface $date_creation): static
  109.     {
  110.         $this->date_creation = $date_creation;
  111.         return $this;
  112.     }
  114.     public function getDatemodification(): ?\DateTimeInterface
  115.     {
  116.         return $this->datemodification;
  117.     }
  119.     public function setDatemodification(?\DateTimeInterface $datemodification): static
  120.     {
  121.         $this->datemodification = $datemodification;
  122.         return $this;
  123.     }
  125.     /**
  126.      * @return Collection<int, Dossier>
  127.      */
  128.     public function getDossiers(): Collection
  129.     {
  130.         return $this->dossiers;
  131.     }
  133.     public function addDossier(Dossier $dossier): static
  134.     {
  135.         if (!$this->dossiers->contains($dossier)) {
  136.             $this->dossiers->add($dossier);
  137.             $dossier->setObjet($this);
  138.         }
  140.         return $this;
  141.     }
  143.     public function removeDossier(Dossier $dossier): static
  144.     {
  145.         if ($this->dossiers->removeElement($dossier)) {
  146.             if ($dossier->getObjet() === $this) {
  147.                 $dossier->setObjet(null);
  148.             }
  149.         }
  151.         return $this;
  152.     }
  154.     /**
  155.      * @return Collection<int, VariableValue>
  156.      */
  157.     public function getVariableValues(): Collection
  158.     {
  159.         return $this->variableValues;
  160.     }
  162.     public function addVariableValue(VariableValue $variableValue): static
  163.     {
  164.         if (!$this->variableValues->contains($variableValue)) {
  165.             $this->variableValues->add($variableValue);
  166.             $variableValue->setObjet($this);
  167.         }
  169.         return $this;
  170.     }
  172.     public function removeVariableValue(VariableValue $variableValue): static
  173.     {
  174.         if ($this->variableValues->removeElement($variableValue)) {
  175.             if ($variableValue->getObjet() === $this) {
  176.                 $variableValue->setObjet(null);
  177.             }
  178.         }
  180.         return $this;
  181.     }
  183.     public function getObjet(): ?self
  184.     {
  185.         return $this->objet;
  186.     }
  188.     public function setObjet(?self $objet): static
  189.     {
  190.         $this->objet = $objet;
  191.         return $this;
  192.     }
  194.     public function setObjets(Collection $objets): static
  195.     {
  196.         $this->objets = $objets;
  197.         return $this;
  198.     }
  200.     /**
  201.      * @return Collection<int, self>
  202.      */
  203.     public function getObjets(): Collection
  204.     {
  205.         return $this->objets;
  206.     }
  208.     public function addObjet(self $objet): static
  209.     {
  210.         if (!$this->objets->contains($objet)) {
  211.             $this->objets->add($objet);
  212.             $objet->setObjet($this);
  213.         }
  215.         return $this;
  216.     }
  218.     public function removeObjet(self $objet): static
  219.     {
  220.         if ($this->objets->removeElement($objet)) {
  221.             if ($objet->getObjet() === $this) {
  222.                 $objet->setObjet(null);
  223.             }
  224.         }
  226.         return $this;
  227.     }
  229.     public function getObjetType(): ?ObjetType
  230.     {
  231.         return $this->objet_type;
  232.     }
  234.     public function setObjetType(?ObjetType $objet_type): static
  235.     {
  236.         $this->objet_type = $objet_type;
  237.         return $this;
  238.     }
  240.     public function getUtilisateur(): ?User
  241.     {
  242.         return $this->utilisateur;
  243.     }
  245.     public function setUtilisateur(?User $utilisateur): static
  246.     {
  247.         $this->utilisateur = $utilisateur;
  248.         return $this;
  249.     }
  250.     
  251.     /**
  252.      * @return Collection<int, Fichier>
  253.      */
  254.     public function getFichiers(): Collection
  255.     {
  256.         return $this->fichiers;
  257.     }
  259.     public function addFichier(Fichier $fichier): static
  260.     {
  261.         if (!$this->fichiers->contains($fichier)) {
  262.             $this->fichiers->add($fichier);
  263.             $fichier->setObjet($this);
  264.         }
  266.         return $this;
  267.     }
  269.     public function removeFichier(Fichier $fichier): static
  270.     {
  271.         if ($this->fichiers->removeElement($fichier)) {
  272.             if ($fichier->getObjet() === $this) {
  273.                 $fichier->setObjet(null);
  274.             }
  275.         }
  277.         return $this;
  278.     }
  280.     // ---------------------
  281.     // Path logic
  282.     // ---------------------
  284.     public function getPath(): ?string
  285.     {
  286.         return $this->path;
  287.     }
  289.     public function setPath(?string $path): static
  290.     {
  291.         $this->path = $path;
  292.         return $this;
  293.     }
  295.     public function computePath(): void
  296.     {
  297.         $ids = [];
  298.         $parent = $this->getObjet();
  300.         while ($parent !== null) {
  301.             $ids[] = $parent->getId();
  302.             $parent = $parent->getObjet();
  303.         }
  305.         $ids = array_reverse($ids);
  306.         $ids[] = $this->getId();
  308.         $this->path = implode(',', $ids);
  309.     }
  311.     /**
  312.      * Set grouped objet type variables
  313.      */
  314.     public function setGroupObjetTypeVariables(?array $groupObjetTypeVariables): self
  315.     {
  316.         $this->groupObjetTypeVariables = $groupObjetTypeVariables;
  317.         return $this;
  318.     }
  320.     /**
  321.      * Get grouped objet type variables
  322.      * Access in Twig: {{ objet.groupObjetTypeVariables }}
  323.      * Lazily computes from objetType if not already set
  324.      */
  325.     public function getGroupObjetTypeVariables(): ?array
  326.     {
  327.         if ($this->groupObjetTypeVariables === null && $this->objet_type !== null) {
  328.             $liaisons = $this->objet_type->getAttributGroupeLiaisons();
  329.             if ($liaisons !== null && !$liaisons->isEmpty()) {
  330.                 $this->groupObjetTypeVariables = $this->groupAndSortByColonneFromLiaisons($liaisons->toArray());
  331.             }
  332.         }
  333.         return $this->groupObjetTypeVariables;
  334.     }
  336.     /**
  337.      * Set grouped contact variables
  338.      */
  339.     public function setGroupContactVariables(?array $groupContactVariables): self
  340.     {
  341.         $this->groupContactVariables = $groupContactVariables;
  342.         return $this;
  343.     }
  345.     /**
  346.      * Get grouped contact variables
  347.      * Access in Twig: {{ objet.groupContactVariables }}
  348.      */
  349.     public function getGroupContactVariables(): ?array
  350.     {
  351.         return $this->groupContactVariables;
  352.     }
  354.     /**
  355.      * Set ancestors chain
  356.      */
  357.     public function setAncestors(?array $ancestors): self
  358.     {
  359.         $this->ancestors = $ancestors;
  360.         return $this;
  361.     }
  363.     /**
  364.      * Get ancestors
  365.      * Access in Twig: {{ objet.ancestors }}
  366.      */
  367.     public function getAncestors(): ?array
  368.     {
  369.         return $this->ancestors;
  370.     }
  372.     /**
  373.      * Group and sort variables by colonne from liaisons (used by repository)
  374.      */
  375.     public function getVariablesGroupedByColonneFromLiaisons(array $liaisons): array
  376.     {
  377.         return $this->groupAndSortByColonneFromLiaisons($liaisons);
  378.     }
  380.     /**
  381.      * Group and sort contact variables by colonne from liaisons (used by repository)
  382.      */
  383.     public function getContactVariablesGroupedByColonneFromLiaisons(array $liaisons): array
  384.     {
  385.         return $this->groupAndSortByColonneFromLiaisons($liaisons);
  386.     }
  388.     /**
  389.      * Group and sort variables by colonne (legacy - used by repository)
  390.      */
  391.     public function getVariablesGroupedByColonne(array $variablesGroups): array
  392.     {
  393.         return $this->groupAndSortByColonne($variablesGroups);
  394.     }
  396.     /**
  397.      * Group and sort contact variables by colonne (legacy - used by repository)
  398.      */
  399.     public function getContactVariablesGroupedByColonne(array $variablesGroups): array
  400.     {
  401.         return $this->groupAndSortByColonne($variablesGroups);
  402.     }
  404.     /**
  405.      * Helper: Group and sort VariablesGroups by colonne using liaisons
  406.      */
  407.     private function groupAndSortByColonneFromLiaisons(array $liaisons): array
  408.     {
  409.         $grouped = [];
  411.         foreach ($liaisons as $liaison) {
  412.             $colonne = $liaison->getColonne() ?? 1;
  414.             if (!isset($grouped[$colonne])) {
  415.                 $grouped[$colonne] = [];
  416.             }
  418.             $grouped[$colonne][] = $liaison->getAttributGroupe();
  419.         }
  421.         // Liaisons are already sorted by ordre through the OrderBy annotation
  422.         return $grouped;
  423.     }
  425.     /**
  426.      * Helper: Group and sort VariablesGroups by colonne (legacy - kept for compatibility)
  427.      */
  428.     private function groupAndSortByColonne(array $variablesGroups): array
  429.     {
  430.         // For variables that don't come through liaisons, group them all in colonne 1
  431.         return [1 => $variablesGroups];
  432.     }
  434.     public function getEtat(): int
  435.     {
  436.         return $this->etat;
  437.     }
  439.     public function setEtat(int $etat): static
  440.     {
  441.         $this->etat = $etat;
  442.         return $this;
  443.     }
  445.     public function getNumero(): ?string
  446.     {
  447.         return $this->numero;
  448.     }
  450.     public function setNumero(?string $numero): static
  451.     {
  452.         $this->numero = $numero;
  453.         return $this;
  454.     }
  456.     public function getData(): ?array
  457.     {
  458.         return $this->data;
  459.     }
  461.     public function setData(?array $data): static
  462.     {
  463.         $this->data = $data;
  464.         return $this;
  465.     }
  467.     /**
  468.      * Get the public URL for this object
  469.      *
  470.      * @param string|null $baseUrl Base URL for the application
  471.      * @return string Full URL to object show page
  472.      */
  473.     public function getLienUrl(?string $baseUrl = null): string
  474.     {
  475.         if ($baseUrl === null) {
  476.             // Auto-detect base URL from request if available
  477.             if (isset($_SERVER['HTTP_HOST'])) {
  478.                 $scheme = isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] === 'on' ? 'https' : 'http';
  479.                 $baseUrl = $scheme . '://' . $_SERVER['HTTP_HOST'];
  480.             } else {
  481.                 // Fallback to environment-based URL
  482.                 $env = $_ENV['APP_ENV'] ?? 'dev';
  483.                 $baseUrl = $env === 'prod'
  484.                     ? ($_ENV['APP_URL_PROD'] ?? 'https://evapi.click')
  485.                     : ($_ENV['APP_URL_DEV'] ?? 'http://localhost');
  486.             }
  487.         }
  488.         return rtrim($baseUrl, '/') . '/objet/' . $this->id;
  489.     }
  491.     /**
  492.      * Get QR code as base64 encoded PNG image
  493.      *
  494.      * @param int $size Image size in pixels (default: 150)
  495.      * @return string Base64 encoded PNG image with data URI prefix
  496.      */
  497.     public function getQrCode(int $size = 150): string
  498.     {
  499.         $qrCodeGenerator = new \App\Service\QRCodeGenerator();
  500.         return $qrCodeGenerator->generateBase64($this->getLienUrl(), $size);
  501.     }
  502. }