src/Entity/Field.php line 21

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Constant\ObjectTypeConstant;
  6. use App\Constant\ReportConstant;
  7. use App\Entity\Report\Report;
  8. use App\Entity\Report\TaskList;
  9. use App\Entity\Task\Objective;
  10. use App\Entity\Techcard\Techcard;
  11. use App\Model\CacheRemover;
  12. use App\Repository\FieldRepository;
  13. use Doctrine\Common\Collections\ArrayCollection;
  14. use Doctrine\Common\Collections\Collection;
  15. use Doctrine\ORM\Mapping as ORM;
  16. use function Clue\StreamFilter\fun;
  18. /**
  19.  * @ORM\Entity(repositoryClass=FieldRepository::class)
  20.  */
  21. class Field
  22. {
  23.     /**
  24.      * @ORM\Id
  25.      * @ORM\GeneratedValue
  26.      * @ORM\Column(type="integer")
  27.      */
  28.     private $id;
  30.     /**
  31.      * @ORM\Column(type="string", length=255)
  32.      */
  33.     private $name;
  35.     /**
  36.      * @ORM\ManyToOne(targetEntity=Season::class)
  37.      */
  38.     private $season;
  40.     /**
  41.      * @ORM\ManyToOne(targetEntity=Culture::class)
  42.      */
  43.     private $culture;
  45.     /**
  46.      * @ORM\Column(type="string", length=255, nullable=true)
  47.      */
  48.     private $sort;
  50.     /**
  51.      * @ORM\ManyToOne(targetEntity=Reproduct::class)
  52.      */
  53.     private $reproduct;
  55.     /**
  56.      * @ORM\Column(type="json", nullable=true)
  57.      */
  58.     private $params = [];
  60.     /**
  61.      * @ORM\Column(type="json")
  62.      */
  63.     private $coordinates = [];
  65.     /**
  66.      * @ORM\Column(type="string", length=255, nullable=true)
  67.      */
  68.     private $size;
  70.     /**
  71.      * @ORM\ManyToOne(targetEntity=Client::class, inversedBy="fields")
  72.      */
  73.     private $client;
  75.     /**
  76.      * @ORM\ManyToOne(targetEntity=Techcard::class, inversedBy="fields")
  77.      */
  78.     private $techcard;
  80.     /**
  81.      * @ORM\Column(type="string", length=255, nullable=true, options={"default":"#000000"})
  82.      */
  83.     private $color;
  85.     /**
  86.      * @ORM\OneToMany(targetEntity=TaskList::class, mappedBy="field")
  87.      */
  88.     private $taskLists;
  90.     /**
  91.      * @ORM\OneToMany(targetEntity=Report::class, mappedBy="field")
  92.      */
  93.     private $reports;
  95.     /**
  96.      * @ORM\ManyToMany(targetEntity=Employee::class, inversedBy="fields")
  97.      */
  98.     private $employees;
  100.     /**
  101.      * @ORM\Column(type="boolean", nullable=true, options={"default":false})
  102.      */
  103.     private $removed;
  105.     /**
  106.      * @ORM\ManyToMany(targetEntity=Techcard::class, inversedBy="fieldsAll")
  107.      */
  108.     private $techcards;
  110.     /**
  111.      * @ORM\OneToMany(targetEntity=Objective::class, mappedBy="field")
  112.      */
  113.     private $objectives;
  115.     /**
  116.      * @ORM\Column(type="string", length=255, nullable=true, options={"default":"field"})
  117.      */
  118.     private $objectType;
  120.     /**
  121.      * @ORM\ManyToOne(targetEntity=ObjectGroup::class, inversedBy="fields")
  122.      */
  123.     private $objectGroup;
  125.     /**
  126.      * @ORM\ManyToOne(targetEntity=Location::class, inversedBy="fields")
  127.      */
  128.     private $location;
  130.     /**
  131.      * @ORM\Column(type="string", length=255, nullable=true)
  132.      */
  133.     private $objectStatus;
  135.     /**
  136.      * @ORM\Column(type="string", length=255, nullable=true)
  137.      */
  138.     private $hash;
  139.     /**
  140.      * @ORM\Column(type="boolean", nullable=true, options={"default":true})
  141.      */
  142.     private $defaultCultureColor;
  144.     /**
  145.      * @ORM\OneToMany(targetEntity=FieldParams::class, mappedBy="field")
  146.      */
  147.     private $fieldParams;
  149.     /**
  150.      * @ORM\OneToMany(targetEntity=Recommendation::class, mappedBy="field")
  151.      */
  152.     private $recommendations;
  154.     /**
  155.      * @ORM\Column(type="integer", nullable=true)
  156.      */
  157.     private $cropWiseFieldId;
  159.     /**
  160.      * @ORM\Column(type="boolean", nullable=true, options={"default":false})
  161.      */
  162.     private $archive;
  164.     public function __construct()
  165.     {
  166.         if ($this->id == null) {
  167.             $this->removed = false;
  168.             $this->color = '#000000';
  169.             $this->objectType = ObjectTypeConstant::OBJECT_TYPE_FIELD;
  170.             $this->defaultCultureColor = 1;
  171.             $this->archive = 0;
  172.         }
  173.         $this->taskLists = new ArrayCollection();
  174.         $this->employees = new ArrayCollection();
  175.         $this->reports = new ArrayCollection();
  176.         $this->techcards = new ArrayCollection();
  177.         $this->objectives = new ArrayCollection();
  178.         $this->fieldParams = new ArrayCollection();
  179.         $this->setHash();
  180.         $this->recommendations = new ArrayCollection();
  182.     }
  184.     public function getId(): ?int
  185.     {
  186.         return $this->id;
  187.     }
  189.     public function getName(): ?string
  190.     {
  191.         return $this->name;
  192.     }
  194.     public function setName(string $name): self
  195.     {
  196.         $this->name = $name;
  198.         return $this;
  199.     }
  201.     public function getSeason(): ?Season
  202.     {
  203.         return $this->season;
  204.     }
  206.     public function setSeason(?Season $season): self
  207.     {
  208.         $this->season = $season;
  210.         return $this;
  211.     }
  213.     public function getCulture(): ?Culture
  214.     {
  215.         return $this->culture;
  216.     }
  218.     public function setCulture(?Culture $culture): self
  219.     {
  220.         $this->culture = $culture;
  222.         return $this;
  223.     }
  225.     public function getSort(): ?string
  226.     {
  227.         return $this->sort;
  228.     }
  230.     public function setSort(?string $sort): self
  231.     {
  232.         $this->sort = $sort;
  234.         return $this;
  235.     }
  237.     public function getReproduct(): ?Reproduct
  238.     {
  239.         return $this->reproduct;
  240.     }
  242.     public function setReproduct(?Reproduct $reproduct): self
  243.     {
  244.         $this->reproduct = $reproduct;
  246.         return $this;
  247.     }
  249.     public function getParams(): ?array
  250.     {
  251.         return $this->params;
  252.     }
  254.     public function setParams(?array $params): self
  255.     {
  256.         $this->params = $params;
  258.         return $this;
  259.     }
  261.     public function getCoordinates(): ?array
  262.     {
  263.         $coordinate = [];
  265.         if (!empty($this->coordinates)) {
  266.             foreach ($this->coordinates as $item) {
  267.                 if (isset($item['lat'])) {
  268.                     $coordinate[] = [
  269.                         'lat' => (float)$item['lat'],
  270.                         'lng' => (float)$item['lng'],
  271.                     ];
  272.                 }
  273.             }
  274.         }
  275.         return $coordinate;
  276.     }
  278.     public function setCoordinates($coordinates): self
  279.     {
  280.         if (is_string($coordinates)) {
  281.             $this->coordinates = json_decode($coordinates, 1);
  282.         } else {
  283.             $this->coordinates = $coordinates;
  284.         }
  286.         return $this;
  287.     }
  289.     public function getSizeNumber(): ?int
  290.     {
  291.         return (float)$this->size;
  292.     }
  294.     public function getSize(): ?string
  295.     {
  296.         return number_format((float)$this->size, 1, '.', ' ');
  297.     }
  299.     public function setSize(?string $size): self
  300.     {
  301.         $this->size = $size;
  303.         return $this;
  304.     }
  306.     public function getClient(): ?Client
  307.     {
  308.         return $this->client;
  309.     }
  311.     public function setClient(?Client $client): self
  312.     {
  313.         $this->client = $client;
  315.         return $this;
  316.     }
  318.     public function getTechcard(): ?Techcard
  319.     {
  320.         return $this->techcard;
  321.     }
  323.     public function setTechcard(?Techcard $techcard): self
  324.     {
  325.         $this->techcard = $techcard;
  327.         return $this;
  328.     }
  330.     public function __toString()
  331.     {
  332.         return $this->name;
  333.     }
  335.     public function getColor(): ?string
  336.     {
  337.         if ($this->isDefaultCultureColor()) {
  338.             if (!empty($this->getCulture())) {
  339.                 $color = $this->getCulture()->getColor();
  340.                 if (!is_null($color)) {
  341.                     return $color;
  342.                 } else {
  343.                    return '#000000';
  344.                 }
  345.             }
  346.         }
  347.         return $this->color;
  348.     }
  350.     public function setColor(?string $color): self
  351.     {
  352.         $this->color = $color;
  354.         return $this;
  355.     }
  357.     public function getOperations()
  358.     {
  359.         $result = [];
  360.         $techcard = $this->getTechcard();
  361.         if (!empty($techcard)) {
  362.             $operations = $techcard->getOperations();
  363.             if (!empty($operations)) {
  364.                 $result['techcard']['name'] = $techcard->getName();
  365.                 $result['techcard']['id'] = $techcard->getId();
  366.                 $result['techcard']['list'] = [];
  367.                 foreach ($operations as $operation) {
  368.                     $result['techcard']['list'][] = [
  369.                         'name' => $operation->getName(),
  370.                         'id' => $operation->getId()
  371.                     ];
  372.                 }
  374.             }
  375.         }
  376.         return $result;
  377.     }
  379.     public function getEnableOperations()
  380.     {
  381.         $result = [];
  382.         $techcard = $this->getTechcard();
  383.         if (!empty($techcard)) {
  384.             $operations = $techcard->getOperations();
  385.             if (!empty($operations)) {
  386.                 $result['techcard']['name'] = $techcard->getName();
  387.                 $result['techcard']['id'] = $techcard->getId();
  388.                 $result['techcard']['list'] = [];
  389.                 foreach ($operations as $operation) {
  390.                     if (!$operation->isRemoved()) {
  391.                         $result['techcard']['list'][] = [
  392.                             'name' => $operation->getName(),
  393.                             'id' => $operation->getId()
  394.                         ];
  395.                     }
  396.                 }
  398.             }
  399.         }
  400.         return $result;
  401.     }
  403.     public function getTodayWorks()
  404.     {
  405.         $result = [
  406.             ReportConstant::AGRO_OPERATION_TYPE => 0,
  407.             ReportConstant::MONITORING_TYPE => 0
  408.         ];
  409.         foreach ($this->getTaskLists() as $taskList) {
  410.             if (!empty($taskList->getSeason()) && $taskList->getSeason()->getName() == date("Y")) {
  411.                 foreach ($taskList->getTasks() as $task) {
  412.                     $dateFrom = $task->getDateFrom();
  413.                     $dateTo = $task->getDateTo();
  414.                     $dateNow = new \DateTime(date("Y-m-d"));
  415.                     if (
  416.                         $dateNow == $dateFrom ||
  417.                         $dateNow == $dateTo ||
  418.                         ($dateFrom < $dateNow && $dateNow <= $dateTo)
  419.                     ) {
  420.                         $key = ReportConstant::AGRO_OPERATION_TYPE;
  421.                         if (!empty($task->getMonitoring())) {
  422.                             $key = ReportConstant::MONITORING_TYPE;
  423.                         }
  424.                         if (isset($result[$key])) {
  425.                             $result[$key]++;
  426.                         } else {
  427.                             $result[$key] = 1;
  428.                         }
  429.                     }
  430.                 }
  431.             }
  432.         }
  433.         return $result;
  434.     }
  436.     public function getMonitorings()
  437.     {
  438.         $result = [];
  439.         $techcard = $this->getTechcard();
  440.         if (!empty($techcard)) {
  441.             $monitorings = $techcard->getMonitorings();
  442.             if (!empty($monitorings)) {
  443.                 $result['techcard']['name'] = $techcard->getName();
  444.                 $result['techcard']['id'] = $techcard->getId();
  445.                 $result['techcard']['list'] = [];
  446.                 foreach ($monitorings as $monitoring) {
  447.                     $result['techcard']['list'][] = [
  448.                         'name' => $monitoring->getName(),
  449.                         'id' => $monitoring->getId()
  450.                     ];
  451.                 }
  453.             }
  454.         }
  455.         return $result;
  456.     }
  458.     public function getEnableMonitorings()
  459.     {
  460.         $result = [];
  461.         $techcard = $this->getTechcard();
  462.         if (!empty($techcard)) {
  463.             $monitorings = $techcard->getMonitorings();
  464.             if (!empty($monitorings)) {
  465.                 $result['techcard']['name'] = $techcard->getName();
  466.                 $result['techcard']['id'] = $techcard->getId();
  467.                 $result['techcard']['list'] = [];
  468.                 foreach ($monitorings as $monitoring) {
  469.                     if (!$monitoring->isRemoved()) {
  470.                         $result['techcard']['list'][] = [
  471.                             'name' => $monitoring->getName(),
  472.                             'id' => $monitoring->getId()
  473.                         ];
  474.                     }
  475.                 }
  477.             }
  478.         }
  479.         return $result;
  480.     }
  482.     /**
  483.      * @return Collection|TaskList[]
  484.      */
  485.     public function getTaskLists(): Collection
  486.     {
  487.         return $this->taskLists;
  488.     }
  490.     public function addTaskList(TaskList $taskList): self
  491.     {
  492.         if (!$this->taskLists->contains($taskList)) {
  493.             $this->taskLists[] = $taskList;
  494.             $taskList->setField($this);
  495.         }
  497.         return $this;
  498.     }
  500.     public function removeTaskList(TaskList $taskList): self
  501.     {
  502.         if ($this->taskLists->removeElement($taskList)) {
  503.             // set the owning side to null (unless already changed)
  504.             if ($taskList->getField() === $this) {
  505.                 $taskList->setField(null);
  506.             }
  507.         }
  509.         return $this;
  510.     }
  512.     public function removeAllTaskList(): self
  513.     {
  514.         foreach ($this->getTaskLists() as $taskList) {
  515.             $this->removeTaskList($taskList);
  516.         }
  518.         return $this;
  519.     }
  521.     public function getTaskListBySeason(Season $season)
  522.     {
  523.         foreach ($this->taskLists as $taskList) {
  524.             if ($taskList->getSeason()->getId() == $season->getId()) {
  525.                 return $taskList;
  526.             }
  527.         }
  528.         return null;
  529.     }
  531.     /**
  532.      * @return Collection|Employee[]
  533.      */
  534.     public function getEmployees(): Collection
  535.     {
  536.         return $this->employees;
  537.     }
  539.     public function addEmployee(Employee $employee): self
  540.     {
  541.         if (!$this->employees->contains($employee)) {
  542.             $this->employees[] = $employee;
  543.         }
  545.         return $this;
  546.     }
  548.     public function removeEmployee(Employee $employee): self
  549.     {
  550.         $this->employees->removeElement($employee);
  552.         return $this;
  553.     }
  555.     /**
  556.      * @return Collection|Report[]
  557.      */
  558.     public function getReports(): Collection
  559.     {
  560.         return $this->reports;
  561.     }
  563.     /**
  564.      * @return Collection|Report[]
  565.      */
  566.     public function getObjectiveReports(): Collection
  567.     {
  568.         return $this->reports->filter(function ($field) {
  569.             if (!empty($field->getObjective())) {
  570.                 return $field;
  571.             }
  572.             return null;
  573.         });
  574.     }
  576.     public function addReport(Report $report): self
  577.     {
  578.         if (!$this->reports->contains($report)) {
  579.             $this->reports[] = $report;
  580.             $report->setField($this);
  581.         }
  583.         return $this;
  584.     }
  586.     public function removeReport(Report $report): self
  587.     {
  588.         if ($this->reports->removeElement($report)) {
  589.             // set the owning side to null (unless already changed)
  590.             if ($report->getField() === $this) {
  591.                 $report->setField(null);
  592.             }
  593.         }
  595.         return $this;
  596.     }
  598.     public function isRemoved(): ?bool
  599.     {
  600.         return $this->removed;
  601.     }
  603.     public function setRemoved(?bool $removed): self
  604.     {
  605.         $this->removed = $removed;
  607.         return $this;
  608.     }
  610.     /**
  611.      * @return Collection|Techcard[]
  612.      */
  613.     public function getTechcards(): Collection
  614.     {
  615.         return $this->techcards;
  616.     }
  618.     public function addTechcard(Techcard $techcard): self
  619.     {
  620.         if (!$this->techcards->contains($techcard)) {
  621.             /** @var Techcard $techcardInList */
  622.             foreach ($this->techcards as $techcardInList) {
  623.                 if (!empty($techcard->getSeason()) && !empty($techcardInList->getSeason()) && $techcard->getSeason()->getId() == $techcardInList->getSeason()->getId() && $techcard->getObjectType() == ObjectTypeConstant::OBJECT_TYPE_FIELD) {
  624.                     $techcardInList->removeField($this);
  625.                     $this->removeTechcard($techcardInList);
  626.                 }
  627.             }
  628.             $this->techcards[] = $techcard;
  629.             $this->techcard = $techcard;
  630.             $this->season = $techcard->getSeason();
  631.             $this->culture = $techcard->getCulture();
  632.             $techcard->addField($this);
  634.         }
  636.         return $this;
  637.     }
  640.     public function removeTechcard(Techcard $techcard): self
  641.     {
  642.         $this->techcards->removeElement($techcard);
  644.         return $this;
  645.     }
  647.     /**
  648.      * @return Collection<int, Objective>
  649.      */
  650.     public function getObjectives(): Collection
  651.     {
  652.         return $this->objectives;
  653.     }
  655.     public function addObjective(Objective $objective): self
  656.     {
  657.         if (!$this->objectives->contains($objective)) {
  658.             $this->objectives[] = $objective;
  659.             $objective->setField($this);
  660.         }
  662.         return $this;
  663.     }
  665.     public function removeObjective(Objective $objective): self
  666.     {
  667.         if ($this->objectives->removeElement($objective)) {
  668.             // set the owning side to null (unless already changed)
  669.             if ($objective->getField() === $this) {
  670.                 $objective->setField(null);
  671.             }
  672.         }
  674.         return $this;
  675.     }
  677.     public function getObjectType(): ?string
  678.     {
  679.         return $this->objectType;
  680.     }
  682.     public function setObjectType(?string $objectType): self
  683.     {
  684.         $this->objectType = $objectType;
  686.         return $this;
  687.     }
  689.     public function getObjectGroup(): ?ObjectGroup
  690.     {
  691.         return $this->objectGroup;
  692.     }
  694.     public function setObjectGroup(?ObjectGroup $objectGroup): self
  695.     {
  696.         $this->objectGroup = $objectGroup;
  698.         return $this;
  699.     }
  701.     public function getLocation(): ?Location
  702.     {
  703.         return $this->location;
  704.     }
  706.     public function setLocation(?Location $location): self
  707.     {
  708.         $this->location = $location;
  710.         return $this;
  711.     }
  713.     public function getObjectStatus(): ?string
  714.     {
  715.         return $this->objectStatus;
  716.     }
  718.     public function setObjectStatus(string $objectStatus): self
  719.     {
  720.         $this->objectStatus = $objectStatus;
  722.         return $this;
  723.     }
  725.     public function getHash(): ?string
  726.     {
  727.         return $this->hash;
  728.     }
  730.     public function setHash(): self
  731.     {
  732.         $this->hash = md5(date('YmdHis') . microtime(true) . rand(0, 999999));
  734.         return $this;
  735.     }
  737.     public function removeFieldForAllEmployee()
  738.     {
  739.         $employees = $this->getEmployees();
  740.         if ($employees->count() > 0) {
  741.             $cacheRemover = new CacheRemover();
  743.             foreach ($employees as $employee) {
  744.                 $this->removeEmployee($employee);
  745.                 $cacheRemover->removeCache($employee);
  746.             }
  747.         }
  748.         return $this;
  749.     }
  751.     public function getCompanyGroupId()
  752.     {
  753.         if (!empty($this->getClient())
  754.             && !empty($this->getClient()->getCompany())
  755.             && !empty($this->getClient()->getCompany()->getCompanyGroup())
  756.         ) {
  757.             return $this->getClient()->getCompany()->getCompanyGroup()->getId();
  758.         }
  759.         return null;
  760.     }
  762.     /**
  763.      * @return mixed
  764.      */
  765.     public function isDefaultCultureColor()
  766.     {
  767.         return $this->defaultCultureColor;
  768.     }
  770.     /**
  771.      * @param mixed $defaultCultureColor
  772.      */
  773.     public function setDefaultCultureColor(bool $defaultCultureColor): void
  774.     {
  775.         $this->defaultCultureColor = $defaultCultureColor;
  776.     }
  778.     /**
  779.      * @return Collection<int, FieldParams>
  780.      */
  781.     public function getFieldParams(): Collection
  782.     {
  783.         return $this->fieldParams;
  784.     }
  786.     public function getFieldParam(string $key): FieldParams
  787.     {
  788.         $params = $this->fieldParams;
  789.         /** @var FieldParams $item */
  790.         foreach ($params as $item) {
  791.             if ($item->getParamKey() == $key) {
  792.                 return $item;
  793.             }
  794.         }
  795.         $newParam = new FieldParams();
  796.         $newParam->setField($this);
  797.         $newParam->setParamKey($key);
  798.         $this->addFieldParam($newParam);
  800.         return $newParam;
  801.     }
  803.     public function addFieldParam(FieldParams $fieldParam): self
  804.     {
  805.         if (!$this->fieldParams->contains($fieldParam)) {
  806.             $this->fieldParams[] = $fieldParam;
  807.             $fieldParam->setField($this);
  808.         }
  810.         return $this;
  811.     }
  813.     public function removeFieldParam(FieldParams $fieldParam): self
  814.     {
  815.         if ($this->fieldParams->removeElement($fieldParam)) {
  816.             // set the owning side to null (unless already changed)
  817.             if ($fieldParam->getField() === $this) {
  818.                 $fieldParam->setField(null);
  819.             }
  820.         }
  822.         return $this;
  823.     }
  825.     public function getFieldParamsToArray(): array
  826.     {
  827.         $response = [];
  828.         $params = $this->getFieldParams();
  829.         foreach ($params as $param) {
  830.             $response[$param->getParamKey()] = $param->getValue();
  831.         }
  832.         return $response;
  833.     }
  835.     public function checkCultureExists(int $cultureId): bool
  836.     {
  837.         $status = false;
  838.         if (!empty($this->getCulture()) && $this->getCulture()->getId() == $cultureId) {
  839.             return true;
  840.         }
  841.         foreach ($this->getTechcards() as $techcard) {
  842.             if (!empty($techcard->getCulture()) && $techcard->getCulture()->getId() == $cultureId) {
  843.                 return true;
  844.             }
  845.         }
  847.         return $status;
  848.     }
  850.     /**
  851.      * @return Collection<int, Recommendation>
  852.      */
  853.     public function getRecommendations(): Collection
  854.     {
  855.         return $this->recommendations;
  856.     }
  858.     public function addRecommendation(Recommendation $recommendation): self
  859.     {
  860.         if (!$this->recommendations->contains($recommendation)) {
  861.             $this->recommendations[] = $recommendation;
  862.             $recommendation->setField($this);
  863.         }
  865.         return $this;
  866.     }
  868.     public function removeRecommendation(Recommendation $recommendation): self
  869.     {
  870.         if ($this->recommendations->removeElement($recommendation)) {
  871.             // set the owning side to null (unless already changed)
  872.             if ($recommendation->getField() === $this) {
  873.                 $recommendation->setField(null);
  874.             }
  875.         }
  877.         return $this;
  878.     }
  880.     public function getCropWiseFieldId(): ?int
  881.     {
  882.         return $this->cropWiseFieldId;
  883.     }
  885.     public function setCropWiseFieldId(?int $cropWiseFieldId): self
  886.     {
  887.         $this->cropWiseFieldId = $cropWiseFieldId;
  889.         return $this;
  890.     }
  892.     public function isArchive(): ?bool
  893.     {
  894.         return $this->archive;
  895.     }
  897.     public function setArchive(?bool $archive): self
  898.     {
  899.         $this->archive = $archive;
  901.         return $this;
  902.     }
  903. }