src/Entity/Objet.php line 20

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\Index(name: 'idx_objet_type_etat_date', columns: ['objet_type_id', 'etat', 'date_creation'])]
  15. #[ORM\UniqueConstraint(
  16.     name: 'uniq_objet_type_num',
  17.     columns: ['objet_type_id', 'numero']
  18. )]
  19. #[ORM\HasLifecycleCallbacks]
  20. class Objet
  21. {
  22.     #[ORM\Id]
  23.     #[ORM\GeneratedValue]
  24.     #[ORM\Column]
  25.     private ?int $id = null;
  27.     #[ORM\ManyToOne(inversedBy: 'objets')]
  28.     private ?Contact $contact = null;
  30.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  31.     private ?\DateTimeInterface $date_creation = null;
  33.     #[ORM\Column(name: 'date_modification', type: Types::DATETIME_MUTABLE, nullable: true)]
  34.     private ?\DateTimeInterface $datemodification = null;
  36.     #[ORM\OneToMany(mappedBy: 'objet', targetEntity: Dossier::class, cascade: ['remove'])]
  37.     private Collection $dossiers;
  39.     #[ORM\OneToMany(mappedBy: 'objet', targetEntity: VariableValue::class)]
  40.     private Collection $variableValues;
  42.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'objets')]
  43.     private ?Objet $objet = null;
  45.     #[ORM\OneToMany(mappedBy: 'objet', targetEntity: self::class, cascade: ['remove'])]
  46.     private Collection $objets;
  48.     #[ORM\ManyToOne(targetEntity: ObjetType::class, inversedBy: 'objets')]
  49.     #[ORM\JoinColumn(onDelete: 'CASCADE', nullable: true)]
  50.     private ?ObjetType $objet_type = null;
  52.     #[ORM\ManyToOne(inversedBy: 'objets')]
  53.     private ?User $utilisateur = null;
  55.     #[ORM\OneToMany(mappedBy: 'objet', targetEntity: Fichier::class)]
  56.     private Collection $fichiers;
  58.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  59.     private ?string $path = null;
  61.     #[ORM\Column(type: Types::INTEGER, options: ['default' => 1])]
  62.     private int $etat = 1;
  64.     #[ORM\Column(type: Types::BIGINT, nullable: true)]
  65.     private ?string $numero = null;
  67.     #[ORM\Column(type: Types::JSON, nullable: true)]
  68.     private ?array $data = null;
  71.     private ?array $groupObjetTypeVariables = null;
  72.     private ?array $groupContactVariables = null;
  73.     private ?array $ancestors = null;
  75.     public function __construct()
  76.     {
  77.         $this->dossiers = new ArrayCollection();
  78.         $this->variableValues = new ArrayCollection();
  79.         $this->fichiers = new ArrayCollection();
  80.         $this->objets = new ArrayCollection();
  81.     }
  83.     // ---------------------
  84.     // Getters & Setters
  85.     // ---------------------
  87.     public function getId(): ?int
  88.     {
  89.         return $this->id;
  90.     }
  92.     public function getContact(): ?Contact
  93.     {
  94.         return $this->contact;
  95.     }
  97.     public function setContact(?Contact $contact): static
  98.     {
  99.         $this->contact = $contact;
  100.         return $this;
  101.     }
  104.     public function getDateCreation(): ?\DateTimeInterface
  105.     {
  106.         return $this->date_creation;
  107.     }
  109.     public function setDateCreation(\DateTimeInterface $date_creation): static
  110.     {
  111.         $this->date_creation = $date_creation;
  112.         return $this;
  113.     }
  115.     public function getDatemodification(): ?\DateTimeInterface
  116.     {
  117.         return $this->datemodification;
  118.     }
  120.     public function setDatemodification(?\DateTimeInterface $datemodification): static
  121.     {
  122.         $this->datemodification = $datemodification;
  123.         return $this;
  124.     }
  126.     /**
  127.      * @return Collection<int, Dossier>
  128.      */
  129.     public function getDossiers(): Collection
  130.     {
  131.         return $this->dossiers;
  132.     }
  134.     public function addDossier(Dossier $dossier): static
  135.     {
  136.         if (!$this->dossiers->contains($dossier)) {
  137.             $this->dossiers->add($dossier);
  138.             $dossier->setObjet($this);
  139.         }
  141.         return $this;
  142.     }
  144.     public function removeDossier(Dossier $dossier): static
  145.     {
  146.         if ($this->dossiers->removeElement($dossier)) {
  147.             if ($dossier->getObjet() === $this) {
  148.                 $dossier->setObjet(null);
  149.             }
  150.         }
  152.         return $this;
  153.     }
  155.     /**
  156.      * @return Collection<int, VariableValue>
  157.      */
  158.     public function getVariableValues(): Collection
  159.     {
  160.         return $this->variableValues;
  161.     }
  163.     public function addVariableValue(VariableValue $variableValue): static
  164.     {
  165.         if (!$this->variableValues->contains($variableValue)) {
  166.             $this->variableValues->add($variableValue);
  167.             $variableValue->setObjet($this);
  168.         }
  170.         return $this;
  171.     }
  173.     public function removeVariableValue(VariableValue $variableValue): static
  174.     {
  175.         if ($this->variableValues->removeElement($variableValue)) {
  176.             if ($variableValue->getObjet() === $this) {
  177.                 $variableValue->setObjet(null);
  178.             }
  179.         }
  181.         return $this;
  182.     }
  184.     public function getObjet(): ?self
  185.     {
  186.         return $this->objet;
  187.     }
  189.     public function setObjet(?self $objet): static
  190.     {
  191.         $this->objet = $objet;
  192.         return $this;
  193.     }
  195.     public function setObjets(Collection $objets): static
  196.     {
  197.         $this->objets = $objets;
  198.         return $this;
  199.     }
  201.     /**
  202.      * @return Collection<int, self>
  203.      */
  204.     public function getObjets(): Collection
  205.     {
  206.         return $this->objets;
  207.     }
  209.     public function addObjet(self $objet): static
  210.     {
  211.         if (!$this->objets->contains($objet)) {
  212.             $this->objets->add($objet);
  213.             $objet->setObjet($this);
  214.         }
  216.         return $this;
  217.     }
  219.     public function removeObjet(self $objet): static
  220.     {
  221.         if ($this->objets->removeElement($objet)) {
  222.             if ($objet->getObjet() === $this) {
  223.                 $objet->setObjet(null);
  224.             }
  225.         }
  227.         return $this;
  228.     }
  230.     public function getObjetType(): ?ObjetType
  231.     {
  232.         return $this->objet_type;
  233.     }
  235.     public function setObjetType(?ObjetType $objet_type): static
  236.     {
  237.         $this->objet_type = $objet_type;
  238.         return $this;
  239.     }
  241.     public function getUtilisateur(): ?User
  242.     {
  243.         return $this->utilisateur;
  244.     }
  246.     public function setUtilisateur(?User $utilisateur): static
  247.     {
  248.         $this->utilisateur = $utilisateur;
  249.         return $this;
  250.     }
  251.     
  252.     /**
  253.      * @return Collection<int, Fichier>
  254.      */
  255.     public function getFichiers(): Collection
  256.     {
  257.         return $this->fichiers;
  258.     }
  260.     public function addFichier(Fichier $fichier): static
  261.     {
  262.         if (!$this->fichiers->contains($fichier)) {
  263.             $this->fichiers->add($fichier);
  264.             $fichier->setObjet($this);
  265.         }
  267.         return $this;
  268.     }
  270.     public function removeFichier(Fichier $fichier): static
  271.     {
  272.         if ($this->fichiers->removeElement($fichier)) {
  273.             if ($fichier->getObjet() === $this) {
  274.                 $fichier->setObjet(null);
  275.             }
  276.         }
  278.         return $this;
  279.     }
  281.     // ---------------------
  282.     // Path logic
  283.     // ---------------------
  285.     public function getPath(): ?string
  286.     {
  287.         return $this->path;
  288.     }
  290.     public function setPath(?string $path): static
  291.     {
  292.         $this->path = $path;
  293.         return $this;
  294.     }
  296.     public function computePath(): void
  297.     {
  298.         $ids = [];
  299.         $parent = $this->getObjet();
  301.         while ($parent !== null) {
  302.             $ids[] = $parent->getId();
  303.             $parent = $parent->getObjet();
  304.         }
  306.         $ids = array_reverse($ids);
  307.         $ids[] = $this->getId();
  309.         $this->path = implode(',', $ids);
  310.     }
  312.     /**
  313.      * Set grouped objet type variables
  314.      */
  315.     public function setGroupObjetTypeVariables(?array $groupObjetTypeVariables): self
  316.     {
  317.         $this->groupObjetTypeVariables = $groupObjetTypeVariables;
  318.         return $this;
  319.     }
  321.     /**
  322.      * Get grouped objet type variables
  323.      * Access in Twig: {{ objet.groupObjetTypeVariables }}
  324.      * Lazily computes from objetType if not already set
  325.      */
  326.     public function getGroupObjetTypeVariables(): ?array
  327.     {
  328.         if ($this->groupObjetTypeVariables === null && $this->objet_type !== null) {
  329.             $liaisons = $this->objet_type->getAttributGroupeLiaisons();
  330.             if ($liaisons !== null && !$liaisons->isEmpty()) {
  331.                 $this->groupObjetTypeVariables = $this->groupAndSortByColonneFromLiaisons($liaisons->toArray());
  332.             }
  333.         }
  334.         return $this->groupObjetTypeVariables;
  335.     }
  337.     /**
  338.      * Set grouped contact variables
  339.      */
  340.     public function setGroupContactVariables(?array $groupContactVariables): self
  341.     {
  342.         $this->groupContactVariables = $groupContactVariables;
  343.         return $this;
  344.     }
  346.     /**
  347.      * Get grouped contact variables
  348.      * Access in Twig: {{ objet.groupContactVariables }}
  349.      */
  350.     public function getGroupContactVariables(): ?array
  351.     {
  352.         return $this->groupContactVariables;
  353.     }
  355.     /**
  356.      * Set ancestors chain
  357.      */
  358.     public function setAncestors(?array $ancestors): self
  359.     {
  360.         $this->ancestors = $ancestors;
  361.         return $this;
  362.     }
  364.     /**
  365.      * Get ancestors
  366.      * Access in Twig: {{ objet.ancestors }}
  367.      */
  368.     public function getAncestors(): ?array
  369.     {
  370.         return $this->ancestors;
  371.     }
  373.     /**
  374.      * Group and sort variables by colonne from liaisons (used by repository)
  375.      */
  376.     public function getVariablesGroupedByColonneFromLiaisons(array $liaisons): array
  377.     {
  378.         return $this->groupAndSortByColonneFromLiaisons($liaisons);
  379.     }
  381.     /**
  382.      * Group and sort contact variables by colonne from liaisons (used by repository)
  383.      */
  384.     public function getContactVariablesGroupedByColonneFromLiaisons(array $liaisons): array
  385.     {
  386.         return $this->groupAndSortByColonneFromLiaisons($liaisons);
  387.     }
  389.     /**
  390.      * Group and sort variables by colonne (legacy - used by repository)
  391.      */
  392.     public function getVariablesGroupedByColonne(array $variablesGroups): array
  393.     {
  394.         return $this->groupAndSortByColonne($variablesGroups);
  395.     }
  397.     /**
  398.      * Group and sort contact variables by colonne (legacy - used by repository)
  399.      */
  400.     public function getContactVariablesGroupedByColonne(array $variablesGroups): array
  401.     {
  402.         return $this->groupAndSortByColonne($variablesGroups);
  403.     }
  405.     /**
  406.      * Helper: Group and sort VariablesGroups by colonne using liaisons
  407.      */
  408.     private function groupAndSortByColonneFromLiaisons(array $liaisons): array
  409.     {
  410.         $grouped = [];
  412.         foreach ($liaisons as $liaison) {
  413.             $colonne = $liaison->getColonne() ?? 1;
  415.             if (!isset($grouped[$colonne])) {
  416.                 $grouped[$colonne] = [];
  417.             }
  419.             $grouped[$colonne][] = $liaison->getAttributGroupe();
  420.         }
  422.         // Liaisons are already sorted by ordre through the OrderBy annotation
  423.         return $grouped;
  424.     }
  426.     /**
  427.      * Helper: Group and sort VariablesGroups by colonne (legacy - kept for compatibility)
  428.      */
  429.     private function groupAndSortByColonne(array $variablesGroups): array
  430.     {
  431.         // For variables that don't come through liaisons, group them all in colonne 1
  432.         return [1 => $variablesGroups];
  433.     }
  435.     public function getEtat(): int
  436.     {
  437.         return $this->etat;
  438.     }
  440.     public function setEtat(int $etat): static
  441.     {
  442.         $this->etat = $etat;
  443.         return $this;
  444.     }
  446.     public function getNumero(): ?string
  447.     {
  448.         return $this->numero;
  449.     }
  451.     public function setNumero(?string $numero): static
  452.     {
  453.         $this->numero = $numero;
  454.         return $this;
  455.     }
  457.     public function getData(): ?array
  458.     {
  459.         return $this->data;
  460.     }
  462.     public function setData(?array $data): static
  463.     {
  464.         $this->data = $data;
  465.         return $this;
  466.     }
  468.     /**
  469.      * Get the public URL for this object
  470.      *
  471.      * @param string|null $baseUrl Base URL for the application
  472.      * @return string Full URL to object show page
  473.      */
  474.     public function getLienUrl(?string $baseUrl = null): string
  475.     {
  476.         if ($baseUrl === null) {
  477.             // Auto-detect base URL from request if available
  478.             if (isset($_SERVER['HTTP_HOST'])) {
  479.                 $scheme = isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] === 'on' ? 'https' : 'http';
  480.                 $baseUrl = $scheme . '://' . $_SERVER['HTTP_HOST'];
  481.             } else {
  482.                 // Fallback to environment-based URL
  483.                 $env = $_ENV['APP_ENV'] ?? 'dev';
  484.                 $baseUrl = $env === 'prod'
  485.                     ? ($_ENV['APP_URL_PROD'] ?? 'https://evapi.click')
  486.                     : ($_ENV['APP_URL_DEV'] ?? 'http://localhost');
  487.             }
  488.         }
  489.         return rtrim($baseUrl, '/') . '/objet/' . $this->id;
  490.     }
  492.     /**
  493.      * Get QR code as base64 encoded PNG image
  494.      *
  495.      * @param int $size Image size in pixels (default: 150)
  496.      * @return string Base64 encoded PNG image with data URI prefix
  497.      */
  498.     public function getQrCode(int $size = 150): string
  499.     {
  500.         $qrCodeGenerator = new \App\Service\QRCodeGenerator();
  501.         return $qrCodeGenerator->generateBase64($this->getLienUrl(), $size);
  502.     }
  503. }