src/Entity/Task/MonitoringObjective.php line 22

Open in your IDE?
  1. <?php
  3. namespace App\Entity\Task;
  5. use App\Constant\StatusConstant;
  6. use App\Entity\Agro\Operation;
  7. use App\Entity\Client;
  8. use App\Entity\Culture;
  9. use App\Entity\Employee;
  10. use App\Entity\Season;
  11. use App\Entity\Techcard\Techcard;
  12. use App\Entity\User;
  13. use App\Model\CacheRemover;
  14. use App\Repository\Task\MonitoringObjectiveRepository;
  15. use Doctrine\Common\Collections\ArrayCollection;
  16. use Doctrine\Common\Collections\Collection;
  17. use Doctrine\ORM\Mapping as ORM;
  19. /**
  20.  * @ORM\Entity(repositoryClass=MonitoringObjectiveRepository::class)
  21.  */
  22. class MonitoringObjective
  23. {
  24.     /**
  25.      * @ORM\Id
  26.      * @ORM\GeneratedValue
  27.      * @ORM\Column(type="integer")
  28.      */
  29.     private $id;
  31.     /**
  32.      * @ORM\ManyToOne(targetEntity=Client::class, inversedBy="monitoringObjectives")
  33.      */
  34.     private $client;
  36.     /**
  37.      * @ORM\ManyToOne(targetEntity=Culture::class, inversedBy="monitoringObjectives")
  38.      */
  39.     private $culture;
  41.     /**
  42.      * @ORM\ManyToOne(targetEntity=Techcard::class, inversedBy="monitoringObjectives")
  43.      */
  44.     private $techcard;
  46.     /**
  47.      * @ORM\ManyToOne(targetEntity=Operation::class, inversedBy="monitoringObjectives")
  48.      */
  49.     private $operation;
  51.     /**
  52.      * @ORM\Column(type="date")
  53.      */
  54.     private $dateStart;
  56.     /**
  57.      * @ORM\Column(type="datetime")
  58.      */
  59.     private $dateEnd;
  61.     /**
  62.      * @ORM\ManyToOne(targetEntity=Employee::class, inversedBy="monitoringObjectives")
  63.      */
  64.     private $viewer;
  66.     /**
  67.      * @ORM\ManyToOne(targetEntity=User::class, inversedBy="monitoringObjectives")
  68.      */
  69.     private $creator;
  71.     /**
  72.      * @ORM\OneToMany(targetEntity=Objective::class, mappedBy="monitoringObjective")
  73.      */
  74.     private $objectives;
  76.     /**
  77.      * @ORM\Column(type="string", length=255, nullable=true)
  78.      */
  79.     private $name;
  81.     /**
  82.      * @ORM\Column(type="boolean", nullable=true, options={"default" : false})
  83.      */
  84.     private $close;
  86.     /**
  87.      * @ORM\Column(type="datetime", nullable=true)
  88.      */
  89.     private $updateAt;
  91.     /**
  92.      * @ORM\Column(type="boolean", nullable=true)
  93.      */
  94.     private $complete;
  96.     /**
  97.      * @ORM\ManyToOne(targetEntity=Season::class, inversedBy="monitoringObjectives")
  98.      */
  99.     private $season;
  101.     /**
  102.      * @ORM\Column(type="string", length=255, nullable=true)
  103.      */
  104.     private $hash;
  106.     public function __construct()
  107.     {
  108.         if(empty($this->id)){
  109.             $this->name = 'Новый мониторинг';
  110.             $this->close = false;
  111.             $this->complete = false;
  112.             $this->setHash();
  113.         }
  114.         $this->objectives = new ArrayCollection();
  115.         $this->updateAt = new \DateTime();
  116.     }
  118.     public function getId(): ?int
  119.     {
  120.         return $this->id;
  121.     }
  123.     public function getClient(): ?Client
  124.     {
  125.         return $this->client;
  126.     }
  128.     public function setClient(?Client $client): self
  129.     {
  130.         $this->client = $client;
  132.         return $this;
  133.     }
  135.     public function getCulture(): ?Culture
  136.     {
  137.         return $this->culture;
  138.     }
  140.     public function setCulture(?Culture $culture): self
  141.     {
  142.         $this->culture = $culture;
  144.         return $this;
  145.     }
  147.     public function getTechcard(): ?Techcard
  148.     {
  149.         return $this->techcard;
  150.     }
  152.     public function setTechcard(?Techcard $techcard): self
  153.     {
  154.         $this->techcard = $techcard;
  156.         return $this;
  157.     }
  159.     public function getOperation(): ?Operation
  160.     {
  161.         return $this->operation;
  162.     }
  164.     public function setOperation(?Operation $operation): self
  165.     {
  166.         $this->operation = $operation;
  168.         return $this;
  169.     }
  171.     public function getDateStart(): ?\DateTimeInterface
  172.     {
  173.         return $this->dateStart;
  174.     }
  176.     public function setDateStart(\DateTimeInterface $dateStart): self
  177.     {
  178.         $this->dateStart = $dateStart;
  180.         return $this;
  181.     }
  183.     public function getDateEnd(): ?\DateTimeInterface
  184.     {
  185.         return $this->dateEnd;
  186.     }
  188.     public function setDateEnd(\DateTimeInterface $dateEnd): self
  189.     {
  190.         $this->dateEnd = $dateEnd;
  192.         return $this;
  193.     }
  195.     public function getViewer(): ?Employee
  196.     {
  197.         return $this->viewer;
  198.     }
  200.     public function setViewer(?Employee $viewer): self
  201.     {
  202.         $this->viewer = $viewer;
  204.         return $this;
  205.     }
  207.     public function getCreator(): ?User
  208.     {
  209.         return $this->creator;
  210.     }
  212.     public function setCreator(?User $creator): self
  213.     {
  214.         $this->creator = $creator;
  216.         return $this;
  217.     }
  219.     /**
  220.      * @return Collection<int, Objective>
  221.      */
  222.     public function getObjectives(): Collection
  223.     {
  224.         return $this->objectives;
  225.     }
  227.     public function addObjective(Objective $objective): self
  228.     {
  229.         if (!$this->objectives->contains($objective)) {
  230.             $this->objectives[] = $objective;
  231.             $objective->setMonitoringObjective($this);
  232.         }
  234.         return $this;
  235.     }
  237.     public function removeObjective(Objective $objective): self
  238.     {
  239.         if ($this->objectives->removeElement($objective)) {
  240.             // set the owning side to null (unless already changed)
  241.             if ($objective->getMonitoringObjective() === $this) {
  242.                 $objective->setMonitoringObjective(null);
  243.             }
  244.         }
  246.         return $this;
  247.     }
  249.     public function getStatus(): string
  250.     {
  251.         $status = StatusConstant::NEW;
  253.         if($this->getObjectives()->count() > 0){
  254.             $cancelCount = 0;
  255.             foreach ($this->getObjectives() as $objective){
  256.                 if(in_array($objective->getStatus(),[StatusConstant::IN_PROGRESS,StatusConstant::COMPLETE])){
  257.                     $status = StatusConstant::IN_PROGRESS;
  258.                     break;
  259.                 }
  260.                 if(in_array($objective->getStatus(),[StatusConstant::CANCEL])){
  261.                     $cancelCount++;
  262.                 }
  263.             }
  264.             if($this->getObjectives()->count() == $cancelCount){
  265.                 $status = StatusConstant::CANCEL;
  266.             }
  267.         }
  268.         if($this->close){
  269.             $status = StatusConstant::CANCEL;
  270.         }
  271.         $analitics = $this->getObjectivesAnalytics();
  272.         if($this->complete || (isset($analitics[StatusConstant::COMPLETE]) && ($this->getObjectives()->count() == $analitics[StatusConstant::COMPLETE]))){
  273.             $status = StatusConstant::COMPLETE;
  274.             $this->complete = true;
  275.         }
  276.        return  $status;
  277.     }
  279.     public function getName(): ?string
  280.     {
  281.         if(!empty($this->name)) {
  282.             return $this->name;
  283.         } else {
  284.             if(!empty($this->getOperation())){
  285.                 return $this->getOperation()->getName();
  286.             }
  287.         }
  288.         return '';
  289.     }
  291.     public function setName(?string $name): self
  292.     {
  293.         $this->name = $name;
  295.         return $this;
  296.     }
  298.     public function getObjectivesAnalytics(): ?array
  299.     {
  300.        $analitics = null;
  301.        if($this->getObjectives()->count() > 0){
  302.            $analitics = [];
  303.            foreach ($this->getObjectives() as $objective) {
  304.                $status = $objective->getStatus();
  305.                if($status == StatusConstant::NEW){
  306.                    $status = StatusConstant::FREE;
  307.                } elseif($status == StatusConstant::CANCEL && $objective->getReports()->count() > 0){
  308.                    $status = StatusConstant::COMPLETE;
  309.                }
  310.                if(isset($analitics[$status])){
  311.                    $analitics[$status] = $analitics[$status] + 1;
  312.                } else {
  313.                    $analitics[$status] = 1;
  314.                }
  315.            }
  316.        }
  317.        return $analitics;
  318.     }
  320.     public function isClose(): ?bool
  321.     {
  322.         return $this->close;
  323.     }
  325.     public function setClose(?bool $close): self
  326.     {
  327.         $this->close = $close;
  329.         return $this;
  330.     }
  332.     public function getUpdateAt(): ?\DateTimeInterface
  333.     {
  334.         return $this->updateAt;
  335.     }
  337.     public function setUpdateAt(?\DateTimeInterface $updateAt): self
  338.     {
  339.         $this->updateAt = $updateAt;
  341.         return $this;
  342.     }
  344.     public function isComplete(): ?bool
  345.     {
  346.         return $this->complete;
  347.     }
  349.     public function setComplete(bool $complete): self
  350.     {
  351.         $this->complete = $complete;
  353.         return $this;
  354.     }
  356.     public function getSeason(): ?Season
  357.     {
  358.         return $this->season;
  359.     }
  361.     public function setSeason(?Season $season): self
  362.     {
  363.         $this->season = $season;
  365.         return $this;
  366.     }
  368.     public function getHash(): ?string
  369.     {
  370.         return $this->hash;
  371.     }
  373.     public function setHash(): self
  374.     {
  375.         $this->hash = md5(date('YmdHis').microtime(true).rand(0,999999));
  377.         return $this;
  378.     }
  380.     public function checkCompleteStatus()
  381.     {
  382.         $countAll = $this->getObjectives()->count();
  383.         $cancel = 0;
  384.         foreach ($this->getObjectives() as $objective) {
  385.             if(in_array($objective->getStatus(),[StatusConstant::CANCEL,StatusConstant::COMPLETE])){
  386.                 $cancel++;
  387.             }
  388.         }
  389.         if($cancel == $countAll && $cancel !== 0){
  390.             $this->setComplete(1);
  391.             $this->setHash();
  392.         }
  393.     }
  395. }