src/Entity/Patch.php line 10

Open in your IDE?
  1. <?php
  2. namespace App\Entity;
  3. use Doctrine\Common\Collections\ArrayCollection;
  4. use Doctrine\Common\Collections\Collection;
  5. use Doctrine\ORM\Mapping as ORM;
  7. #[ORM\Table(name: 'patch')]
  8. #[ORM\Index(name: 'ix_uuid', columns: ['uuid'])]
  9. #[ORM\Entity(repositoryClass: 'App\Entity\Repository\PatchRepository')]
  10. class Patch
  11. {
  12.     #[ORM\Id]
  13.     #[ORM\Column(type: 'integer')]
  14.     #[ORM\GeneratedValue(strategy: 'AUTO')]
  15.     private $id;
  17.     #[ORM\Column(type: 'string', nullable: true)]
  18.     private $name;
  20.     #[ORM\Column(type: 'json', nullable: true)]
  21.     private $microclimate;
  23.     #[ORM\Column(type: 'json', nullable: true)]
  24.     private $location;
  26.     #[ORM\Column(type: 'integer', nullable: true)]
  27.     private $width;
  29.     #[ORM\Column(type: 'integer', nullable: true)]
  30.     private $length;
  32.     #[ORM\Column(type: 'integer', nullable: true)]
  33.     private $amount_rows;
  35.     #[ORM\Column(type: 'integer', nullable: true)]
  36.     private $amount_cols;
  38.     #[ORM\Column(type: 'integer', nullable: true)]
  39.     private $rasterSize;
  41.     #[ORM\Column(type: 'boolean', nullable: true)]
  42.     private $initialized;
  44.     #[ORM\Column(type: 'json', nullable: true)]
  45.     private $settings;
  47.     /**
  48.      *
  49.      */
  50.     private $rows;
  52.     /**
  53.      *
  54.      */
  55.     private $cols;
  57.     #[ORM\Column(type: 'string', nullable: true)]
  58.     private $shape;
  60.     #[ORM\Column(type: 'datetime', nullable: false)]
  61.     private $date_created;
  63.     #[ORM\Column(type: 'datetime', nullable: true)]
  64.     private $date_updated;
  66.     #[ORM\Column(type: 'integer', nullable: true)]
  67.     private $position_x;
  69.     #[ORM\Column(type: 'integer', nullable: true)]
  70.     private $position_y;
  72.     #[ORM\OneToMany(targetEntity: 'App\Entity\Patch', mappedBy: 'parentPatch')]
  73.     private $childPatch;
  75.     #[ORM\OneToMany(targetEntity: 'App\Entity\Patchfield', mappedBy: 'patch')]
  76.     private $patchfield;
  78.     /**
  79.      *
  80.      */
  81.     private $patchCrop;
  83.     #[ORM\OneToMany(targetEntity: 'App\Entity\PatchfieldGroup', mappedBy: 'patch')]
  84.     private $patchfieldGroup;
  86.     #[ORM\ManyToOne(targetEntity: 'App\Entity\User', inversedBy: 'patch')]
  87.     #[ORM\JoinColumn(name: 'user_id', referencedColumnName: 'id', nullable: false)]
  88.     private $user;
  90.     #[ORM\ManyToOne(targetEntity: 'App\Entity\Patch', inversedBy: 'childPatch')]
  91.     #[ORM\JoinColumn(name: 'patch_id', referencedColumnName: 'id')]
  92.     private $parentPatch;
  94.     #[ORM\OneToMany(targetEntity: Plant::class, mappedBy: 'patch')]
  95.     private $plants;
  97.     #[ORM\Column(type: 'boolean', nullable: true)]
  98.     private $isNewPlan;
  100.     #[ORM\Column(type: 'guid', nullable: true)]
  101.     private $uuid;
  103.     #[ORM\Column(type: 'json', nullable: true)]
  104.     private $data = [];
  106.     #[ORM\ManyToOne(targetEntity: Garden::class, inversedBy: 'patches')]
  107.     private $garden;
  109.     public function __construct()
  110.     {
  111.         $this->patchCrop = new ArrayCollection();
  112.         $this->patchfieldGroup = new ArrayCollection();
  113.         $this->patchfield = new ArrayCollection();
  114.         $this->childPatch = new ArrayCollection();
  115.         $this->plants = new ArrayCollection();
  116.         $this->date_created = new \DateTime();
  117.     }
  119.     public function __clone() {
  120.         $this->id = null;
  121.         $this->patchCrop = new ArrayCollection();
  122.         $this->patchfieldGroup = new ArrayCollection();
  123.         $this->patchfield = new ArrayCollection();
  124.         $this->childPatch = new ArrayCollection();
  125.     }
  127.     public function getId(): ?int
  128.     {
  129.         return $this->id;
  130.     }
  132.     public function getName(): ?string
  133.     {
  134.         if( empty($this->name) && isset($this->data['name']) ) {
  135.             return $this->data['name'];
  136.         }
  137.         return $this->name;
  138.     }
  140.     public function setName(?string $name): self
  141.     {
  142.         $this->name = $name;
  144.         return $this;
  145.     }
  147.     public function getMicroclimate()
  148.     {
  149.         return $this->microclimate;
  150.     }
  152.     public function setMicroclimate($microclimate): self
  153.     {
  154.         $this->microclimate = $microclimate;
  156.         return $this;
  157.     }
  159.     public function getWidth(): ?int
  160.     {
  161.         return $this->width;
  162.     }
  164.     public function setWidth(?int $width): self
  165.     {
  166.         $this->width = $width;
  168.         return $this;
  169.     }
  171.     public function getLength(): ?int
  172.     {
  173.         return $this->length;
  174.     }
  176.     public function setLength(?int $length): self
  177.     {
  178.         $this->length = $length;
  180.         return $this;
  181.     }
  183.     public function getShape(): ?string
  184.     {
  185.         return $this->shape;
  186.     }
  188.     public function setShape(?string $shape): self
  189.     {
  190.         $this->shape = $shape;
  192.         return $this;
  193.     }
  195.     public function getDateCreated(): ?\DateTimeInterface
  196.     {
  197.         return $this->date_created;
  198.     }
  200.     public function setDateCreated(\DateTimeInterface $date_created): self
  201.     {
  202.         $this->date_created = $date_created;
  204.         return $this;
  205.     }
  207.     /**
  208.      * @return Collection|Patchfield[]
  209.      */
  210.     public function getPatchCrop(): Collection
  211.     {
  212.         return $this->patchCrop;
  213.     }
  215.     public function addPatchCrop(Patchfield $patchCrop): self
  216.     {
  217.         if (!$this->patchCrop->contains($patchCrop)) {
  218.             $this->patchCrop[] = $patchCrop;
  219.             $patchCrop->setPatch($this);
  220.         }
  222.         return $this;
  223.     }
  225.     public function removePatchCrop(Patchfield $patchCrop): self
  226.     {
  227.         if ($this->patchCrop->contains($patchCrop)) {
  228.             $this->patchCrop->removeElement($patchCrop);
  229.             // set the owning side to null (unless already changed)
  230.             if ($patchCrop->getPatch() === $this) {
  231.                 $patchCrop->setPatch(null);
  232.             }
  233.         }
  235.         return $this;
  236.     }
  238.     public function getUser(): ?User
  239.     {
  240.         return $this->user;
  241.     }
  243.     public function setUser(?User $user): self
  244.     {
  245.         $this->user = $user;
  247.         return $this;
  248.     }
  250.     /**
  251.      * @return Collection|PatchfieldGroup[]
  252.      */
  253.     public function getPatchfieldGroup(): Collection
  254.     {
  255.         return $this->patchfieldGroup;
  256.     }
  258.     public function addPatchfieldGroup(PatchfieldGroup $patchfieldGroup): self
  259.     {
  260.         if (!$this->patchfieldGroup->contains($patchfieldGroup)) {
  261.             $this->patchfieldGroup[] = $patchfieldGroup;
  262.             $patchfieldGroup->setPatch($this);
  263.         }
  265.         return $this;
  266.     }
  268.     public function removePatchfieldGroup(PatchfieldGroup $patchfieldGroup): self
  269.     {
  270.         if ($this->patchfieldGroup->contains($patchfieldGroup)) {
  271.             $this->patchfieldGroup->removeElement($patchfieldGroup);
  272.             // set the owning side to null (unless already changed)
  273.             if ($patchfieldGroup->getPatch() === $this) {
  274.                 $patchfieldGroup->setPatch(null);
  275.             }
  276.         }
  278.         return $this;
  279.     }
  281.     public function getAmountRows(): ?int
  282.     {
  283.         return $this->amount_rows;
  284.     }
  286.     public function setAmountRows(?int $amount_rows): self
  287.     {
  288.         $this->amount_rows = $amount_rows;
  290.         return $this;
  291.     }
  293.     public function getAmountCols(): ?int
  294.     {
  295.         return $this->amount_cols;
  296.     }
  298.     public function setAmountCols(?int $amount_cols): self
  299.     {
  300.         $this->amount_cols = $amount_cols;
  302.         return $this;
  303.     }
  305.     /**
  306.      * @return Collection|Patchfield[]
  307.      */
  308.     public function getPatchfield(): Collection
  309.     {
  310.         return $this->patchfield;
  311.     }
  313.     public function addPatchfield(Patchfield $patchfield): self
  314.     {
  315.         if (!$this->patchfield->contains($patchfield)) {
  316.             $this->patchfield[] = $patchfield;
  317.             $patchfield->setPatch($this);
  318.         }
  320.         return $this;
  321.     }
  323.     public function removePatchfield(Patchfield $patchfield): self
  324.     {
  325.         if ($this->patchfield->contains($patchfield)) {
  326.             $this->patchfield->removeElement($patchfield);
  327.             // set the owning side to null (unless already changed)
  328.             if ($patchfield->getPatch() === $this) {
  329.                 $patchfield->setPatch(null);
  330.             }
  331.         }
  333.         return $this;
  334.     }
  336.     public function getDateUpdated(): ?\DateTimeInterface
  337.     {
  338.         return $this->date_updated;
  339.     }
  341.     public function setDateUpdated(?\DateTimeInterface $date_updated): self
  342.     {
  343.         $this->date_updated = $date_updated;
  345.         return $this;
  346.     }
  348.     public function getInitialized(): ?bool
  349.     {
  350.         return $this->initialized;
  351.     }
  353.     public function setInitialized(?bool $initialized): self
  354.     {
  355.         $this->initialized = $initialized;
  357.         return $this;
  358.     }
  360.     public function getLocation()
  361.     {
  362.         return $this->location;
  363.     }
  365.     public function setLocation($location): self
  366.     {
  367.         $this->location = $location;
  369.         return $this;
  370.     }
  372.     public function getPositionX(): ?int
  373.     {
  374.         return $this->position_x;
  375.     }
  377.     public function setPositionX(?int $position_x): self
  378.     {
  379.         $this->position_x = $position_x;
  381.         return $this;
  382.     }
  384.     public function getPositionY(): ?int
  385.     {
  386.         return $this->position_y;
  387.     }
  389.     public function setPositionY(?int $position_y): self
  390.     {
  391.         $this->position_y = $position_y;
  393.         return $this;
  394.     }
  396.     /**
  397.      * @return Collection|Patch[]
  398.      */
  399.     public function getChildPatch(): Collection
  400.     {
  401.         return $this->childPatch;
  402.     }
  404.     public function addChildPatch(Patch $childPatch): self
  405.     {
  406.         if (!$this->childPatch->contains($childPatch)) {
  407.             $this->childPatch[] = $childPatch;
  408.             $childPatch->setParentPatch($this);
  409.         }
  411.         return $this;
  412.     }
  414.     public function removeChildPatch(Patch $childPatch): self
  415.     {
  416.         if ($this->childPatch->contains($childPatch)) {
  417.             $this->childPatch->removeElement($childPatch);
  418.             // set the owning side to null (unless already changed)
  419.             if ($childPatch->getParentPatch() === $this) {
  420.                 $childPatch->setParentPatch(null);
  421.             }
  422.         }
  424.         return $this;
  425.     }
  427.     public function getParentPatch(): ?self
  428.     {
  429.         return $this->parentPatch;
  430.     }
  432.     public function setParentPatch(?self $parentPatch): self
  433.     {
  434.         $this->parentPatch = $parentPatch;
  436.         return $this;
  437.     }
  439.     public function getRasterSize(): ?int
  440.     {
  441.         return $this->rasterSize;
  442.     }
  444.     public function setRasterSize(?int $rasterSize): self
  445.     {
  446.         $this->rasterSize = $rasterSize;
  448.         return $this;
  449.     }
  451.     public function getSettings()
  452.     {
  453.         return $this->settings;
  454.     }
  456.     public function setSettings($settings): self
  457.     {
  458.         $this->settings = $settings;
  460.         return $this;
  461.     }
  463.     /**
  464.      * @return Collection|Plant[]
  465.      */
  466.     public function getPlants(): Collection
  467.     {
  468.         return $this->plants;
  469.     }
  471.     public function addPlant(Plant $plant): self
  472.     {
  473.         if (!$this->plants->contains($plant)) {
  474.             $this->plants[] = $plant;
  475.             $plant->setPatch($this);
  476.         }
  478.         return $this;
  479.     }
  481.     public function removePlant(Plant $plant): self
  482.     {
  483.         if ($this->plants->removeElement($plant)) {
  484.             // set the owning side to null (unless already changed)
  485.             if ($plant->getPatch() === $this) {
  486.                 $plant->setPatch(null);
  487.             }
  488.         }
  490.         return $this;
  491.     }
  493.     public function getIsNewPlan(): ?bool
  494.     {
  495.         return $this->isNewPlan;
  496.     }
  498.     public function setIsNewPlan(?bool $isNewPlan): self
  499.     {
  500.         $this->isNewPlan = $isNewPlan;
  502.         return $this;
  503.     }
  505.     public function getUuid(): ?string
  506.     {
  507.         return $this->uuid;
  508.     }
  510.     public function setUuid(?string $uuid): self
  511.     {
  512.         $this->uuid = $uuid;
  514.         return $this;
  515.     }
  517.     public function getData(): ?array
  518.     {
  519.         return $this->data;
  520.     }
  522.     public function setData(?array $data): self
  523.     {
  524.         $this->data = $data;
  526.         return $this;
  527.     }
  529.     public function getGarden(): ?Garden
  530.     {
  531.         return $this->garden;
  532.     }
  534.     public function setGarden(?Garden $garden): self
  535.     {
  536.         $this->garden = $garden;
  538.         return $this;
  539.     }
  540. }