src/Entity/Countries.php line 14

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\CountriesRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Symfony\Component\Serializer\Annotation\Groups;
  9. use Doctrine\ORM\Mapping as ORM;
  11. /**
  12.  * @ORM\Entity(repositoryClass=CountriesRepository::class)
  13.  */
  14. class Countries
  15. {
  16.     /**
  17.      * @ORM\Id
  18.      * @ORM\GeneratedValue
  19.      * @ORM\Column(type="integer")
  20.      * Groups("partner")
  21.      * @Groups({
  22.      *     "country.base",
  23.      *     "counties.basic",
  24.      *     "project.branches",
  25.      *     "project.owner",
  26.      *     "project.base",
  27.      *     "countries.base",
  28.      *     "partner.list.base",
  29.      *     "partner.manage.base",
  30.      *     "branch.location.base",
  31.      *
  32.      *     "country.core",
  33.      *
  34.      *
  35.      *     "country@core"
  36.      * })
  37.      *
  38.      */
  39.     private $id;
  41.     /**
  42.      * @ORM\Column(type="string", length=255)
  43.      * @Groups({
  44.      *     "counties.basic",
  45.      *     "project.branches",
  46.      *     "project.owner",
  47.     *      "project.base",
  48.      *     "countries.base",
  49.      *     "partner.list.base",
  50.      *     "partner.manage.base",
  51.      *     "branch.location.base",
  52.      *     "project.list.with.necessary.details",
  53.      *
  54.      *     "project.details",
  55.      *
  56.      *     "country.base",
  57.      *
  58.      *     "country.core",
  59.      *
  60.      *     "country@core"
  61.      * })
  62.      */
  63.     private $name;
  65.     /**
  66.      * @ORM\Column(type="string", length=5)
  67.      * @Groups({
  68.      *     "country@core"
  69.      * })
  70.      */
  71.     private $iso_code;
  73.     /**
  74.      * @ORM\OneToMany(targetEntity=ProjectOwner::class, mappedBy="country")
  75.      */
  76.     private $projectOwners;
  78.     /**
  79.      * @ORM\OneToMany(targetEntity=Projects::class, mappedBy="country")
  80.      */
  81.     private $projects;
  83.     /**
  84.      * @ORM\OneToMany(targetEntity=Addresses::class, mappedBy="country")
  85.      */
  86.     private $addresses;
  88.     /**
  89.      * @ORM\OneToMany(targetEntity=Vendor::class, mappedBy="country")
  90.      */
  91.     private $vendors;
  95.     public function __construct()
  96.     {
  97.         $this->partners = new ArrayCollection();
  98.         $this->projectOwners = new ArrayCollection();
  99.         $this->projects = new ArrayCollection();
  100.         $this->addresses = new ArrayCollection();
  101.         $this->vendors = new ArrayCollection();
  102.     }
  104.     public function getId(): ?int
  105.     {
  106.         return $this->id;
  107.     }
  109.     public function getName(): ?string
  110.     {
  111.         return $this->name;
  112.     }
  114.     public function setName(string $name): self
  115.     {
  116.         $this->name = $name;
  118.         return $this;
  119.     }
  121.     public function getIsoCode(): ?string
  122.     {
  123.         return $this->iso_code;
  124.     }
  126.     public function setIsoCode(string $iso_code): self
  127.     {
  128.         $this->iso_code = $iso_code;
  130.         return $this;
  131.     }
  133.     /**
  134.      * @return Collection<int, ProjectOwner>
  135.      */
  136.     public function getProjectOwners(): Collection
  137.     {
  138.         return $this->projectOwners;
  139.     }
  141.     public function addProjectOwner(ProjectOwner $projectOwner): self
  142.     {
  143.         if (!$this->projectOwners->contains($projectOwner)) {
  144.             $this->projectOwners[] = $projectOwner;
  145.             $projectOwner->setCountry($this);
  146.         }
  148.         return $this;
  149.     }
  151.     public function removeProjectOwner(ProjectOwner $projectOwner): self
  152.     {
  153.         if ($this->projectOwners->removeElement($projectOwner)) {
  154.             // set the owning side to null (unless already changed)
  155.             if ($projectOwner->getCountry() === $this) {
  156.                 $projectOwner->setCountry(null);
  157.             }
  158.         }
  160.         return $this;
  161.     }
  163.     /**
  164.      * @return Collection<int, Projects>
  165.      */
  166.     public function getProjects(): Collection
  167.     {
  168.         return $this->projects;
  169.     }
  171.     public function addProject(Projects $project): self
  172.     {
  173.         if (!$this->projects->contains($project)) {
  174.             $this->projects[] = $project;
  175.             $project->setCountry($this);
  176.         }
  178.         return $this;
  179.     }
  181.     public function removeProject(Projects $project): self
  182.     {
  183.         if ($this->projects->removeElement($project)) {
  184.             // set the owning side to null (unless already changed)
  185.             if ($project->getCountry() === $this) {
  186.                 $project->setCountry(null);
  187.             }
  188.         }
  190.         return $this;
  191.     }
  193.     /**
  194.      * @return Collection<int, Addresses>
  195.      */
  196.     public function getAddresses(): Collection
  197.     {
  198.         return $this->addresses;
  199.     }
  201.     public function addAdress(Addresses $adress): self
  202.     {
  203.         if (!$this->addresses->contains($adress)) {
  204.             $this->addresses[] = $adress;
  205.             $adress->setCountry($this);
  206.         }
  208.         return $this;
  209.     }
  211.     public function removeAdress(Addresses $adress): self
  212.     {
  213.         if ($this->addresses->removeElement($adress)) {
  214.             // set the owning side to null (unless already changed)
  215.             if ($adress->getCountry() === $this) {
  216.                 $adress->setCountry(null);
  217.             }
  218.         }
  220.         return $this;
  221.     }
  223.     /**
  224.      * @return Collection<int, Vendor>
  225.      */
  226.     public function getVendors(): Collection
  227.     {
  228.         return $this->vendors;
  229.     }
  231.     public function addVendor(Vendor $vendor): self
  232.     {
  233.         if (!$this->vendors->contains($vendor)) {
  234.             $this->vendors[] = $vendor;
  235.             $vendor->setCountry($this);
  236.         }
  238.         return $this;
  239.     }
  241.     public function removeVendor(Vendor $vendor): self
  242.     {
  243.         if ($this->vendors->removeElement($vendor)) {
  244.             // set the owning side to null (unless already changed)
  245.             if ($vendor->getCountry() === $this) {
  246.                 $vendor->setCountry(null);
  247.             }
  248.         }
  250.         return $this;
  251.     }
  254. }