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(type: Types::INTEGER, options: ['default' => 1])]
  38.     private int $etat = 1;
  40.     #[ORM\Column(type: Types::JSON, nullable: true)]
  41.     private ?array $data = null;
  44.     #[ORM\OneToMany(mappedBy: 'contact', targetEntity: Objet::class, cascade: ['remove'])]
  45.     private Collection $objets;
  47.     #[ORM\OneToMany(mappedBy: 'contact', targetEntity: Dossier::class, cascade: ['remove'])]
  48.     private Collection $dossiers;
  50.     #[ORM\ManyToOne(inversedBy: 'contacts')]
  51.     private ?ContactType $contact_type = null;
  53.     #[ORM\OneToMany(mappedBy: 'contact', targetEntity: VariableValue::class, cascade: ['remove'])]
  54.     private Collection $variableValues;
  56.     #[ORM\ManyToOne(inversedBy: 'associatedContacts')]
  57.     #[ORM\JoinColumn(name: "parent_contact_id", referencedColumnName: "id", nullable: true)]
  58.     private ?Contact $parentContact;
  60.     #[ORM\OneToMany(mappedBy: 'parentContact', targetEntity: Contact::class, cascade: ['remove'])]
  61.     private Collection $associatedContacts;
  63.     #[ORM\Column(length: 255, nullable: true)]
  64.     private ?string $compte_client = null;
  66.     #[ORM\Column(length: 255, nullable: true)]
  67.     private ?string $tel2 = null;
  69.     #[ORM\Column(length: 255, nullable: true)]
  70.     private ?string $adresse = null;
  72.     #[ORM\Column(length: 255, nullable: true)]
  73.     private ?string $siret = null;
  75.     #[ORM\Column(nullable: true)]
  76.     private ?bool $emailing = null;
  78.     #[ORM\Column(nullable: true)]
  79.     private ?bool $antispam = null;
  81.     #[ORM\ManyToOne(inversedBy: 'contacts')]
  82.     private ?User $utilisateur = null;
  84.     #[ORM\OneToMany(mappedBy: 'contact', targetEntity: Fichier::class)]
  85.     private Collection $fichiers;
  87.     public function __construct()
  88.     {
  89.         $this->objets = new ArrayCollection();
  90.         $this->dossiers = new ArrayCollection();
  91.         $this->variableValues = new ArrayCollection();
  92.         $this->associatedContacts = new ArrayCollection();
  93.         $this->fichiers = new ArrayCollection();
  94.     }
  96.     public function getId(): ?int
  97.     {
  98.         return $this->id;
  99.     }
  101.     public function getDenomination(): ?string
  102.     {
  103.         return $this->denomination;
  104.     }
  106.     public function setDenomination(string $denomination): static
  107.     {
  108.         $this->denomination = $denomination;
  110.         return $this;
  111.     }
  113.     public function getSiren(): ?string
  114.     {
  115.         return $this->siren;
  116.     }
  118.     public function setSiren(string $siren): static
  119.     {
  120.         $this->siren = $siren;
  122.         return $this;
  123.     }
  125.     public function getNom(): ?string
  126.     {
  127.         return $this->nom;
  128.     }
  130.     public function setNom(string $nom): static
  131.     {
  132.         $this->nom = $nom;
  134.         return $this;
  135.     }
  137.     public function getTel1(): ?string
  138.     {
  139.         return $this->tel1;
  140.     }
  142.     public function setTel1(string $tel1): static
  143.     {
  144.         $this->tel1 = $tel1;
  146.         return $this;
  147.     }
  149.     public function getEmail(): ?string
  150.     {
  151.         return $this->email;
  152.     }
  154.     public function setEmail(string $email): static
  155.     {
  156.         $this->email = $email;
  158.         return $this;
  159.     }
  161.     public function getDateCreation(): ?\DateTimeInterface
  162.     {
  163.         return $this->date_creation;
  164.     }
  166.     public function setDateCreation(\DateTimeInterface $date_creation): static
  167.     {
  168.         $this->date_creation = $date_creation;
  170.         return $this;
  171.     }
  173.     public function setObjets(Collection $objets): static
  174.     {
  175.         $this->objets = $objets;
  176.         return $this;
  177.     }
  179.     /**
  180.      * @return Collection<int, Objet>
  181.      */
  182.     public function getObjets(): Collection
  183.     {
  184.         return $this->objets;
  185.     }
  187.     /**
  188.      * @return Collection<int, Objet>
  189.      */
  190.     public function getLevelOneObjets(): Collection
  191.     {
  192.         $levelOneObjets = new ArrayCollection();
  194.         foreach ($this->objets as $objet) {
  195.             if (!$objet->getObjet()) {
  196.                 $levelOneObjets->add($objet);
  197.             }
  198.         }
  200.         return $levelOneObjets;
  201.     }
  204.     /**
  205.      * @return Collection<int, Objet>
  206.      */
  207.     public function getObjetsLevelOneObjetType(): Collection
  208.     {
  209.         return $this->objets;
  210.     }
  212.     public function addObjet(Objet $objet): static
  213.     {
  214.         if (!$this->objets->contains($objet)) {
  215.             $this->objets->add($objet);
  216.             $objet->setContact($this);
  217.         }
  219.         return $this;
  220.     }
  222.     public function removeObjet(Objet $objet): static
  223.     {
  224.         if ($this->objets->removeElement($objet)) {
  225.             // set the owning side to null (unless already changed)
  226.             if ($objet->getContact() === $this) {
  227.                 $objet->setContact(null);
  228.             }
  229.         }
  231.         return $this;
  232.     }
  234.     /**
  235.      * @return Collection<int, Dossier>
  236.      */
  237.     public function getDossiers(): Collection
  238.     {
  239.         return $this->dossiers;
  240.     }
  242.     public function addDossier(Dossier $dossier): static
  243.     {
  244.         if (!$this->dossiers->contains($dossier)) {
  245.             $this->dossiers->add($dossier);
  246.             $dossier->setContact($this);
  247.         }
  249.         return $this;
  250.     }
  252.     public function removeDossier(Dossier $dossier): static
  253.     {
  254.         if ($this->dossiers->removeElement($dossier)) {
  255.             // set the owning side to null (unless already changed)
  256.             if ($dossier->getContact() === $this) {
  257.                 $dossier->setContact(null);
  258.             }
  259.         }
  261.         return $this;
  262.     }
  264.     public function getContactType(): ?ContactType
  265.     {
  266.         return $this->contact_type;
  267.     }
  269.     public function setContactType(?ContactType $contact_type): static
  270.     {
  271.         $this->contact_type = $contact_type;
  273.         return $this;
  274.     }
  276.     /**
  277.      * @return Collection<int, VariableValue>
  278.      */
  279.     public function getVariableValues(): Collection
  280.     {
  281.         return $this->variableValues;
  282.     }
  284.     public function addVariableValue(VariableValue $variableValue): static
  285.     {
  286.         if (!$this->variableValues->contains($variableValue)) {
  287.             $this->variableValues->add($variableValue);
  288.             $variableValue->setContact($this);
  289.         }
  291.         return $this;
  292.     }
  294.     public function removeVariableValue(VariableValue $variableValue): static
  295.     {
  296.         if ($this->variableValues->removeElement($variableValue)) {
  297.             // set the owning side to null (unless already changed)
  298.             if ($variableValue->getContact() === $this) {
  299.                 $variableValue->setContact(null);
  300.             }
  301.         }
  303.         return $this;
  304.     }
  306.     public function getParentContact(): ?Contact
  307.     {
  308.         return $this->parentContact;
  309.     }
  311.     public function setParentContact(?Contact $parentContact): static
  312.     {
  313.         $this->parentContact = $parentContact;
  315.         return $this;
  316.     }
  318.     public function setAssociatedContacts(Collection $associatedContacts): static
  319.     {
  320.         $this->associatedContacts = $associatedContacts;
  321.         return $this;
  322.     }
  324.     /**
  325.      * @return Collection<int, Contact>
  326.      */
  327.     public function getAssociatedContacts(): Collection
  328.     {
  329.         return $this->associatedContacts;
  330.     }
  332.     public function addAssociatedContact(Contact $associatedContact): static
  333.     {
  334.         if (!$this->associatedContacts->contains($associatedContact)) {
  335.             $this->associatedContacts->add($associatedContact);
  336.             $associatedContact->setParentContact($this);
  337.         }
  339.         return $this;
  340.     }
  342.     public function removeAssociatedContact(Contact $associatedContact): static
  343.     {
  344.         if ($this->associatedContacts->removeElement($associatedContact)) {
  345.             $associatedContact->setParentContact(null);
  346.         }
  348.         return $this;
  349.     }
  351.     public function getCompteClient(): ?string
  352.     {
  353.         return $this->compte_client;
  354.     }
  356.     public function setCompteClient(?string $compte_client): static
  357.     {
  358.         $this->compte_client = $compte_client;
  360.         return $this;
  361.     }
  363.     public function getTel2(): ?string
  364.     {
  365.         return $this->tel2;
  366.     }
  368.     public function setTel2(?string $tel2): static
  369.     {
  370.         $this->tel2 = $tel2;
  372.         return $this;
  373.     }
  375.     public function getAdresse(): ?string
  376.     {
  377.         return $this->adresse;
  378.     }
  380.     public function setAdresse(?string $adresse): static
  381.     {
  382.         $this->adresse = $adresse;
  384.         return $this;
  385.     }
  387.     public function getSiret(): ?string
  388.     {
  389.         return $this->siret;
  390.     }
  392.     public function setSiret(?string $siret): static
  393.     {
  394.         $this->siret = $siret;
  396.         return $this;
  397.     }
  399.     public function isEmailing(): ?bool
  400.     {
  401.         return $this->emailing;
  402.     }
  404.     public function setEmailing(?bool $emailing): static
  405.     {
  406.         $this->emailing = $emailing;
  408.         return $this;
  409.     }
  411.     public function isAntispam(): ?bool
  412.     {
  413.         return $this->antispam;
  414.     }
  416.     public function setAntispam(?bool $antispam): static
  417.     {
  418.         $this->antispam = $antispam;
  420.         return $this;
  421.     }
  423.     public function getUtilisateur(): ?User
  424.     {
  425.         return $this->utilisateur;
  426.     }
  428.     public function setUtilisateur(?User $utilisateur): static
  429.     {
  430.         $this->utilisateur = $utilisateur;
  432.         return $this;
  433.     }
  435.     /**
  436.      * @return Collection<int, Fichier>
  437.      */
  438.     public function getFichiers(): Collection
  439.     {
  440.         return $this->fichiers;
  441.     }
  443.     public function addFichier(Fichier $fichier): static
  444.     {
  445.         if (!$this->fichiers->contains($fichier)) {
  446.             $this->fichiers->add($fichier);
  447.             $fichier->setContact($this);
  448.         }
  450.         return $this;
  451.     }
  453.     public function removeFichier(Fichier $fichier): static
  454.     {
  455.         if ($this->fichiers->removeElement($fichier)) {
  456.             // set the owning side to null (unless already changed)
  457.             if ($fichier->getContact() === $this) {
  458.                 $fichier->setContact(null);
  459.             }
  460.         }
  462.         return $this;
  463.     }
  464.     public function __toString()
  465.     {
  466.         return (string) $this->id;  // Ou une autre propriété qui représente bien l'objet
  467.     }
  469.     public function getEtat(): int
  470.     {
  471.         return $this->etat;
  472.     }
  474.     public function setEtat(int $etat): static
  475.     {
  476.         $this->etat = $etat;
  477.         return $this;
  478.     }
  480.     public function getData(): ?array
  481.     {
  482.         return $this->data;
  483.     }
  485.     public function setData(?array $data): static
  486.     {
  487.         $this->data = $data;
  488.         return $this;
  489.     }
  490. }