src/Entity/Country.php line 13

  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\CountryRepository;
  6. use App\Traits\TimeStampTrait;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\ORM\Mapping as ORM;
  11. #[ORM\Entity(repositoryClass: CountryRepository::class)]
  12. #[ORM\HasLifecycleCallbacks]
  13. class Country
  14. {
  15.     use TimeStampTrait;
  17.     #[ORM\Id]
  18.     #[ORM\GeneratedValue]
  19.     #[ORM\Column]
  20.     private ?int $id = null;
  22.     #[ORM\Column(length: 100)]
  23.     private ?string $code = null;
  25.     #[ORM\Column(length: 10, nullable: true)]
  26.     private ?string $countryCode = null;
  28.     #[ORM\Column(length: 100, nullable: true)]
  29.     private ?string $name = null;
  31.     #[ORM\Column(length: 10, nullable: true)]
  32.     private ?string $isoCode = null;
  34.     #[ORM\ManyToOne(inversedBy: 'countries')]
  35.     private ?User $createdBy = null;
  37.     #[ORM\OneToMany(mappedBy: 'country', targetEntity: Province::class)]
  38.     private Collection $provinces;
  40.     #[ORM\OneToMany(mappedBy: 'country', targetEntity: Residence::class)]
  41.     private Collection $residences;
  43.     #[ORM\Column(nullable: true)]
  44.     private ?bool $status = null;
  46.     #[ORM\OneToMany(mappedBy: 'country', targetEntity: Entreprise::class)]
  47.     private Collection $entreprises;
  49.     #[ORM\OneToMany(mappedBy: 'country', targetEntity: User::class)]
  50.     private Collection $users;
  52.     public function __construct()
  53.     {
  54.         $this->provinces = new ArrayCollection();
  55.         $this->residences = new ArrayCollection();
  56.         $this->entreprises = new ArrayCollection();
  57.         $this->users = new ArrayCollection();
  58.     }
  60.     public function getId(): ?int
  61.     {
  62.         return $this->id;
  63.     }
  65.     public function getCode(): ?string
  66.     {
  67.         return $this->code;
  68.     }
  70.     public function setCode(string $code): static
  71.     {
  72.         $this->code = $code;
  74.         return $this;
  75.     }
  77.     public function getCountryCode(): ?string
  78.     {
  79.         return $this->countryCode;
  80.     }
  82.     public function setCountryCode(?string $countryCode): static
  83.     {
  84.         $this->countryCode = $countryCode;
  86.         return $this;
  87.     }
  89.     public function getName(): ?string
  90.     {
  91.         return $this->name;
  92.     }
  94.     public function setName(?string $name): static
  95.     {
  96.         $this->name = $name;
  98.         return $this;
  99.     }
  101.     public function getIsoCode(): ?string
  102.     {
  103.         return $this->isoCode;
  104.     }
  106.     public function setIsoCode(?string $isoCode): static
  107.     {
  108.         $this->isoCode = $isoCode;
  110.         return $this;
  111.     }
  113.     public function getCreatedBy(): ?User
  114.     {
  115.         return $this->createdBy;
  116.     }
  118.     public function setCreatedBy(?User $createdBy): static
  119.     {
  120.         $this->createdBy = $createdBy;
  122.         return $this;
  123.     }
  125.     /**
  126.      * @return Collection<int, Province>
  127.      */
  128.     public function getProvinces(): Collection
  129.     {
  130.         return $this->provinces;
  131.     }
  133.     public function addProvince(Province $province): static
  134.     {
  135.         if (!$this->provinces->contains($province)) {
  136.             $this->provinces->add($province);
  137.             $province->setCountry($this);
  138.         }
  140.         return $this;
  141.     }
  143.     public function removeProvince(Province $province): static
  144.     {
  145.         if ($this->provinces->removeElement($province)) {
  146.             // set the owning side to null (unless already changed)
  147.             if ($province->getCountry() === $this) {
  148.                 $province->setCountry(null);
  149.             }
  150.         }
  152.         return $this;
  153.     }
  155.     /**
  156.      * @return Collection<int, Residence>
  157.      */
  158.     public function getResidences(): Collection
  159.     {
  160.         return $this->residences;
  161.     }
  163.     public function addResidence(Residence $residence): static
  164.     {
  165.         if (!$this->residences->contains($residence)) {
  166.             $this->residences->add($residence);
  167.             $residence->setCountry($this);
  168.         }
  170.         return $this;
  171.     }
  173.     public function removeResidence(Residence $residence): static
  174.     {
  175.         if ($this->residences->removeElement($residence)) {
  176.             // set the owning side to null (unless already changed)
  177.             if ($residence->getCountry() === $this) {
  178.                 $residence->setCountry(null);
  179.             }
  180.         }
  182.         return $this;
  183.     }
  185.     public function __toString(): string
  186.     {
  187.         return $this->name;
  188.     }
  190.     public function isStatus(): ?bool
  191.     {
  192.         return $this->status;
  193.     }
  195.     public function setStatus(?bool $status): static
  196.     {
  197.         $this->status = $status;
  199.         return $this;
  200.     }
  202.     /**
  203.      * @return Collection<int, Entreprise>
  204.      */
  205.     public function getEntreprises(): Collection
  206.     {
  207.         return $this->entreprises;
  208.     }
  210.     public function addEntreprise(Entreprise $entreprise): static
  211.     {
  212.         if (!$this->entreprises->contains($entreprise)) {
  213.             $this->entreprises->add($entreprise);
  214.             $entreprise->setCountry($this);
  215.         }
  217.         return $this;
  218.     }
  220.     public function removeEntreprise(Entreprise $entreprise): static
  221.     {
  222.         if ($this->entreprises->removeElement($entreprise)) {
  223.             // set the owning side to null (unless already changed)
  224.             if ($entreprise->getCountry() === $this) {
  225.                 $entreprise->setCountry(null);
  226.             }
  227.         }
  229.         return $this;
  230.     }
  232.     /**
  233.      * @return Collection<int, User>
  234.      */
  235.     public function getUsers(): Collection
  236.     {
  237.         return $this->users;
  238.     }
  240.     public function addUser(User $user): static
  241.     {
  242.         if (!$this->users->contains($user)) {
  243.             $this->users->add($user);
  244.             $user->setCountry($this);
  245.         }
  247.         return $this;
  248.     }
  250.     public function removeUser(User $user): static
  251.     {
  252.         if ($this->users->removeElement($user)) {
  253.             // set the owning side to null (unless already changed)
  254.             if ($user->getCountry() === $this) {
  255.                 $user->setCountry(null);
  256.             }
  257.         }
  259.         return $this;
  260.     }
  261. }