src/Entity/Residence.php line 15

  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\ResidenceRepository;
  6. use App\Traits\TimeStampTrait;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Symfony\Component\Validator\Constraints as Assert;
  13. #[ORM\Entity(repositoryClass: ResidenceRepository::class)]
  14. #[ORM\HasLifecycleCallbacks]
  15. class Residence
  16. {
  17.     use TimeStampTrait;
  19.     #[ORM\Id]
  20.     #[ORM\GeneratedValue]
  21.     #[ORM\Column(type: 'integer')]
  22.     private $id;
  24.     #[ORM\Column(length: 100)]
  25.     private ?string $code = null;
  27.     #[ORM\Column(length: 100, nullable: true)]
  28.     private ?string $libelle = null;
  30.     #[ORM\ManyToOne(inversedBy: 'residences')]
  31.     private ?User $createdBy = null;
  33.     #[ORM\Column(length: 255)]
  34.     private ?string $adress = null;
  36.     #[ORM\Column(nullable: true)]
  37.     private ?bool $status = null;
  39.     #[ORM\OneToMany(mappedBy: 'residence', targetEntity: Habitat::class, cascade: ['all'], fetch: 'EAGER')]
  40.     private Collection $habitats;
  42.     #[ORM\Column(length: 100, nullable: true)]
  43.     private ?string $number = null;
  45.     #[ORM\Column(length: 100, nullable: true)]
  46.     private ?string $commune = null;
  48.     #[ORM\Column(length: 100, nullable: true)]
  49.     private ?string $ville = null;
  51.     #[ORM\ManyToOne(inversedBy: 'residences')]
  52.     private ?Entreprise $marchand = null;
  54.     #[ORM\OneToMany(mappedBy: 'residence', targetEntity: Photos::class)]
  55.     private Collection $photos;
  57.     #[ORM\ManyToMany(targetEntity: ResidenceDetails::class, inversedBy: 'residences')]
  58.     private Collection $details;
  60.     #[ORM\ManyToMany(targetEntity: CategoryResidence::class, inversedBy: 'residences')]
  61.     private Collection $category;
  63.     #[ORM\ManyToOne(inversedBy: 'residences')]
  64.     private ?ResidenceImmeuble $immeuble = null;
  66.     #[ORM\OneToMany(mappedBy: 'residence', targetEntity: ResidenceImmeuble::class)]
  67.     private Collection $residenceImmeubles;
  69.     #[ORM\ManyToOne(inversedBy: 'residences')]
  70.     #[Assert\NotBlank(message: 'Veuillez renseigner ce champ')]
  71.     private ?Country $country = null;
  73.     #[ORM\ManyToOne(inversedBy: 'residences')]
  74.     #[Assert\NotBlank(message: 'Veuillez renseigner ce champ')]
  75.     private ?Province $province = null;
  77.     #[ORM\OneToMany(mappedBy: 'residence', targetEntity: Incident::class)]
  78.     private Collection $incidents;
  80.     #[ORM\Column(length: 255, nullable: true)]
  81.     private ?string $pointdereference = null;
  83.     #[ORM\Column(length: 50, nullable: true)]
  84.     private ?string $codepostal = null;
  86.     #[ORM\OneToMany(mappedBy: 'residence', targetEntity: Charge::class)]
  87.     private Collection $charges;
  89.     #[ORM\OneToMany(mappedBy: 'residence', targetEntity: Location::class)]
  90.     private Collection $locations;
  92.     public function __construct()
  93.     {
  94.         $this->habitats = new ArrayCollection();
  95.         $this->category = new ArrayCollection();
  96.         $this->photos = new ArrayCollection();
  97.         $this->details = new ArrayCollection();
  98.         $this->residenceImmeubles = new ArrayCollection();
  99.         $this->incidents = new ArrayCollection();
  100.         $this->charges = new ArrayCollection();
  101.         $this->locations = new ArrayCollection();
  102.     }
  104.     /**
  105.      * Set id.
  106.      *
  107.      * @param int $id
  108.      *
  109.      * @return Residence
  110.      */
  111.     public function setId($id): static
  112.     {
  113.         $this->id = $id;
  115.         return $this;
  116.     }
  118.     public function getId()
  119.     {
  120.         return $this->id;
  121.     }
  123.     /**
  124.      * @return string|null
  125.      */
  126.     public function getCode(): ?string
  127.     {
  128.         return $this->code;
  129.     }
  131.     /**
  132.      * @param string|null $code
  133.      */
  134.     public function setCode(?string $code): void
  135.     {
  136.         $this->code = $code;
  137.     }
  139.     /**
  140.      * @return string|null
  141.      */
  142.     public function getLibelle(): ?string
  143.     {
  144.         return $this->libelle;
  145.     }
  147.     /**
  148.      * @param string|null $libelle
  149.      */
  150.     public function setLibelle(?string $libelle): void
  151.     {
  152.         $this->libelle = $libelle;
  153.     }
  155.     /**
  156.      * @return User|null
  157.      */
  158.     public function getCreatedBy(): ?User
  159.     {
  160.         return $this->createdBy;
  161.     }
  163.     /**
  164.      * @param User|null $createdBy
  165.      */
  166.     public function setCreatedBy(?User $createdBy): void
  167.     {
  168.         $this->createdBy = $createdBy;
  169.     }
  171.     /**
  172.      * @return string|null
  173.      */
  174.     public function getAdress(): ?string
  175.     {
  176.         return $this->adress;
  177.     }
  179.     /**
  180.      * @param string|null $adress
  181.      */
  182.     public function setAdress(?string $adress): void
  183.     {
  184.         $this->adress = $adress;
  185.     }
  187.     /**
  188.      * @return bool|null
  189.      */
  190.     public function getStatus(): ?bool
  191.     {
  192.         return $this->status;
  193.     }
  195.     /**
  196.      * @param bool|null $status
  197.      */
  198.     public function setStatus(?bool $status): void
  199.     {
  200.         $this->status = $status;
  201.     }
  203.     /**
  204.      * @return ArrayCollection|Collection
  205.      */
  206.     public function getHabitats(): ArrayCollection|Collection
  207.     {
  208.         return $this->habitats;
  209.     }
  211.     /**
  212.      * @param ArrayCollection|Collection $habitats
  213.      */
  214.     public function setHabitats(ArrayCollection|Collection $habitats): void
  215.     {
  216.         $this->habitats = $habitats;
  217.     }
  219.     /**
  220.      * @return string|null
  221.      */
  222.     public function getNumber(): ?string
  223.     {
  224.         return $this->number;
  225.     }
  227.     /**
  228.      * @param string|null $number
  229.      */
  230.     public function setNumber(?string $number): void
  231.     {
  232.         $this->number = $number;
  233.     }
  235.     /**
  236.      * @return string|null
  237.      */
  238.     public function getCommune(): ?string
  239.     {
  240.         return $this->commune;
  241.     }
  243.     /**
  244.      * @param string|null $commune
  245.      */
  246.     public function setCommune(?string $commune): void
  247.     {
  248.         $this->commune = $commune;
  249.     }
  251.     /**
  252.      * @return string|null
  253.      */
  254.     public function getVille(): ?string
  255.     {
  256.         return $this->ville;
  257.     }
  259.     /**
  260.      * @param string|null $ville
  261.      */
  262.     public function setVille(?string $ville): void
  263.     {
  264.         $this->ville = $ville;
  265.     }
  267.     /**
  268.      * @return Entreprise|null
  269.      */
  270.     public function getMarchand(): ?Entreprise
  271.     {
  272.         return $this->marchand;
  273.     }
  275.     /**
  276.      * @param Entreprise|null $marchand
  277.      */
  278.     public function setMarchand(?Entreprise $marchand): void
  279.     {
  280.         $this->marchand = $marchand;
  281.     }
  283.     /**
  284.      * @return ArrayCollection|Collection
  285.      */
  286.     public function getPhotos(): ArrayCollection|Collection
  287.     {
  288.         return $this->photos;
  289.     }
  291.     /**
  292.      * @param ArrayCollection|Collection $photos
  293.      */
  294.     public function setPhotos(ArrayCollection|Collection $photos): void
  295.     {
  296.         $this->photos = $photos;
  297.     }
  299.     public function __toString()
  300.     {
  301.         return $this->libelle;
  302.     }
  304.     /**
  305.      * @return Collection<int, ResidenceDetails>
  306.      */
  307.     public function getDetails(): Collection
  308.     {
  309.         return $this->details;
  310.     }
  312.     public function addDetail(ResidenceDetails $detail): static
  313.     {
  314.         if (!$this->details->contains($detail)) {
  315.             $this->details->add($detail);
  316.         }
  318.         return $this;
  319.     }
  321.     public function removeDetail(ResidenceDetails $detail): static
  322.     {
  323.         $this->details->removeElement($detail);
  325.         return $this;
  326.     }
  328.     /**
  329.      * @return Collection<int, CategoryResidence>
  330.      */
  331.     public function getCategory(): Collection
  332.     {
  333.         return $this->category;
  334.     }
  336.     public function addCategory(CategoryResidence $category): static
  337.     {
  338.         if (!$this->category->contains($category)) {
  339.             $this->category->add($category);
  340.         }
  342.         return $this;
  343.     }
  345.     public function removeCategory(CategoryResidence $category): static
  346.     {
  347.         $this->category->removeElement($category);
  349.         return $this;
  350.     }
  352.     public function getImmeuble(): ?ResidenceImmeuble
  353.     {
  354.         return $this->immeuble;
  355.     }
  357.     public function setImmeuble(?ResidenceImmeuble $immeuble): static
  358.     {
  359.         $this->immeuble = $immeuble;
  361.         return $this;
  362.     }
  364.     /**
  365.      * @return Collection<int, ResidenceImmeuble>
  366.      */
  367.     public function getResidenceImmeubles(): Collection
  368.     {
  369.         return $this->residenceImmeubles;
  370.     }
  372.     public function addResidenceImmeuble(ResidenceImmeuble $residenceImmeuble): static
  373.     {
  374.         if (!$this->residenceImmeubles->contains($residenceImmeuble)) {
  375.             $this->residenceImmeubles->add($residenceImmeuble);
  376.             $residenceImmeuble->setResidence($this);
  377.         }
  379.         return $this;
  380.     }
  382.     public function removeResidenceImmeuble(ResidenceImmeuble $residenceImmeuble): static
  383.     {
  384.         if ($this->residenceImmeubles->removeElement($residenceImmeuble)) {
  385.             // set the owning side to null (unless already changed)
  386.             if ($residenceImmeuble->getResidence() === $this) {
  387.                 $residenceImmeuble->setResidence(null);
  388.             }
  389.         }
  391.         return $this;
  392.     }
  394.     public function getCountry(): ?Country
  395.     {
  396.         return $this->country;
  397.     }
  399.     public function setCountry(?Country $country): static
  400.     {
  401.         $this->country = $country;
  403.         return $this;
  404.     }
  406.     public function getProvince(): ?Province
  407.     {
  408.         return $this->province;
  409.     }
  411.     public function setProvince(?Province $province): static
  412.     {
  413.         $this->province = $province;
  415.         return $this;
  416.     }
  418.     /**
  419.      * @return Collection<int, Incident>
  420.      */
  421.     public function getIncidents(): Collection
  422.     {
  423.         return $this->incidents;
  424.     }
  426.     public function addIncident(Incident $incident): static
  427.     {
  428.         if (!$this->incidents->contains($incident)) {
  429.             $this->incidents->add($incident);
  430.             $incident->setResidence($this);
  431.         }
  433.         return $this;
  434.     }
  436.     public function removeIncident(Incident $incident): static
  437.     {
  438.         if ($this->incidents->removeElement($incident)) {
  439.             // set the owning side to null (unless already changed)
  440.             if ($incident->getResidence() === $this) {
  441.                 $incident->setResidence(null);
  442.             }
  443.         }
  445.         return $this;
  446.     }
  448.     public function getPointdereference(): ?string
  449.     {
  450.         return $this->pointdereference;
  451.     }
  453.     public function setPointdereference(?string $pointdereference): static
  454.     {
  455.         $this->pointdereference = $pointdereference;
  457.         return $this;
  458.     }
  460.     public function getCodepostal(): ?string
  461.     {
  462.         return $this->codepostal;
  463.     }
  465.     public function setCodepostal(?string $codepostal): static
  466.     {
  467.         $this->codepostal = $codepostal;
  469.         return $this;
  470.     }
  472.     /**
  473.      * @return Collection<int, Charge>
  474.      */
  475.     public function getCharges(): Collection
  476.     {
  477.         return $this->charges;
  478.     }
  480.     public function addCharge(Charge $charge): static
  481.     {
  482.         if (!$this->charges->contains($charge)) {
  483.             $this->charges->add($charge);
  484.             $charge->setResidence($this);
  485.         }
  487.         return $this;
  488.     }
  490.     public function removeCharge(Charge $charge): static
  491.     {
  492.         if ($this->charges->removeElement($charge)) {
  493.             // set the owning side to null (unless already changed)
  494.             if ($charge->getResidence() === $this) {
  495.                 $charge->setResidence(null);
  496.             }
  497.         }
  499.         return $this;
  500.     }
  502.     /**
  503.      * @return Collection<int, Location>
  504.      */
  505.     public function getLocations(): Collection
  506.     {
  507.         return $this->locations;
  508.     }
  510.     public function addLocation(Location $location): static
  511.     {
  512.         if (!$this->locations->contains($location)) {
  513.             $this->locations->add($location);
  514.             $location->setResidence($this);
  515.         }
  517.         return $this;
  518.     }
  520.     public function removeLocation(Location $location): static
  521.     {
  522.         if ($this->locations->removeElement($location)) {
  523.             // set the owning side to null (unless already changed)
  524.             if ($location->getResidence() === $this) {
  525.                 $location->setResidence(null);
  526.             }
  527.         }
  529.         return $this;
  530.     }
  531. }