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\OneToMany(mappedBy: 'contact', targetEntity: Project::class, cascade: ['remove'])]
  38.     private Collection $projects;
  40.     #[ORM\OneToMany(mappedBy: 'contact', targetEntity: Dossier::class, cascade: ['remove'])]
  41.     private Collection $dossiers;
  43.     #[ORM\ManyToOne(inversedBy: 'contacts')]
  44.     private ?ContactType $contact_type = null;
  46.     #[ORM\OneToMany(mappedBy: 'contact', targetEntity: VariableValue::class, cascade: ['remove'])]
  47.     private Collection $variableValues;
  49.     #[ORM\ManyToOne(inversedBy: 'associatedContacts')]
  50.     #[ORM\JoinColumn(name: "parent_contact_id", referencedColumnName: "id", nullable: true)]
  51.     private ?Contact $parentContact;
  53.     #[ORM\OneToMany(mappedBy: 'parentContact', targetEntity: Contact::class, cascade: ['remove'])]
  54.     private Collection $associatedContacts;
  56.     #[ORM\Column(length: 255, nullable: true)]
  57.     private ?string $compte_client = null;
  59.     #[ORM\Column(length: 255, nullable: true)]
  60.     private ?string $tel2 = null;
  62.     #[ORM\Column(length: 255, nullable: true)]
  63.     private ?string $adresse = null;
  65.     #[ORM\Column(length: 255, nullable: true)]
  66.     private ?string $siret = null;
  68.     #[ORM\Column(nullable: true)]
  69.     private ?bool $emailing = null;
  71.     #[ORM\Column(nullable: true)]
  72.     private ?bool $antispam = null;
  74.     #[ORM\ManyToOne(inversedBy: 'contacts')]
  75.     private ?User $utilisateur = null;
  77.     #[ORM\OneToMany(mappedBy: 'contact', targetEntity: Fichier::class)]
  78.     private Collection $fichiers;
  80.     public function __construct()
  81.     {
  82.         $this->projects = new ArrayCollection();
  83.         $this->dossiers = new ArrayCollection();
  84.         $this->variableValues = new ArrayCollection();
  85.         $this->associatedContacts = new ArrayCollection();
  86.         $this->fichiers = new ArrayCollection();
  87.     }
  89.     public function getId(): ?int
  90.     {
  91.         return $this->id;
  92.     }
  94.     public function getDenomination(): ?string
  95.     {
  96.         return $this->denomination;
  97.     }
  99.     public function setDenomination(string $denomination): static
  100.     {
  101.         $this->denomination = $denomination;
  103.         return $this;
  104.     }
  106.     public function getSiren(): ?string
  107.     {
  108.         return $this->siren;
  109.     }
  111.     public function setSiren(string $siren): static
  112.     {
  113.         $this->siren = $siren;
  115.         return $this;
  116.     }
  118.     public function getNom(): ?string
  119.     {
  120.         return $this->nom;
  121.     }
  123.     public function setNom(string $nom): static
  124.     {
  125.         $this->nom = $nom;
  127.         return $this;
  128.     }
  130.     public function getTel1(): ?string
  131.     {
  132.         return $this->tel1;
  133.     }
  135.     public function setTel1(string $tel1): static
  136.     {
  137.         $this->tel1 = $tel1;
  139.         return $this;
  140.     }
  142.     public function getEmail(): ?string
  143.     {
  144.         return $this->email;
  145.     }
  147.     public function setEmail(string $email): static
  148.     {
  149.         $this->email = $email;
  151.         return $this;
  152.     }
  154.     public function getDateCreation(): ?\DateTimeInterface
  155.     {
  156.         return $this->date_creation;
  157.     }
  159.     public function setDateCreation(\DateTimeInterface $date_creation): static
  160.     {
  161.         $this->date_creation = $date_creation;
  163.         return $this;
  164.     }
  166.     /**
  167.      * @return Collection<int, Project>
  168.      */
  169.     public function getProjects(): Collection
  170.     {
  171.         return $this->projects;
  172.     }
  174.     public function addProject(Project $project): static
  175.     {
  176.         if (!$this->projects->contains($project)) {
  177.             $this->projects->add($project);
  178.             $project->setContact($this);
  179.         }
  181.         return $this;
  182.     }
  184.     public function removeProject(Project $project): static
  185.     {
  186.         if ($this->projects->removeElement($project)) {
  187.             // set the owning side to null (unless already changed)
  188.             if ($project->getContact() === $this) {
  189.                 $project->setContact(null);
  190.             }
  191.         }
  193.         return $this;
  194.     }
  196.     /**
  197.      * @return Collection<int, Dossier>
  198.      */
  199.     public function getDossiers(): Collection
  200.     {
  201.         return $this->dossiers;
  202.     }
  204.     public function addDossier(Dossier $dossier): static
  205.     {
  206.         if (!$this->dossiers->contains($dossier)) {
  207.             $this->dossiers->add($dossier);
  208.             $dossier->setContact($this);
  209.         }
  211.         return $this;
  212.     }
  214.     public function removeDossier(Dossier $dossier): static
  215.     {
  216.         if ($this->dossiers->removeElement($dossier)) {
  217.             // set the owning side to null (unless already changed)
  218.             if ($dossier->getContact() === $this) {
  219.                 $dossier->setContact(null);
  220.             }
  221.         }
  223.         return $this;
  224.     }
  225.     
  226.     public function getContactType(): ?ContactType
  227.     {
  228.         return $this->contact_type;
  229.     }
  231.     public function setContactType(?ContactType $contact_type): static
  232.     {
  233.         $this->contact_type = $contact_type;
  235.         return $this;
  236.     }
  238.     /**
  239.      * @return Collection<int, VariableValue>
  240.      */
  241.     public function getVariableValues(): Collection
  242.     {
  243.         return $this->variableValues;
  244.     }
  246.     public function addVariableValue(VariableValue $variableValue): static
  247.     {
  248.         if (!$this->variableValues->contains($variableValue)) {
  249.             $this->variableValues->add($variableValue);
  250.             $variableValue->setContact($this);
  251.         }
  253.         return $this;
  254.     }
  256.     public function removeVariableValue(VariableValue $variableValue): static
  257.     {
  258.         if ($this->variableValues->removeElement($variableValue)) {
  259.             // set the owning side to null (unless already changed)
  260.             if ($variableValue->getContact() === $this) {
  261.                 $variableValue->setContact(null);
  262.             }
  263.         }
  265.         return $this;
  266.     }
  268.     public function getParentContact(): ?Contact
  269.     {
  270.         return $this->parentContact;
  271.     }
  273.     public function setParentContact(?Contact $parentContact): static
  274.     {
  275.         $this->parentContact = $parentContact;
  277.         return $this;
  278.     }
  280.     /**
  281.      * @return Collection<int, Contact>
  282.      */
  283.     public function getAssociatedContacts(): Collection
  284.     {
  285.         return $this->associatedContacts;
  286.     }
  288.     public function addAssociatedContact(Contact $associatedContact): static
  289.     {
  290.         if (!$this->associatedContacts->contains($associatedContact)) {
  291.             $this->associatedContacts->add($associatedContact);
  292.             $associatedContact->setParentContact($this);
  293.         }
  295.         return $this;
  296.     }
  298.     public function removeAssociatedContact(Contact $associatedContact): static
  299.     {
  300.         if ($this->associatedContacts->removeElement($associatedContact)) {
  301.             $associatedContact->setParentContact(null);
  302.         }
  304.         return $this;
  305.     }
  307.     public function getCompteClient(): ?string
  308.     {
  309.         return $this->compte_client;
  310.     }
  312.     public function setCompteClient(?string $compte_client): static
  313.     {
  314.         $this->compte_client = $compte_client;
  316.         return $this;
  317.     }
  319.     public function getTel2(): ?string
  320.     {
  321.         return $this->tel2;
  322.     }
  324.     public function setTel2(?string $tel2): static
  325.     {
  326.         $this->tel2 = $tel2;
  328.         return $this;
  329.     }
  331.     public function getAdresse(): ?string
  332.     {
  333.         return $this->adresse;
  334.     }
  336.     public function setAdresse(?string $adresse): static
  337.     {
  338.         $this->adresse = $adresse;
  340.         return $this;
  341.     }
  343.     public function getSiret(): ?string
  344.     {
  345.         return $this->siret;
  346.     }
  348.     public function setSiret(?string $siret): static
  349.     {
  350.         $this->siret = $siret;
  352.         return $this;
  353.     }
  355.     public function isEmailing(): ?bool
  356.     {
  357.         return $this->emailing;
  358.     }
  360.     public function setEmailing(?bool $emailing): static
  361.     {
  362.         $this->emailing = $emailing;
  364.         return $this;
  365.     }
  367.     public function isAntispam(): ?bool
  368.     {
  369.         return $this->antispam;
  370.     }
  372.     public function setAntispam(?bool $antispam): static
  373.     {
  374.         $this->antispam = $antispam;
  376.         return $this;
  377.     }
  379.     public function getUtilisateur(): ?User
  380.     {
  381.         return $this->utilisateur;
  382.     }
  384.     public function setUtilisateur(?User $utilisateur): static
  385.     {
  386.         $this->utilisateur = $utilisateur;
  388.         return $this;
  389.     }
  391.     /**
  392.      * @return Collection<int, Fichier>
  393.      */
  394.     public function getFichiers(): Collection
  395.     {
  396.         return $this->fichiers;
  397.     }
  399.     public function addFichier(Fichier $fichier): static
  400.     {
  401.         if (!$this->fichiers->contains($fichier)) {
  402.             $this->fichiers->add($fichier);
  403.             $fichier->setContact($this);
  404.         }
  406.         return $this;
  407.     }
  409.     public function removeFichier(Fichier $fichier): static
  410.     {
  411.         if ($this->fichiers->removeElement($fichier)) {
  412.             // set the owning side to null (unless already changed)
  413.             if ($fichier->getContact() === $this) {
  414.                 $fichier->setContact(null);
  415.             }
  416.         }
  418.         return $this;
  419.     }
  420.     public function __toString() {
  421.         return (string) $this->id;  // Ou une autre propriété qui représente bien l'objet
  422.     }
  423. }