src/Entity/Contact.php line 12

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. class Contact
  13. {
  14.     #[ORM\Id]
  15.     #[ORM\GeneratedValue]
  16.     #[ORM\Column]
  17.     private ?int $id = null;
  19.     #[ORM\Column(length: 255)]
  20.     private ?string $denomination = null;
  22.     #[ORM\Column(length: 9)]
  23.     private ?string $siren = null;
  25.     #[ORM\Column(length: 255)]
  26.     private ?string $nom = null;
  28.     #[ORM\Column(length: 255)]
  29.     private ?string $tel1 = null;
  31.     #[ORM\Column(length: 255)]
  32.     private ?string $email = null;
  34.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  35.     private ?\DateTimeInterface $date_creation = null;
  37.     #[ORM\Column(name: 'date_modification', type: Types::DATETIME_MUTABLE, nullable: true)]
  38.     private ?\DateTimeInterface $datemodification = null;
  40.     #[ORM\Column(type: Types::INTEGER, options: ['default' => 1])]
  41.     private int $etat = 1;
  43.     #[ORM\Column(type: Types::JSON, nullable: true)]
  44.     private ?array $data = null;
  47.     #[ORM\OneToMany(mappedBy: 'contact', targetEntity: Objet::class, cascade: ['remove'])]
  48.     private Collection $objets;
  50.     #[ORM\OneToMany(mappedBy: 'contact', targetEntity: Dossier::class, cascade: ['remove'])]
  51.     private Collection $dossiers;
  53.     #[ORM\ManyToOne(inversedBy: 'contacts')]
  54.     private ?ContactType $contact_type = null;
  56.     #[ORM\OneToMany(mappedBy: 'contact', targetEntity: VariableValue::class, cascade: ['remove'])]
  57.     private Collection $variableValues;
  59.     #[ORM\ManyToOne(inversedBy: 'associatedContacts')]
  60.     #[ORM\JoinColumn(name: "parent_contact_id", referencedColumnName: "id", nullable: true)]
  61.     private ?Contact $parentContact;
  63.     #[ORM\OneToMany(mappedBy: 'parentContact', targetEntity: Contact::class, cascade: ['remove'])]
  64.     private Collection $associatedContacts;
  66.     #[ORM\Column(length: 255, nullable: true)]
  67.     private ?string $compte_client = null;
  69.     #[ORM\Column(length: 255, nullable: true)]
  70.     private ?string $tel2 = null;
  72.     #[ORM\Column(length: 255, nullable: true)]
  73.     private ?string $adresse = null;
  75.     #[ORM\Column(length: 255, nullable: true)]
  76.     private ?string $siret = null;
  78.     #[ORM\Column(length: 255, nullable: true)]
  79.     private ?string $poste = null;
  81.     #[ORM\Column(nullable: true)]
  82.     private ?bool $emailing = null;
  84.     #[ORM\Column(nullable: true)]
  85.     private ?bool $antispam = null;
  87.     #[ORM\ManyToOne(inversedBy: 'contacts')]
  88.     private ?User $utilisateur = null;
  90.     #[ORM\OneToMany(mappedBy: 'contact', targetEntity: Fichier::class)]
  91.     private Collection $fichiers;
  93.     public function __construct()
  94.     {
  95.         $this->objets = new ArrayCollection();
  96.         $this->dossiers = new ArrayCollection();
  97.         $this->variableValues = new ArrayCollection();
  98.         $this->associatedContacts = new ArrayCollection();
  99.         $this->fichiers = new ArrayCollection();
  100.     }
  102.     public function getId(): ?int
  103.     {
  104.         return $this->id;
  105.     }
  107.     public function getDenomination(): ?string
  108.     {
  109.         return $this->denomination;
  110.     }
  112.     public function setDenomination(string $denomination): static
  113.     {
  114.         $this->denomination = $denomination;
  116.         return $this;
  117.     }
  119.     public function getSiren(): ?string
  120.     {
  121.         return $this->siren;
  122.     }
  124.     public function setSiren(string $siren): static
  125.     {
  126.         $this->siren = $siren;
  128.         return $this;
  129.     }
  131.     public function getNom(): ?string
  132.     {
  133.         return $this->nom;
  134.     }
  136.     public function setNom(string $nom): static
  137.     {
  138.         $this->nom = $nom;
  140.         return $this;
  141.     }
  143.     public function getTel1(): ?string
  144.     {
  145.         return $this->tel1;
  146.     }
  148.     public function setTel1(string $tel1): static
  149.     {
  150.         $this->tel1 = $tel1;
  152.         return $this;
  153.     }
  155.     public function getEmail(): ?string
  156.     {
  157.         return $this->email;
  158.     }
  160.     public function setEmail(string $email): static
  161.     {
  162.         $this->email = $email;
  164.         return $this;
  165.     }
  167.     public function getDateCreation(): ?\DateTimeInterface
  168.     {
  169.         return $this->date_creation;
  170.     }
  172.     public function setDateCreation(\DateTimeInterface $date_creation): static
  173.     {
  174.         $this->date_creation = $date_creation;
  176.         return $this;
  177.     }
  179.     public function getDatemodification(): ?\DateTimeInterface
  180.     {
  181.         return $this->datemodification;
  182.     }
  184.     public function setDatemodification(?\DateTimeInterface $datemodification): static
  185.     {
  186.         $this->datemodification = $datemodification;
  188.         return $this;
  189.     }
  191.     public function setObjets(Collection $objets): static
  192.     {
  193.         $this->objets = $objets;
  194.         return $this;
  195.     }
  197.     /**
  198.      * @return Collection<int, Objet>
  199.      */
  200.     public function getObjets(): Collection
  201.     {
  202.         return $this->objets;
  203.     }
  205.     /**
  206.      * @return Collection<int, Objet>
  207.      */
  208.     public function getLevelOneObjets(): Collection
  209.     {
  210.         $levelOneObjets = new ArrayCollection();
  212.         foreach ($this->objets as $objet) {
  213.             if (!$objet->getObjet()) {
  214.                 $levelOneObjets->add($objet);
  215.             }
  216.         }
  218.         return $levelOneObjets;
  219.     }
  222.     /**
  223.      * @return Collection<int, Objet>
  224.      */
  225.     public function getObjetsLevelOneObjetType(): Collection
  226.     {
  227.         return $this->objets;
  228.     }
  230.     public function addObjet(Objet $objet): static
  231.     {
  232.         if (!$this->objets->contains($objet)) {
  233.             $this->objets->add($objet);
  234.             $objet->setContact($this);
  235.         }
  237.         return $this;
  238.     }
  240.     public function removeObjet(Objet $objet): static
  241.     {
  242.         if ($this->objets->removeElement($objet)) {
  243.             // set the owning side to null (unless already changed)
  244.             if ($objet->getContact() === $this) {
  245.                 $objet->setContact(null);
  246.             }
  247.         }
  249.         return $this;
  250.     }
  252.     /**
  253.      * @return Collection<int, Dossier>
  254.      */
  255.     public function getDossiers(): Collection
  256.     {
  257.         return $this->dossiers;
  258.     }
  260.     public function addDossier(Dossier $dossier): static
  261.     {
  262.         if (!$this->dossiers->contains($dossier)) {
  263.             $this->dossiers->add($dossier);
  264.             $dossier->setContact($this);
  265.         }
  267.         return $this;
  268.     }
  270.     public function removeDossier(Dossier $dossier): static
  271.     {
  272.         if ($this->dossiers->removeElement($dossier)) {
  273.             // set the owning side to null (unless already changed)
  274.             if ($dossier->getContact() === $this) {
  275.                 $dossier->setContact(null);
  276.             }
  277.         }
  279.         return $this;
  280.     }
  282.     public function getContactType(): ?ContactType
  283.     {
  284.         return $this->contact_type;
  285.     }
  287.     public function setContactType(?ContactType $contact_type): static
  288.     {
  289.         $this->contact_type = $contact_type;
  291.         return $this;
  292.     }
  294.     /**
  295.      * @return Collection<int, VariableValue>
  296.      */
  297.     public function getVariableValues(): Collection
  298.     {
  299.         return $this->variableValues;
  300.     }
  302.     public function addVariableValue(VariableValue $variableValue): static
  303.     {
  304.         if (!$this->variableValues->contains($variableValue)) {
  305.             $this->variableValues->add($variableValue);
  306.             $variableValue->setContact($this);
  307.         }
  309.         return $this;
  310.     }
  312.     public function removeVariableValue(VariableValue $variableValue): static
  313.     {
  314.         if ($this->variableValues->removeElement($variableValue)) {
  315.             // set the owning side to null (unless already changed)
  316.             if ($variableValue->getContact() === $this) {
  317.                 $variableValue->setContact(null);
  318.             }
  319.         }
  321.         return $this;
  322.     }
  324.     public function getParentContact(): ?Contact
  325.     {
  326.         return $this->parentContact;
  327.     }
  329.     public function setParentContact(?Contact $parentContact): static
  330.     {
  331.         $this->parentContact = $parentContact;
  333.         return $this;
  334.     }
  336.     public function setAssociatedContacts(Collection $associatedContacts): static
  337.     {
  338.         $this->associatedContacts = $associatedContacts;
  339.         return $this;
  340.     }
  342.     /**
  343.      * @return Collection<int, Contact>
  344.      */
  345.     public function getAssociatedContacts(): Collection
  346.     {
  347.         return $this->associatedContacts;
  348.     }
  350.     public function addAssociatedContact(Contact $associatedContact): static
  351.     {
  352.         if (!$this->associatedContacts->contains($associatedContact)) {
  353.             $this->associatedContacts->add($associatedContact);
  354.             $associatedContact->setParentContact($this);
  355.         }
  357.         return $this;
  358.     }
  360.     public function removeAssociatedContact(Contact $associatedContact): static
  361.     {
  362.         if ($this->associatedContacts->removeElement($associatedContact)) {
  363.             $associatedContact->setParentContact(null);
  364.         }
  366.         return $this;
  367.     }
  369.     public function getCompteClient(): ?string
  370.     {
  371.         return $this->compte_client;
  372.     }
  374.     public function setCompteClient(?string $compte_client): static
  375.     {
  376.         $this->compte_client = $compte_client;
  378.         return $this;
  379.     }
  381.     public function getTel2(): ?string
  382.     {
  383.         return $this->tel2;
  384.     }
  386.     public function setTel2(?string $tel2): static
  387.     {
  388.         $this->tel2 = $tel2;
  390.         return $this;
  391.     }
  393.     public function getAdresse(): ?string
  394.     {
  395.         return $this->adresse;
  396.     }
  398.     public function setAdresse(?string $adresse): static
  399.     {
  400.         $this->adresse = $adresse;
  402.         return $this;
  403.     }
  405.     public function getSiret(): ?string
  406.     {
  407.         return $this->siret;
  408.     }
  410.     public function setSiret(?string $siret): static
  411.     {
  412.         $this->siret = $siret;
  414.         return $this;
  415.     }
  417.     public function getPoste(): ?string
  418.     {
  419.         return $this->poste;
  420.     }
  422.     public function setPoste(?string $poste): static
  423.     {
  424.         $this->poste = $poste;
  426.         return $this;
  427.     }
  429.     public function isEmailing(): ?bool
  430.     {
  431.         return $this->emailing;
  432.     }
  434.     public function setEmailing(?bool $emailing): static
  435.     {
  436.         $this->emailing = $emailing;
  438.         return $this;
  439.     }
  441.     public function isAntispam(): ?bool
  442.     {
  443.         return $this->antispam;
  444.     }
  446.     public function setAntispam(?bool $antispam): static
  447.     {
  448.         $this->antispam = $antispam;
  450.         return $this;
  451.     }
  453.     public function getUtilisateur(): ?User
  454.     {
  455.         return $this->utilisateur;
  456.     }
  458.     public function setUtilisateur(?User $utilisateur): static
  459.     {
  460.         $this->utilisateur = $utilisateur;
  462.         return $this;
  463.     }
  465.     /**
  466.      * @return Collection<int, Fichier>
  467.      */
  468.     public function getFichiers(): Collection
  469.     {
  470.         return $this->fichiers;
  471.     }
  473.     public function addFichier(Fichier $fichier): static
  474.     {
  475.         if (!$this->fichiers->contains($fichier)) {
  476.             $this->fichiers->add($fichier);
  477.             $fichier->setContact($this);
  478.         }
  480.         return $this;
  481.     }
  483.     public function removeFichier(Fichier $fichier): static
  484.     {
  485.         if ($this->fichiers->removeElement($fichier)) {
  486.             // set the owning side to null (unless already changed)
  487.             if ($fichier->getContact() === $this) {
  488.                 $fichier->setContact(null);
  489.             }
  490.         }
  492.         return $this;
  493.     }
  494.     public function __toString()
  495.     {
  496.         return (string) $this->id;  // Ou une autre propriété qui représente bien l'objet
  497.     }
  499.     public function getEtat(): int
  500.     {
  501.         return $this->etat;
  502.     }
  504.     public function setEtat(int $etat): static
  505.     {
  506.         $this->etat = $etat;
  507.         return $this;
  508.     }
  510.     public function getData(): ?array
  511.     {
  512.         return $this->data;
  513.     }
  515.     public function setData(?array $data): static
  516.     {
  517.         $this->data = $data;
  518.         return $this;
  519.     }
  521.     /**
  522.      * Get the public URL for this contact
  523.      *
  524.      * @param string|null $baseUrl Base URL for the application
  525.      * @return string Full URL to contact show page
  526.      */
  527.     public function getLienUrl(?string $baseUrl = null): string
  528.     {
  529.         if ($baseUrl === null) {
  530.             // Auto-detect base URL from request if available
  531.             if (isset($_SERVER['HTTP_HOST'])) {
  532.                 $scheme = isset($_SERVER['HTTPS']) && $_SERVER['HTTPS'] === 'on' ? 'https' : 'http';
  533.                 $baseUrl = $scheme . '://' . $_SERVER['HTTP_HOST'];
  534.             } else {
  535.                 // Fallback to environment-based URL
  536.                 $env = $_ENV['APP_ENV'] ?? 'dev';
  537.                 $baseUrl = $env === 'prod'
  538.                     ? ($_ENV['APP_URL_PROD'] ?? 'https://evapi.click')
  539.                     : ($_ENV['APP_URL_DEV'] ?? 'http://localhost');
  540.             }
  541.         }
  542.         return rtrim($baseUrl, '/') . '/contact/' . $this->id;
  543.     }
  545.     /**
  546.      * Get QR code as base64 encoded PNG image
  547.      *
  548.      * @param int $size Image size in pixels (default: 150)
  549.      * @return string Base64 encoded PNG image with data URI prefix
  550.      */
  551.     public function getQrCode(int $size = 150): string
  552.     {
  553.         $qrCodeGenerator = new \App\Service\QRCodeGenerator();
  554.         return $qrCodeGenerator->generateBase64($this->getLienUrl(), $size);
  555.     }
  556. }