src/Entity/Contact.php line 13

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\ContactRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  11. #[ORM\Entity(repositoryClass: ContactRepository::class)]
  12. #[ORM\Index(name: 'idx_contact_type_etat_date', columns: ['contact_type_id', 'etat', 'date_creation'])]
  13. class Contact
  14. {
  15.     #[ORM\Id]
  16.     #[ORM\GeneratedValue]
  17.     #[ORM\Column]
  18.     private ?int $id = null;
  20.     #[ORM\Column(length: 255)]
  21.     private ?string $denomination = null;
  23.     #[ORM\Column(length: 9)]
  24.     private ?string $siren = null;
  26.     #[ORM\Column(length: 255)]
  27.     private ?string $nom = null;
  29.     #[ORM\Column(length: 255)]
  30.     private ?string $tel1 = null;
  32.     #[ORM\Column(length: 255)]
  33.     private ?string $email = null;
  35.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  36.     private ?\DateTimeInterface $date_creation = null;
  38.     #[ORM\Column(name: 'date_modification', type: Types::DATETIME_MUTABLE, nullable: true)]
  39.     private ?\DateTimeInterface $datemodification = null;
  41.     #[ORM\Column(type: Types::INTEGER, options: ['default' => 1])]
  42.     private int $etat = 1;
  44.     #[ORM\Column(type: Types::JSON, nullable: true)]
  45.     private ?array $data = null;
  48.     #[ORM\OneToMany(mappedBy: 'contact', targetEntity: Objet::class, cascade: ['remove'])]
  49.     private Collection $objets;
  51.     #[ORM\OneToMany(mappedBy: 'contact', targetEntity: Dossier::class, cascade: ['remove'])]
  52.     private Collection $dossiers;
  54.     #[ORM\ManyToOne(inversedBy: 'contacts')]
  55.     private ?ContactType $contact_type = null;
  57.     #[ORM\OneToMany(mappedBy: 'contact', targetEntity: VariableValue::class, cascade: ['remove'])]
  58.     private Collection $variableValues;
  60.     #[ORM\ManyToOne(inversedBy: 'associatedContacts')]
  61.     #[ORM\JoinColumn(name: "parent_contact_id", referencedColumnName: "id", nullable: true)]
  62.     private ?Contact $parentContact = null;
  64.     #[ORM\OneToMany(mappedBy: 'parentContact', targetEntity: Contact::class, cascade: ['remove'])]
  65.     private Collection $associatedContacts;
  67.     #[ORM\Column(length: 255, nullable: true)]
  68.     private ?string $compte_client = null;
  70.     #[ORM\Column(length: 255, nullable: true)]
  71.     private ?string $tel2 = null;
  73.     #[ORM\Column(length: 255, nullable: true)]
  74.     private ?string $adresse = null;
  76.     #[ORM\Column(length: 255, nullable: true)]
  77.     private ?string $siret = null;
  79.     #[ORM\Column(length: 255, nullable: true)]
  80.     private ?string $poste = null;
  82.     #[ORM\Column(nullable: true)]
  83.     private ?bool $emailing = null;
  85.     #[ORM\Column(nullable: true)]
  86.     private ?bool $antispam = null;
  88.     #[ORM\ManyToOne(inversedBy: 'contacts')]
  89.     private ?User $utilisateur = null;
  91.     #[ORM\OneToMany(mappedBy: 'contact', targetEntity: Fichier::class)]
  92.     private Collection $fichiers;
  94.     public function __construct()
  95.     {
  96.         $this->objets = new ArrayCollection();
  97.         $this->dossiers = new ArrayCollection();
  98.         $this->variableValues = new ArrayCollection();
  99.         $this->associatedContacts = new ArrayCollection();
  100.         $this->fichiers = new ArrayCollection();
  101.     }
  103.     public function getId(): ?int
  104.     {
  105.         return $this->id;
  106.     }
  108.     public function getDenomination(): ?string
  109.     {
  110.         return $this->denomination;
  111.     }
  113.     public function setDenomination(string $denomination): static
  114.     {
  115.         $this->denomination = $denomination;
  117.         return $this;
  118.     }
  120.     public function getSiren(): ?string
  121.     {
  122.         return $this->siren;
  123.     }
  125.     public function setSiren(string $siren): static
  126.     {
  127.         $this->siren = $siren;
  129.         return $this;
  130.     }
  132.     public function getNom(): ?string
  133.     {
  134.         return $this->nom;
  135.     }
  137.     public function setNom(string $nom): static
  138.     {
  139.         $this->nom = $nom;
  141.         return $this;
  142.     }
  144.     public function getTel1(): ?string
  145.     {
  146.         return $this->tel1;
  147.     }
  149.     public function setTel1(string $tel1): static
  150.     {
  151.         $this->tel1 = $tel1;
  153.         return $this;
  154.     }
  156.     public function getEmail(): ?string
  157.     {
  158.         return $this->email;
  159.     }
  161.     public function setEmail(string $email): static
  162.     {
  163.         $this->email = $email;
  165.         return $this;
  166.     }
  168.     public function getDateCreation(): ?\DateTimeInterface
  169.     {
  170.         return $this->date_creation;
  171.     }
  173.     public function setDateCreation(\DateTimeInterface $date_creation): static
  174.     {
  175.         $this->date_creation = $date_creation;
  177.         return $this;
  178.     }
  180.     public function getDatemodification(): ?\DateTimeInterface
  181.     {
  182.         return $this->datemodification;
  183.     }
  185.     public function setDatemodification(?\DateTimeInterface $datemodification): static
  186.     {
  187.         $this->datemodification = $datemodification;
  189.         return $this;
  190.     }
  192.     public function setObjets(Collection $objets): static
  193.     {
  194.         $this->objets = $objets;
  195.         return $this;
  196.     }
  198.     /**
  199.      * @return Collection<int, Objet>
  200.      */
  201.     public function getObjets(): Collection
  202.     {
  203.         return $this->objets;
  204.     }
  206.     /**
  207.      * @return Collection<int, Objet>
  208.      */
  209.     public function getLevelOneObjets(): Collection
  210.     {
  211.         $levelOneObjets = new ArrayCollection();
  213.         foreach ($this->objets as $objet) {
  214.             if (!$objet->getObjet()) {
  215.                 $levelOneObjets->add($objet);
  216.             }
  217.         }
  219.         return $levelOneObjets;
  220.     }
  223.     /**
  224.      * @return Collection<int, Objet>
  225.      */
  226.     public function getObjetsLevelOneObjetType(): Collection
  227.     {
  228.         return $this->objets;
  229.     }
  231.     public function addObjet(Objet $objet): static
  232.     {
  233.         if (!$this->objets->contains($objet)) {
  234.             $this->objets->add($objet);
  235.             $objet->setContact($this);
  236.         }
  238.         return $this;
  239.     }
  241.     public function removeObjet(Objet $objet): static
  242.     {
  243.         if ($this->objets->removeElement($objet)) {
  244.             // set the owning side to null (unless already changed)
  245.             if ($objet->getContact() === $this) {
  246.                 $objet->setContact(null);
  247.             }
  248.         }
  250.         return $this;
  251.     }
  253.     /**
  254.      * @return Collection<int, Dossier>
  255.      */
  256.     public function getDossiers(): Collection
  257.     {
  258.         return $this->dossiers;
  259.     }
  261.     public function addDossier(Dossier $dossier): static
  262.     {
  263.         if (!$this->dossiers->contains($dossier)) {
  264.             $this->dossiers->add($dossier);
  265.             $dossier->setContact($this);
  266.         }
  268.         return $this;
  269.     }
  271.     public function removeDossier(Dossier $dossier): static
  272.     {
  273.         if ($this->dossiers->removeElement($dossier)) {
  274.             // set the owning side to null (unless already changed)
  275.             if ($dossier->getContact() === $this) {
  276.                 $dossier->setContact(null);
  277.             }
  278.         }
  280.         return $this;
  281.     }
  283.     public function getContactType(): ?ContactType
  284.     {
  285.         return $this->contact_type;
  286.     }
  288.     public function setContactType(?ContactType $contact_type): static
  289.     {
  290.         $this->contact_type = $contact_type;
  292.         return $this;
  293.     }
  295.     /**
  296.      * @return Collection<int, VariableValue>
  297.      */
  298.     public function getVariableValues(): Collection
  299.     {
  300.         return $this->variableValues;
  301.     }
  303.     public function addVariableValue(VariableValue $variableValue): static
  304.     {
  305.         if (!$this->variableValues->contains($variableValue)) {
  306.             $this->variableValues->add($variableValue);
  307.             $variableValue->setContact($this);
  308.         }
  310.         return $this;
  311.     }
  313.     public function removeVariableValue(VariableValue $variableValue): static
  314.     {
  315.         if ($this->variableValues->removeElement($variableValue)) {
  316.             // set the owning side to null (unless already changed)
  317.             if ($variableValue->getContact() === $this) {
  318.                 $variableValue->setContact(null);
  319.             }
  320.         }
  322.         return $this;
  323.     }
  325.     public function getParentContact(): ?Contact
  326.     {
  327.         return $this->parentContact;
  328.     }
  330.     public function setParentContact(?Contact $parentContact): static
  331.     {
  332.         $this->parentContact = $parentContact;
  334.         return $this;
  335.     }
  337.     public function setAssociatedContacts(Collection $associatedContacts): static
  338.     {
  339.         $this->associatedContacts = $associatedContacts;
  340.         return $this;
  341.     }
  343.     /**
  344.      * @return Collection<int, Contact>
  345.      */
  346.     public function getAssociatedContacts(): Collection
  347.     {
  348.         return $this->associatedContacts;
  349.     }
  351.     public function addAssociatedContact(Contact $associatedContact): static
  352.     {
  353.         if (!$this->associatedContacts->contains($associatedContact)) {
  354.             $this->associatedContacts->add($associatedContact);
  355.             $associatedContact->setParentContact($this);
  356.         }
  358.         return $this;
  359.     }
  361.     public function removeAssociatedContact(Contact $associatedContact): static
  362.     {
  363.         if ($this->associatedContacts->removeElement($associatedContact)) {
  364.             $associatedContact->setParentContact(null);
  365.         }
  367.         return $this;
  368.     }
  370.     public function getCompteClient(): ?string
  371.     {
  372.         return $this->compte_client;
  373.     }
  375.     public function setCompteClient(?string $compte_client): static
  376.     {
  377.         $this->compte_client = $compte_client;
  379.         return $this;
  380.     }
  382.     public function getTel2(): ?string
  383.     {
  384.         return $this->tel2;
  385.     }
  387.     public function setTel2(?string $tel2): static
  388.     {
  389.         $this->tel2 = $tel2;
  391.         return $this;
  392.     }
  394.     public function getAdresse(): ?string
  395.     {
  396.         return $this->adresse;
  397.     }
  399.     public function setAdresse(?string $adresse): static
  400.     {
  401.         $this->adresse = $adresse;
  403.         return $this;
  404.     }
  406.     public function getSiret(): ?string
  407.     {
  408.         return $this->siret;
  409.     }
  411.     public function setSiret(?string $siret): static
  412.     {
  413.         $this->siret = $siret;
  415.         return $this;
  416.     }
  418.     public function getPoste(): ?string
  419.     {
  420.         return $this->poste;
  421.     }
  423.     public function setPoste(?string $poste): static
  424.     {
  425.         $this->poste = $poste;
  427.         return $this;
  428.     }
  430.     public function isEmailing(): ?bool
  431.     {
  432.         return $this->emailing;
  433.     }
  435.     public function setEmailing(?bool $emailing): static
  436.     {
  437.         $this->emailing = $emailing;
  439.         return $this;
  440.     }
  442.     public function isAntispam(): ?bool
  443.     {
  444.         return $this->antispam;
  445.     }
  447.     public function setAntispam(?bool $antispam): static
  448.     {
  449.         $this->antispam = $antispam;
  451.         return $this;
  452.     }
  454.     public function getUtilisateur(): ?User
  455.     {
  456.         return $this->utilisateur;
  457.     }
  459.     public function setUtilisateur(?User $utilisateur): static
  460.     {
  461.         $this->utilisateur = $utilisateur;
  463.         return $this;
  464.     }
  466.     /**
  467.      * @return Collection<int, Fichier>
  468.      */
  469.     public function getFichiers(): Collection
  470.     {
  471.         return $this->fichiers;
  472.     }
  474.     public function addFichier(Fichier $fichier): static
  475.     {
  476.         if (!$this->fichiers->contains($fichier)) {
  477.             $this->fichiers->add($fichier);
  478.             $fichier->setContact($this);
  479.         }
  481.         return $this;
  482.     }
  484.     public function removeFichier(Fichier $fichier): static
  485.     {
  486.         if ($this->fichiers->removeElement($fichier)) {
  487.             // set the owning side to null (unless already changed)
  488.             if ($fichier->getContact() === $this) {
  489.                 $fichier->setContact(null);
  490.             }
  491.         }
  493.         return $this;
  494.     }
  495.     public function __toString()
  496.     {
  497.         return (string) $this->id;  // Ou une autre propriété qui représente bien l'objet
  498.     }
  500.     public function getEtat(): int
  501.     {
  502.         return $this->etat;
  503.     }
  505.     public function setEtat(int $etat): static
  506.     {
  507.         $this->etat = $etat;
  508.         return $this;
  509.     }
  511.     public function getData(): ?array
  512.     {
  513.         return $this->data;
  514.     }
  516.     public function setData(?array $data): static
  517.     {
  518.         $this->data = $data;
  519.         return $this;
  520.     }
  522.     /**
  523.      * Get the public URL for this contact
  524.      *
  525.      * @param string|null $baseUrl Base URL for the application
  526.      * @return string Full URL to contact show page
  527.      */
  528.     public function getLienUrl(?string $baseUrl = null): string
  529.     {
  530.         if ($baseUrl === null) {
  531.             // Auto-detect base URL from request if available
  532.             if (isset($_SERVER['HTTP_HOST'])) {
  533.                 $scheme = isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] === 'on' ? 'https' : 'http';
  534.                 $baseUrl = $scheme . '://' . $_SERVER['HTTP_HOST'];
  535.             } else {
  536.                 // Fallback to environment-based URL
  537.                 $env = $_ENV['APP_ENV'] ?? 'dev';
  538.                 $baseUrl = $env === 'prod'
  539.                     ? ($_ENV['APP_URL_PROD'] ?? 'https://evapi.click')
  540.                     : ($_ENV['APP_URL_DEV'] ?? 'http://localhost');
  541.             }
  542.         }
  543.         return rtrim($baseUrl, '/') . '/contact/' . $this->id;
  544.     }
  546.     /**
  547.      * Get QR code as base64 encoded PNG image
  548.      *
  549.      * @param int $size Image size in pixels (default: 150)
  550.      * @return string Base64 encoded PNG image with data URI prefix
  551.      */
  552.     public function getQrCode(int $size = 150): string
  553.     {
  554.         $qrCodeGenerator = new \App\Service\QRCodeGenerator();
  555.         return $qrCodeGenerator->generateBase64($this->getLienUrl(), $size);
  556.     }
  557. }