src/Entity/Crop.php line 15

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Translation\AutoTranslatableTrait;
  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;
  10. use Knp\DoctrineBehaviors\Contract\Entity\TranslatableInterface;
  12. #[ORM\Table(name: 'crop')]
  13. #[ORM\Index(name: 'IX_identifier', columns: ['identifier'])]
  14. #[ORM\Entity(repositoryClass: 'App\Entity\Repository\CropRepository')]
  15. class Crop implements TranslatableInterface
  16. {
  17.     use AutoTranslatableTrait;
  19.     #[ORM\Id]
  20.     #[ORM\Column(type: 'integer')]
  21.     #[ORM\GeneratedValue(strategy: 'AUTO')]
  22.     private $id;
  24.     #[ORM\Column(type: 'string', nullable: true)]
  25.     private $identifier;
  27.     #[ORM\Column(type: 'string', nullable: true)]
  28.     private $name;
  30.     #[ORM\Column(type: 'string', nullable: true)]
  31.     private $latin_name;
  33.     #[ORM\Column(type: 'text', nullable: true)]
  34.     private $description;
  36.     #[ORM\Column(type: 'text', nullable: true)]
  37.     private $short_description;
  39.     #[ORM\Column(type: 'string', nullable: true)]
  40.     private $origin;
  42.     #[ORM\Column(type: 'json', nullable: true)]
  43.     private $growing_tipps;
  45.     #[ORM\Column(type: 'string', nullable: true)]
  46.     private $cultivation_cycles;
  48.     #[ORM\Column(type: 'json', nullable: true)]
  49.     private $germination_duration;
  51.     #[ORM\Column(type: 'json', nullable: true)]
  52.     private $germination_season;
  54.     #[ORM\Column(type: 'json', nullable: true)]
  55.     private $precultivation_duration;
  57.     #[ORM\Column(type: 'json', nullable: true)]
  58.     private $precultivation_season;
  60.     #[ORM\Column(type: 'boolean', nullable: true)]
  61.     private $has_precultivation;
  63.     #[ORM\Column(type: 'json', nullable: true)]
  64.     private $growth_duration;
  66.     #[ORM\Column(type: 'json', nullable: true)]
  67.     private $growth_season;
  69.     #[ORM\Column(type: 'json', nullable: true)]
  70.     private $harvest_duration;
  72.     #[ORM\Column(type: 'json', nullable: true)]
  73.     private $harvest_season;
  75.     #[ORM\Column(type: 'json', nullable: true)]
  76.     private $lightscore;
  78.     #[ORM\Column(type: 'integer', nullable: true)]
  79.     private $grid_length;
  81.     #[ORM\Column(type: 'integer', nullable: true)]
  82.     private $grid_width;
  84.     #[ORM\Column(type: 'float', nullable: true)]
  85.     private $harvest_amount;
  87.     #[ORM\Column(type: 'string', nullable: true)]
  88.     private $nutrient_demand;
  90.     #[ORM\Column(type: 'string', nullable: true)]
  91.     private $lighting_demand;
  93.     #[ORM\Column(type: 'string', nullable: true)]
  94.     private $water_demand;
  96.     #[ORM\Column(type: 'json', nullable: true)]
  97.     private $seeding_depth;
  99.     #[ORM\Column(type: 'json', nullable: true)]
  100.     private $seeding_distance;
  102.     #[ORM\Column(type: 'string', nullable: true)]
  103.     private $spread;
  105.     #[ORM\Column(type: 'json', nullable: true)]
  106.     private $compatibility;
  108.     #[ORM\Column(type: 'boolean', nullable: true)]
  109.     private $plant_in_rows;
  111.     #[ORM\Column(type: 'boolean', nullable: true)]
  112.     private $f1_hybrid;
  114.     #[ORM\Column(type: 'json', nullable: true)]
  115.     private $row_distance;
  117.     #[ORM\Column(type: 'string', nullable: true)]
  118.     private $fertilizer_type;
  120.     #[ORM\Column(type: 'json', nullable: true)]
  121.     private $user_crop_settings;
  123.     #[ORM\Column(type: 'string', nullable: true)]
  124.     private $ground_type;
  126.     #[ORM\Column(type: 'boolean', nullable: true)]
  127.     private $cold_resistant;
  129.     #[ORM\Column(type: 'boolean', nullable: true)]
  130.     private $is_shared;
  132.     #[ORM\Column(type: 'boolean', nullable: true)]
  133.     private $is_approved;
  135.     #[ORM\Column(type: 'datetime', nullable: false)]
  136.     private $date_created;
  138.     #[ORM\Column(type: 'datetime', nullable: true)]
  139.     private $date_updated;
  141.     #[ORM\OneToMany(targetEntity: 'App\Entity\Crop', mappedBy: 'parentCrop')]
  142.     private $childCrop;
  144.     #[ORM\OneToMany(targetEntity: 'App\Entity\Patchfield', mappedBy: 'crop')]
  145.     private $patchCrop;
  147.     #[ORM\OneToMany(targetEntity: 'App\Entity\CropPest', mappedBy: 'crop')]
  148.     private $cropPest;
  150.     #[ORM\OneToMany(targetEntity: 'App\Entity\CropDisease', mappedBy: 'crop')]
  151.     private $cropDisease;
  153.     #[ORM\OneToMany(targetEntity: 'App\Entity\Cropaction', mappedBy: 'crop')]
  154.     private $cropaction;
  156.     #[ORM\OneToMany(targetEntity: 'App\Entity\PlanCrop', mappedBy: 'crop')]
  157.     private $planCrop;
  159.     #[ORM\OneToMany(targetEntity: 'App\Entity\ShoparticleCrop', mappedBy: 'crop')]
  160.     private $shoparticleCrop;
  162.     #[ORM\OneToMany(targetEntity: 'App\Entity\FavoriteCrop', mappedBy: 'crop')]
  163.     private $favoriteCrop;
  165.     #[ORM\OneToMany(targetEntity: 'App\Entity\CropSynonym', mappedBy: 'crop')]
  166.     private $cropSynonym;
  168.     #[ORM\OneToMany(targetEntity: 'App\Entity\CropEdit', mappedBy: 'crop')]
  169.     private $cropEdit;
  171.     #[ORM\OneToMany(targetEntity: 'App\Entity\CropRating', mappedBy: 'crop')]
  172.     private $cropRating;
  174.     #[ORM\ManyToOne(targetEntity: 'App\Entity\Cropcategory', inversedBy: 'crop')]
  175.     #[ORM\JoinColumn(name: 'cropcategory_id', referencedColumnName: 'id')]
  176.     private $cropcategory;
  178.     #[ORM\ManyToOne(targetEntity: 'App\Entity\Crop', inversedBy: 'childCrop')]
  179.     #[ORM\JoinColumn(name: 'parent_crop_id', referencedColumnName: 'id')]
  180.     private $parentCrop;
  182.     #[ORM\ManyToOne(targetEntity: 'App\Entity\User', inversedBy: 'crop')]
  183.     #[ORM\JoinColumn(name: 'user_id', referencedColumnName: 'id')]
  184.     private $user;
  186.     #[ORM\ManyToOne(targetEntity: 'App\Entity\Plantfamily', inversedBy: 'crop')]
  187.     #[ORM\JoinColumn(name: 'plantfamily_id', referencedColumnName: 'id')]
  188.     private $plantfamily;
  190.     #[ORM\Column(type: 'integer', nullable: true)]
  191.     private $popularity;
  193.     #[ORM\Column(type: 'json', nullable: true)]
  194.     private $seasons = [];
  196.     #[ORM\OneToMany(targetEntity: CropProperty::class, mappedBy: 'crop', orphanRemoval: true)]
  197.     private $cropProperties;
  199.     #[ORM\OneToMany(targetEntity: CropTranslation::class, mappedBy: 'translatable', orphanRemoval: true)]
  200.     private $cropTranslation;
  202.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  203.     private $dynamic_link;
  205.     #[ORM\Column(nullable: true)]
  206.     private ?float $cultivation_break = null;
  208.     #[ORM\Column(length: 10, nullable: true)]
  209.     private ?string $germination_type = null;
  211.     #[ORM\Column(length: 10, nullable: true)]
  212.     private ?string $germination_temperature = null;
  214.     #[ORM\Column(length: 255, nullable: true)]
  215.     private ?string $shop_category_url = null;
  217.     #[ORM\Column(length: 50, nullable: true)]
  218.     private ?string $growth_habit = null;
  220.     #[ORM\OneToMany(mappedBy: 'crop', targetEntity: ShoparticleBlockentry::class, orphanRemoval: true)]
  221.     private Collection $shoparticleBlockentries;
  223.     #[ORM\Column(nullable: true)]
  224.     private ?bool $isGreenManure = null;
  226.     #[ORM\OneToMany(mappedBy: 'crop', targetEntity: CropImage::class, orphanRemoval: true)]
  227.     private Collection $cropImages;
  229.     #[ORM\ManyToOne]
  230.     private ?Climatezone $climatezone = null;
  232.     #[ORM\Column(type: Types::BIGINT, nullable: true)]
  233.     private ?string $gtin_barcode = null;
  235.     public function __construct()
  236.     {
  237.         $this->patchCrop = new ArrayCollection();
  238.         $this->cropPest = new ArrayCollection();
  239.         $this->cropDisease = new ArrayCollection();
  240.         $this->cropaction = new ArrayCollection();
  241.         $this->planCrop = new ArrayCollection();
  242.         $this->shoparticleCrop = new ArrayCollection();
  243.         $this->favoriteCrop = new ArrayCollection();
  244.         $this->childCrop = new ArrayCollection();
  245.         $this->cropSynonym = new ArrayCollection();
  246.         $this->cropEdit = new ArrayCollection();
  247.         $this->cropRating = new ArrayCollection();
  248.         $this->cropProperties = new ArrayCollection();
  249.         $this->shoparticleBlockentries = new ArrayCollection();
  250.         $this->cropImages = new ArrayCollection();
  251.     }
  253.     public function getId(): ?int
  254.     {
  255.         return $this->id;
  256.     }
  258.     public function getIdentifier(): ?string
  259.     {
  260.         return $this->identifier;
  261.     }
  263.     public function setIdentifier(?string $identifier): self
  264.     {
  265.         $this->identifier = $identifier;
  267.         return $this;
  268.     }
  270.     public function getName(bool $skipTranslation = false): ?string
  271.     {
  272.         if ($skipTranslation || $this->getCurrentLocale() === $this->getDefaultLocale()) {
  273.             return $this->name;
  274.         }
  275.         $translated = $this->translate()->getName();
  276.         return !empty($translated) ? $translated : $this->name;
  277.     }
  279.     public function setName(?string $name): self
  280.     {
  281.         $this->name = $name;
  283.         return $this;
  284.     }
  286.     public function getLatinName(): ?string
  287.     {
  288.         return $this->latin_name;
  289.     }
  291.     public function setLatinName(?string $latin_name): self
  292.     {
  293.         $this->latin_name = $latin_name;
  295.         return $this;
  296.     }
  298.     public function getDescription(bool $skipTranslation = false): ?string
  299.     {
  300.         if ($skipTranslation || $this->getCurrentLocale() === $this->getDefaultLocale()) {
  301.             return $this->description;
  302.         }
  303.         $translated = $this->translate()->getDescription();
  304.         return !empty($translated) ? $translated : $this->description;
  305.     }
  307.     public function setDescription(?string $description): self
  308.     {
  309.         $this->description = $description;
  311.         return $this;
  312.     }
  314.     public function getOrigin(bool $skipTranslation = false): ?string
  315.     {
  316.         if ($skipTranslation || $this->getCurrentLocale() === $this->getDefaultLocale()) {
  317.             return $this->origin;
  318.         }
  319.         $translated = $this->translate()->getOrigin();
  320.         return !empty($translated) ? $translated : $this->origin;
  321.     }
  323.     public function setOrigin(?string $origin): self
  324.     {
  325.         $this->origin = $origin;
  327.         return $this;
  328.     }
  330.     public function getGrowingTipps(bool $skipTranslation = false)
  331.     {
  332.         if ($skipTranslation || $this->getCurrentLocale() === $this->getDefaultLocale()) {
  333.             return $this->growing_tipps;
  334.         }
  335.         $translated = $this->translate()->getGrowingTipps();
  336.         return !empty($translated) ? $translated : $this->growing_tipps;
  337.     }
  339.     public function setGrowingTipps($growing_tipps): self
  340.     {
  341.         $this->growing_tipps = $growing_tipps;
  343.         return $this;
  344.     }
  346.     public function getCultivationCycles(): ?string
  347.     {
  348.         return $this->cultivation_cycles;
  349.     }
  351.     public function setCultivationCycles(?string $cultivation_cycles): self
  352.     {
  353.         $this->cultivation_cycles = $cultivation_cycles;
  355.         return $this;
  356.     }
  358.     public function getGerminationDuration()
  359.     {
  360.         return $this->germination_duration;
  361.     }
  363.     public function setGerminationDuration($germination_duration): self
  364.     {
  365.         $this->germination_duration = $germination_duration;
  367.         return $this;
  368.     }
  370.     public function getGrowthDuration()
  371.     {
  372.         return $this->growth_duration;
  373.     }
  375.     public function setGrowthDuration($growth_duration): self
  376.     {
  377.         $this->growth_duration = $growth_duration;
  379.         return $this;
  380.     }
  382.     public function getGrowthSeason()
  383.     {
  384.         return $this->growth_season;
  385.     }
  387.     public function setGrowthSeason($growth_season): self
  388.     {
  389.         $this->growth_season = $growth_season;
  391.         return $this;
  392.     }
  394.     public function getHarvestDuration()
  395.     {
  396.         return $this->harvest_duration;
  397.     }
  399.     public function setHarvestDuration($harvest_duration): self
  400.     {
  401.         $this->harvest_duration = $harvest_duration;
  403.         return $this;
  404.     }
  406.     public function getHarvestSeason()
  407.     {
  408.         return $this->harvest_season;
  409.     }
  411.     public function setHarvestSeason($harvest_season): self
  412.     {
  413.         $this->harvest_season = $harvest_season;
  415.         return $this;
  416.     }
  418.     public function getLightscore()
  419.     {
  420.         return $this->lightscore;
  421.     }
  423.     public function setLightscore($lightscore): self
  424.     {
  425.         $this->lightscore = $lightscore;
  427.         return $this;
  428.     }
  430.     public function getGridLength(): ?int
  431.     {
  432.         return $this->grid_length;
  433.     }
  435.     public function setGridLength(?int $grid_length): self
  436.     {
  437.         $this->grid_length = $grid_length;
  439.         return $this;
  440.     }
  442.     public function getGridWidth(): ?int
  443.     {
  444.         return $this->grid_width;
  445.     }
  447.     public function setGridWidth(?int $grid_width): self
  448.     {
  449.         $this->grid_width = $grid_width;
  451.         return $this;
  452.     }
  454.     public function getHarvestAmount(): ?float
  455.     {
  456.         return $this->harvest_amount;
  457.     }
  459.     public function setHarvestAmount(?float $harvest_amount): self
  460.     {
  461.         $this->harvest_amount = $harvest_amount;
  463.         return $this;
  464.     }
  466.     public function getNutrientDemand(): ?string
  467.     {
  468.         return $this->nutrient_demand;
  469.     }
  471.     public function setNutrientDemand(?string $nutrient_demand): self
  472.     {
  473.         $this->nutrient_demand = $nutrient_demand;
  475.         return $this;
  476.     }
  478.     public function getLightingDemand(): ?string
  479.     {
  480.         return $this->lighting_demand;
  481.     }
  483.     public function setLightingDemand(?string $lighting_demand): self
  484.     {
  485.         $this->lighting_demand = $lighting_demand;
  487.         return $this;
  488.     }
  490.     public function getSpread(): ?string
  491.     {
  492.         return $this->spread;
  493.     }
  495.     public function setSpread(?string $spread): self
  496.     {
  497.         $this->spread = $spread;
  499.         return $this;
  500.     }
  502.     public function getDateCreated(): ?\DateTimeInterface
  503.     {
  504.         return $this->date_created;
  505.     }
  507.     public function setDateCreated(\DateTimeInterface $date_created): self
  508.     {
  509.         $this->date_created = $date_created;
  511.         return $this;
  512.     }
  514.     /**
  515.      * @return Collection|Patchfield[]
  516.      */
  517.     public function getPatchCrop(): Collection
  518.     {
  519.         return $this->patchCrop;
  520.     }
  522.     public function addPatchCrop(Patchfield $patchCrop): self
  523.     {
  524.         if (!$this->patchCrop->contains($patchCrop)) {
  525.             $this->patchCrop[] = $patchCrop;
  526.             $patchCrop->setCrop($this);
  527.         }
  529.         return $this;
  530.     }
  532.     public function removePatchCrop(Patchfield $patchCrop): self
  533.     {
  534.         if ($this->patchCrop->contains($patchCrop)) {
  535.             $this->patchCrop->removeElement($patchCrop);
  536.             // set the owning side to null (unless already changed)
  537.             if ($patchCrop->getCrop() === $this) {
  538.                 $patchCrop->setCrop(null);
  539.             }
  540.         }
  542.         return $this;
  543.     }
  545.     /**
  546.      * @return Collection|CropPest[]
  547.      */
  548.     public function getCropPest(): Collection
  549.     {
  550.         return $this->cropPest;
  551.     }
  553.     public function addCropPest(CropPest $cropPest): self
  554.     {
  555.         if (!$this->cropPest->contains($cropPest)) {
  556.             $this->cropPest[] = $cropPest;
  557.             $cropPest->setCrop($this);
  558.         }
  560.         return $this;
  561.     }
  563.     public function removeCropPest(CropPest $cropPest): self
  564.     {
  565.         if ($this->cropPest->contains($cropPest)) {
  566.             $this->cropPest->removeElement($cropPest);
  567.             // set the owning side to null (unless already changed)
  568.             if ($cropPest->getCrop() === $this) {
  569.                 $cropPest->setCrop(null);
  570.             }
  571.         }
  573.         return $this;
  574.     }
  576.     /**
  577.      * @return Collection|CropDisease[]
  578.      */
  579.     public function getCropDisease(): Collection
  580.     {
  581.         return $this->cropDisease;
  582.     }
  584.     public function addCropDisease(CropDisease $cropDisease): self
  585.     {
  586.         if (!$this->cropDisease->contains($cropDisease)) {
  587.             $this->cropDisease[] = $cropDisease;
  588.             $cropDisease->setCrop($this);
  589.         }
  591.         return $this;
  592.     }
  594.     public function removeCropDisease(CropDisease $cropDisease): self
  595.     {
  596.         if ($this->cropDisease->contains($cropDisease)) {
  597.             $this->cropDisease->removeElement($cropDisease);
  598.             // set the owning side to null (unless already changed)
  599.             if ($cropDisease->getCrop() === $this) {
  600.                 $cropDisease->setCrop(null);
  601.             }
  602.         }
  604.         return $this;
  605.     }
  607.     /**
  608.      * @return Collection|Cropaction[]
  609.      */
  610.     public function getCropaction(): Collection
  611.     {
  612.         return $this->cropaction;
  613.     }
  615.     public function addCropaction(Cropaction $cropaction): self
  616.     {
  617.         if (!$this->cropaction->contains($cropaction)) {
  618.             $this->cropaction[] = $cropaction;
  619.             $cropaction->setCrop($this);
  620.         }
  622.         return $this;
  623.     }
  625.     public function removeCropaction(Cropaction $cropaction): self
  626.     {
  627.         if ($this->cropaction->contains($cropaction)) {
  628.             $this->cropaction->removeElement($cropaction);
  629.             // set the owning side to null (unless already changed)
  630.             if ($cropaction->getCrop() === $this) {
  631.                 $cropaction->setCrop(null);
  632.             }
  633.         }
  635.         return $this;
  636.     }
  638.     public function getCropcategory(): ?Cropcategory
  639.     {
  640.         return $this->cropcategory;
  641.     }
  643.     public function setCropcategory(?Cropcategory $cropcategory): self
  644.     {
  645.         $this->cropcategory = $cropcategory;
  647.         return $this;
  648.     }
  650.     public function getCompatibility()
  651.     {
  652.         return $this->compatibility;
  653.     }
  655.     public function setCompatibility($compatibility): self
  656.     {
  657.         $this->compatibility = $compatibility;
  659.         return $this;
  660.     }
  662.     /**
  663.      * @return Collection|PlanCrop[]
  664.      */
  665.     public function getPlanCrop(): Collection
  666.     {
  667.         return $this->planCrop;
  668.     }
  670.     public function addPlanCrop(PlanCrop $planCrop): self
  671.     {
  672.         if (!$this->planCrop->contains($planCrop)) {
  673.             $this->planCrop[] = $planCrop;
  674.             $planCrop->setCrop($this);
  675.         }
  677.         return $this;
  678.     }
  680.     public function removePlanCrop(PlanCrop $planCrop): self
  681.     {
  682.         if ($this->planCrop->contains($planCrop)) {
  683.             $this->planCrop->removeElement($planCrop);
  684.             // set the owning side to null (unless already changed)
  685.             if ($planCrop->getCrop() === $this) {
  686.                 $planCrop->setCrop(null);
  687.             }
  688.         }
  690.         return $this;
  691.     }
  693.     /**
  694.      * @return Collection|ShoparticleCrop[]
  695.      */
  696.     public function getShoparticleCrop(): Collection
  697.     {
  698.         return $this->shoparticleCrop;
  699.     }
  701.     public function addShoparticleCrop(ShoparticleCrop $shoparticleCrop): self
  702.     {
  703.         if (!$this->shoparticleCrop->contains($shoparticleCrop)) {
  704.             $this->shoparticleCrop[] = $shoparticleCrop;
  705.             $shoparticleCrop->setCrop($this);
  706.         }
  708.         return $this;
  709.     }
  711.     public function removeShoparticleCrop(ShoparticleCrop $shoparticleCrop): self
  712.     {
  713.         if ($this->shoparticleCrop->contains($shoparticleCrop)) {
  714.             $this->shoparticleCrop->removeElement($shoparticleCrop);
  715.             // set the owning side to null (unless already changed)
  716.             if ($shoparticleCrop->getCrop() === $this) {
  717.                 $shoparticleCrop->setCrop(null);
  718.             }
  719.         }
  721.         return $this;
  722.     }
  724.     public function getPlantInRows(): ?bool
  725.     {
  726.         return $this->plant_in_rows;
  727.     }
  729.     public function setPlantInRows(?bool $plant_in_rows): self
  730.     {
  731.         $this->plant_in_rows = $plant_in_rows;
  733.         return $this;
  734.     }
  736.     public function getGerminationSeason()
  737.     {
  738.         return $this->germination_season;
  739.     }
  741.     public function setGerminationSeason($germination_season): self
  742.     {
  743.         $this->germination_season = $germination_season;
  745.         return $this;
  746.     }
  748.     /**
  749.      * @return Collection|FavoriteCrop[]
  750.      */
  751.     public function getFavoriteCrop(): Collection
  752.     {
  753.         return $this->favoriteCrop;
  754.     }
  756.     public function addFavoriteCrop(FavoriteCrop $favoriteCrop): self
  757.     {
  758.         if (!$this->favoriteCrop->contains($favoriteCrop)) {
  759.             $this->favoriteCrop[] = $favoriteCrop;
  760.             $favoriteCrop->setCrop($this);
  761.         }
  763.         return $this;
  764.     }
  766.     public function removeFavoriteCrop(FavoriteCrop $favoriteCrop): self
  767.     {
  768.         if ($this->favoriteCrop->contains($favoriteCrop)) {
  769.             $this->favoriteCrop->removeElement($favoriteCrop);
  770.             // set the owning side to null (unless already changed)
  771.             if ($favoriteCrop->getCrop() === $this) {
  772.                 $favoriteCrop->setCrop(null);
  773.             }
  774.         }
  776.         return $this;
  777.     }
  779.     public function getWaterDemand(): ?string
  780.     {
  781.         return $this->water_demand;
  782.     }
  784.     public function setWaterDemand(?string $water_demand): self
  785.     {
  786.         $this->water_demand = $water_demand;
  788.         return $this;
  789.     }
  791.     /**
  792.      * @return Collection|Crop[]
  793.      */
  794.     public function getChildCrop(): Collection
  795.     {
  796.         return $this->childCrop;
  797.     }
  799.     public function addChildCrop(Crop $childCrop): self
  800.     {
  801.         if (!$this->childCrop->contains($childCrop)) {
  802.             $this->childCrop[] = $childCrop;
  803.             $childCrop->setParentCrop($this);
  804.         }
  806.         return $this;
  807.     }
  809.     public function removeChildCrop(Crop $childCrop): self
  810.     {
  811.         if ($this->childCrop->contains($childCrop)) {
  812.             $this->childCrop->removeElement($childCrop);
  813.             // set the owning side to null (unless already changed)
  814.             if ($childCrop->getParentCrop() === $this) {
  815.                 $childCrop->setParentCrop(null);
  816.             }
  817.         }
  819.         return $this;
  820.     }
  822.     public function getParentCrop(): ?self
  823.     {
  824.         return $this->parentCrop;
  825.     }
  827.     public function setParentCrop(?self $parentCrop): self
  828.     {
  829.         $this->parentCrop = $parentCrop;
  831.         return $this;
  832.     }
  834.     public function getFertilizerType(): ?string
  835.     {
  836.         return $this->fertilizer_type;
  837.     }
  839.     public function setFertilizerType(?string $fertilizer_type): self
  840.     {
  841.         $this->fertilizer_type = $fertilizer_type;
  843.         return $this;
  844.     }
  846.     public function getPrecultivationDuration()
  847.     {
  848.         return $this->precultivation_duration;
  849.     }
  851.     public function setPrecultivationDuration($precultivation_duration): self
  852.     {
  853.         $this->precultivation_duration = $precultivation_duration;
  855.         return $this;
  856.     }
  858.     public function getPrecultivationSeason()
  859.     {
  860.         return $this->precultivation_season;
  861.     }
  863.     public function setPrecultivationSeason($precultivation_season): self
  864.     {
  865.         $this->precultivation_season = $precultivation_season;
  867.         return $this;
  868.     }
  870.     public function getShortDescription(bool $skipTranslation = false): ?string
  871.     {
  872.         if ($skipTranslation || $this->getCurrentLocale() === $this->getDefaultLocale()) {
  873.             return $this->short_description;
  874.         }
  875.         $translated = $this->translate()->getShortDescription();
  876.         return !empty($translated) ? $translated : $this->short_description;
  877.     }
  879.     public function setShortDescription(?string $short_description): self
  880.     {
  881.         $this->short_description = $short_description;
  883.         return $this;
  884.     }
  886.     public function getHasPrecultivation(): ?bool
  887.     {
  888.         return $this->has_precultivation;
  889.     }
  891.     public function setHasPrecultivation(?bool $has_precultivation): self
  892.     {
  893.         $this->has_precultivation = $has_precultivation;
  895.         return $this;
  896.     }
  898.     public function getF1Hybrid(): ?bool
  899.     {
  900.         return $this->f1_hybrid;
  901.     }
  903.     public function setF1Hybrid(?bool $f1_hybrid): self
  904.     {
  905.         $this->f1_hybrid = $f1_hybrid;
  907.         return $this;
  908.     }
  910.     public function getUserCropSettings()
  911.     {
  912.         return $this->user_crop_settings;
  913.     }
  915.     public function setUserCropSettings($user_crop_settings): self
  916.     {
  917.         $this->user_crop_settings = $user_crop_settings;
  919.         return $this;
  920.     }
  922.     public function getUser(): ?User
  923.     {
  924.         return $this->user;
  925.     }
  927.     public function setUser(?User $user): self
  928.     {
  929.         $this->user = $user;
  931.         return $this;
  932.     }
  934.     /**
  935.      * @return Collection|CropSynonym[]
  936.      */
  937.     public function getCropSynonym(): Collection
  938.     {
  939.         return $this->cropSynonym;
  940.     }
  942.     public function addCropSynonym(CropSynonym $cropSynonym): self
  943.     {
  944.         if (!$this->cropSynonym->contains($cropSynonym)) {
  945.             $this->cropSynonym[] = $cropSynonym;
  946.             $cropSynonym->setCrop($this);
  947.         }
  949.         return $this;
  950.     }
  952.     public function removeCropSynonym(CropSynonym $cropSynonym): self
  953.     {
  954.         if ($this->cropSynonym->contains($cropSynonym)) {
  955.             $this->cropSynonym->removeElement($cropSynonym);
  956.             // set the owning side to null (unless already changed)
  957.             if ($cropSynonym->getCrop() === $this) {
  958.                 $cropSynonym->setCrop(null);
  959.             }
  960.         }
  962.         return $this;
  963.     }
  965.     public function getGroundType(): ?string
  966.     {
  967.         return $this->ground_type;
  968.     }
  970.     public function setGroundType(?string $ground_type): self
  971.     {
  972.         $this->ground_type = $ground_type;
  974.         return $this;
  975.     }
  977.     public function getColdResistant(): ?bool
  978.     {
  979.         return $this->cold_resistant;
  980.     }
  982.     public function setColdResistant(?bool $cold_resistant): self
  983.     {
  984.         $this->cold_resistant = $cold_resistant;
  986.         return $this;
  987.     }
  989.     public function getIsShared(): ?bool
  990.     {
  991.         return $this->is_shared;
  992.     }
  994.     public function setIsShared(?bool $is_shared): self
  995.     {
  996.         $this->is_shared = $is_shared;
  998.         return $this;
  999.     }
  1001.     public function getDateUpdated(): ?\DateTimeInterface
  1002.     {
  1003.         return $this->date_updated;
  1004.     }
  1006.     public function setDateUpdated(?\DateTimeInterface $date_updated): self
  1007.     {
  1008.         $this->date_updated = $date_updated;
  1010.         return $this;
  1011.     }
  1013.     public function getSeedingDepth(): ?array
  1014.     {
  1015.         return $this->seeding_depth;
  1016.     }
  1018.     public function setSeedingDepth(?array $seeding_depth): self
  1019.     {
  1020.         $this->seeding_depth = $seeding_depth;
  1022.         return $this;
  1023.     }
  1025.     public function getSeedingDistance(): ?array
  1026.     {
  1027.         return $this->seeding_distance;
  1028.     }
  1030.     public function setSeedingDistance(?array $seeding_distance): self
  1031.     {
  1032.         $this->seeding_distance = $seeding_distance;
  1034.         return $this;
  1035.     }
  1037.     public function getRowDistance(): ?array
  1038.     {
  1039.         return $this->row_distance;
  1040.     }
  1042.     public function setRowDistance(?array $row_distance): self
  1043.     {
  1044.         $this->row_distance = $row_distance;
  1046.         return $this;
  1047.     }
  1049.     public function getIsApproved(): ?bool
  1050.     {
  1051.         return $this->is_approved;
  1052.     }
  1054.     public function setIsApproved(?bool $is_approved): self
  1055.     {
  1056.         $this->is_approved = $is_approved;
  1058.         return $this;
  1059.     }
  1061.     /**
  1062.      * @return Collection|CropEdit[]
  1063.      */
  1064.     public function getCropEdit(): Collection
  1065.     {
  1066.         return $this->cropEdit;
  1067.     }
  1069.     public function addCropEdit(CropEdit $cropEdit): self
  1070.     {
  1071.         if (!$this->cropEdit->contains($cropEdit)) {
  1072.             $this->cropEdit[] = $cropEdit;
  1073.             $cropEdit->setCrop($this);
  1074.         }
  1076.         return $this;
  1077.     }
  1079.     public function removeCropEdit(CropEdit $cropEdit): self
  1080.     {
  1081.         if ($this->cropEdit->removeElement($cropEdit)) {
  1082.             // set the owning side to null (unless already changed)
  1083.             if ($cropEdit->getCrop() === $this) {
  1084.                 $cropEdit->setCrop(null);
  1085.             }
  1086.         }
  1088.         return $this;
  1089.     }
  1091.     /**
  1092.      * @return Collection|CropRating[]
  1093.      */
  1094.     public function getCropRating(): Collection
  1095.     {
  1096.         return $this->cropRating;
  1097.     }
  1099.     public function addCropRating(CropRating $cropRating): self
  1100.     {
  1101.         if (!$this->cropRating->contains($cropRating)) {
  1102.             $this->cropRating[] = $cropRating;
  1103.             $cropRating->setCrop($this);
  1104.         }
  1106.         return $this;
  1107.     }
  1109.     public function removeCropRating(CropRating $cropRating): self
  1110.     {
  1111.         if ($this->cropRating->removeElement($cropRating)) {
  1112.             // set the owning side to null (unless already changed)
  1113.             if ($cropRating->getCrop() === $this) {
  1114.                 $cropRating->setCrop(null);
  1115.             }
  1116.         }
  1118.         return $this;
  1119.     }
  1121.     public function getPlantfamily(): ?Plantfamily
  1122.     {
  1123.         return $this->plantfamily;
  1124.     }
  1126.     public function setPlantfamily(?Plantfamily $plantfamily): self
  1127.     {
  1128.         $this->plantfamily = $plantfamily;
  1130.         return $this;
  1131.     }
  1133.     public function getPopularity(): ?int
  1134.     {
  1135.         return $this->popularity;
  1136.     }
  1138.     public function setPopularity(?int $popularity): self
  1139.     {
  1140.         $this->popularity = $popularity;
  1142.         return $this;
  1143.     }
  1145.     public function getSeasons(): ?array
  1146.     {
  1147.         return $this->seasons;
  1148.     }
  1150.     public function setSeasons(?array $seasons): self
  1151.     {
  1152.         $this->seasons = $seasons;
  1154.         return $this;
  1155.     }
  1157.     public function calculateSeasons(): void
  1158.     {
  1159.         // season = pre / main / post
  1160.         // preseason plants MUST start and MUST end in preseason
  1161.         // mainseason plants CAN start in preseason and CAN end in postseason
  1162.         // postseason plants MUST start in postseason and CAN end in preseason in the following year
  1163.         // ---pre---- | ---main--- | ---post---
  1164.         // --xxxx---- | ---------- | ---------- (pre)
  1165.         // --xxxxxxxx | xxxxx----- | ---------- (main)
  1166.         // --------xx | xxxxxxxxxx | xx-------- (main)
  1167.         // ---------- | --xxxxxxx- | ---------- (main)
  1168.         // ---------- | --xxxxxxxx | x--------- (main)
  1169.         // ---------- | ---------- | -xxx------ (post)
  1170.         // xx-------- | ---------- | -------xxx (post)
  1172.         $coldResistant = $this->cold_resistant;
  1173.         $weekAfterIceSaints = 20;
  1174.         $weekPostSeasonStart = 38;
  1176.         if (!isset($this->precultivation_season['start'], $this->precultivation_season['end']) && !isset($this->germination_season['start'], $this->germination_season['end'])) {
  1177.             return;
  1178.         }
  1180.         $startWeekIsPrecultivationStart = $this->has_precultivation && isset($this->precultivation_season['start']);
  1181.         $earliestStartWeek = $startWeekIsPrecultivationStart ? $this->precultivation_season['start'] : $this->germination_season['start'];
  1182.         $latestStartWeek = $startWeekIsPrecultivationStart ? $this->precultivation_season['end'] : $this->germination_season['end'];
  1183.         $growthDurationInWeeks = $this->getGrowthDurationInWeeks(true);
  1185.         if ($earliestStartWeek > $latestStartWeek) {
  1186.             $earliestStartWeek = 0;
  1187.             $latestStartWeek = 52;
  1188.         }
  1190.         $seasons = [];
  1191.         if ($coldResistant === true && $earliestStartWeek + $growthDurationInWeeks <= $weekAfterIceSaints) {
  1192.             // fits in pre season
  1193.             $seasons[] = 'pre';
  1194.         }
  1195.         if ($latestStartWeek + $growthDurationInWeeks >= $weekAfterIceSaints && $earliestStartWeek < $weekPostSeasonStart) {
  1196.             // fits in main season
  1197.             $seasons[] = 'main';
  1198.         }
  1199.         if ($latestStartWeek >= $weekPostSeasonStart) {
  1200.             // fits in post season
  1201.             $seasons[] = 'post';
  1202.         }
  1204.         $this->setSeasons($seasons);
  1205.     }
  1207.     private function getGrowthDurationInWeeks($withoutHarvest = false)
  1208.     {
  1209.         $germinationDuration = $this->parseDuration($this->germination_duration);
  1210.         $precultivationDuration = $this->parseDuration($this->precultivation_duration);
  1211.         $growthDuration = $this->parseDuration($this->growth_duration);
  1213.         $harvestDuration = 0;
  1214.         if (!$withoutHarvest) {
  1215.             if ($this->harvest_duration === "continuous") {
  1216.                 $harvestDuration = 8;
  1217.             } else {
  1218.                 $harvestDuration =
  1219.                     (is_numeric($this->harvest_duration)
  1220.                         ? (float)$this->harvest_duration
  1221.                         : 2);
  1222.             }
  1223.         }
  1225.         return ceil(
  1226.             $germinationDuration +
  1227.             $precultivationDuration +
  1228.             $growthDuration +
  1229.             $harvestDuration
  1230.         );
  1231.     }
  1233.     private function parseDuration($duration): float
  1234.     {
  1235.         $durationNumber = 0;
  1237.         if (isset($duration['default'])) {
  1238.             $defaultValue = $duration['default'];
  1239.             $durationNumber = (float)str_replace(',', '.', $defaultValue);
  1240.         }
  1241.         return $durationNumber;
  1242.     }
  1244.     /**
  1245.      * @return Collection<int, CropProperty>
  1246.      */
  1247.     public function getCropProperties(): Collection
  1248.     {
  1249.         return $this->cropProperties;
  1250.     }
  1252.     public function addCropProperty(CropProperty $cropProperty): self
  1253.     {
  1254.         if (!$this->cropProperties->contains($cropProperty)) {
  1255.             $this->cropProperties[] = $cropProperty;
  1256.             $cropProperty->setCrop($this);
  1257.         }
  1259.         return $this;
  1260.     }
  1262.     public function removeCropProperty(CropProperty $cropProperty): self
  1263.     {
  1264.         if ($this->cropProperties->removeElement($cropProperty)) {
  1265.             // set the owning side to null (unless already changed)
  1266.             if ($cropProperty->getCrop() === $this) {
  1267.                 $cropProperty->setCrop(null);
  1268.             }
  1269.         }
  1271.         return $this;
  1272.     }
  1274.     public function getDynamicLink(): ?string
  1275.     {
  1276.         return $this->dynamic_link;
  1277.     }
  1279.     public function setDynamicLink(?string $dynamic_link): self
  1280.     {
  1281.         $this->dynamic_link = $dynamic_link;
  1283.         return $this;
  1284.     }
  1286.     public function getCultivationBreak(): ?float
  1287.     {
  1288.         return $this->cultivation_break;
  1289.     }
  1291.     public function setCultivationBreak(?float $cultivation_break): static
  1292.     {
  1293.         $this->cultivation_break = $cultivation_break;
  1295.         return $this;
  1296.     }
  1298.     public function getGerminationType(): ?string
  1299.     {
  1300.         return $this->germination_type;
  1301.     }
  1303.     public function setGerminationType(?string $germination_type): static
  1304.     {
  1305.         $this->germination_type = $germination_type;
  1307.         return $this;
  1308.     }
  1310.     public function getGerminationTemperature(): ?string
  1311.     {
  1312.         return $this->germination_temperature;
  1313.     }
  1315.     public function setGerminationTemperature(?string $germination_temperature): static
  1316.     {
  1317.         $this->germination_temperature = $germination_temperature;
  1319.         return $this;
  1320.     }
  1322.     public function getShopCategoryUrl(): ?string
  1323.     {
  1324.         return $this->shop_category_url;
  1325.     }
  1327.     public function setShopCategoryUrl(?string $shop_category_url): static
  1328.     {
  1329.         $this->shop_category_url = $shop_category_url;
  1331.         return $this;
  1332.     }
  1334.     public function getGrowthHabit(): ?string
  1335.     {
  1336.         return $this->growth_habit;
  1337.     }
  1339.     public function setGrowthHabit(?string $growth_habit): static
  1340.     {
  1341.         $this->growth_habit = $growth_habit;
  1343.         return $this;
  1344.     }
  1346.     /**
  1347.      * @return Collection<int, ShoparticleBlockentry>
  1348.      */
  1349.     public function getShoparticleBlockentries(): Collection
  1350.     {
  1351.         return $this->shoparticleBlockentries;
  1352.     }
  1354.     public function addShoparticleBlockentry(ShoparticleBlockentry $shoparticleBlockentry): static
  1355.     {
  1356.         if (!$this->shoparticleBlockentries->contains($shoparticleBlockentry)) {
  1357.             $this->shoparticleBlockentries->add($shoparticleBlockentry);
  1358.             $shoparticleBlockentry->setCrop($this);
  1359.         }
  1361.         return $this;
  1362.     }
  1364.     public function removeShoparticleBlockentry(ShoparticleBlockentry $shoparticleBlockentry): static
  1365.     {
  1366.         if ($this->shoparticleBlockentries->removeElement($shoparticleBlockentry)) {
  1367.             // set the owning side to null (unless already changed)
  1368.             if ($shoparticleBlockentry->getCrop() === $this) {
  1369.                 $shoparticleBlockentry->setCrop(null);
  1370.             }
  1371.         }
  1373.         return $this;
  1374.     }
  1376.     public function getIsGreenManure(): ?bool
  1377.     {
  1378.         return $this->isGreenManure;
  1379.     }
  1381.     public function setIsGreenManure(?bool $isGreenManure): static
  1382.     {
  1383.         $this->isGreenManure = $isGreenManure;
  1385.         return $this;
  1386.     }
  1388.     /**
  1389.      * @return Collection<int, CropImage>
  1390.      */
  1391.     public function getCropImages(): Collection
  1392.     {
  1393.         return $this->cropImages;
  1394.     }
  1396.     public function addCropImage(CropImage $cropImage): static
  1397.     {
  1398.         if (!$this->cropImages->contains($cropImage)) {
  1399.             $this->cropImages->add($cropImage);
  1400.             $cropImage->setCrop($this);
  1401.         }
  1403.         return $this;
  1404.     }
  1406.     public function removeCropImage(CropImage $cropImage): static
  1407.     {
  1408.         if ($this->cropImages->removeElement($cropImage)) {
  1409.             // set the owning side to null (unless already changed)
  1410.             if ($cropImage->getCrop() === $this) {
  1411.                 $cropImage->setCrop(null);
  1412.             }
  1413.         }
  1415.         return $this;
  1416.     }
  1418.     public function getClimatezone(): ?Climatezone
  1419.     {
  1420.         return $this->climatezone;
  1421.     }
  1423.     public function setClimatezone(?Climatezone $climatezone): static
  1424.     {
  1425.         $this->climatezone = $climatezone;
  1427.         return $this;
  1428.     }
  1430.     public function getGtinBarcode(): ?string
  1431.     {
  1432.         return $this->gtin_barcode;
  1433.     }
  1435.     public function setGtinBarcode(?string $gtin_barcode): static
  1436.     {
  1437.         $this->gtin_barcode = $gtin_barcode;
  1439.         return $this;
  1440.     }
  1442. }