src/Entity/Activity.php line 20

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Traits\TimeStampableTrait;
  6. use App\Repository\ActivityRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\DBAL\Types\Types;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use Symfony\Component\Serializer\Annotation\Groups;
  12. use Symfony\Component\Validator\Constraints as Assert;
  13. use App\Validator as CustomAssert;
  16. #[ORM\Entity(repositoryClass: ActivityRepository::class)]
  17. #[CustomAssert\StartDateActivity]
  18. #[CustomAssert\DateRange]
  20. class Activity
  21. {
  22.     use TimeStampableTrait;
  24.     #[ORM\Id]
  25.     #[ORM\GeneratedValue]
  26.     #[ORM\Column]
  27.     #[Groups(['objectif:read', 'activity:read', 'activiteBailleurs', 'entity:write'])]
  28.     private ?int $id = null;
  30.     #[ORM\Column(length: 255)]
  31.     #[Groups(['objectif:read', 'activity:read', 'activiteBailleurs', 'entity:write'])]
  32.     private ?string $code = null;
  34.     #[ORM\ManyToOne(inversedBy: 'activities')]
  35.     #[Groups(['entity:write'])]
  37.     private ?Objectif $objectif = null;
  39.     #[ORM\ManyToOne(inversedBy: 'activities')]
  40.     #[Groups(['objectif:read', 'activity:read', 'entity:write'])]
  41.     #[Assert\NotBlank(message: "Veuillez remplir ce champ")]
  42.     private ?Unite $unite = null;
  44.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  45.     #[Groups(['objectif:read', 'activity:read', 'activiteBailleurs', 'entity:write'])]
  46.     #[Assert\NotBlank(message: "Veuillez remplir ce champ")]
  47.     private ?string $description = null;
  49.     // #[ORM\ManyToOne(inversedBy: 'activities')]
  50.     // #[Groups(['objectif:read', 'activity:read', 'entity:write'])]
  51.     // #[Assert\NotBlank(message: "Veuillez remplir ce champ")]
  52.     // private ?Priority $priority = null;
  54.     #[Assert\NotBlank(message: "Veuillez remplir ce champ")]
  55.     #[ORM\Column(length: 255)]
  56.     #[Groups(['objectif:read', 'activity:read', 'entity:write'])]
  57.     private ?int $status = null;
  59.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
  60.     #[Groups(['objectif:read', 'activity:read', 'entity:write'])]
  61.     #[Assert\NotBlank(message: "Veuillez remplir ce champ")]
  62.     private ?\DateTimeInterface $StartDateEstimate = null;
  64.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
  65.     #[Groups(['objectif:read', 'activity:read', 'entity:write'])]
  66.     #[Assert\NotBlank(message: "Veuillez remplir ce champ")]
  67.     private ?\DateTimeInterface $endDateEstimate = null;
  69.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
  70.     #[Groups(['objectif:read', 'activity:read', 'entity:write'])]
  71.     #[Assert\NotBlank(message: "Veuillez remplir ce champ")]
  72.     private ?\DateTimeInterface $startDate = null;
  74.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
  75.     #[Groups(['objectif:read', 'activity:read', 'entity:write',])]
  76.     #[Assert\NotBlank(message: "Veuillez remplir ce champ")]
  77.     private ?\DateTimeInterface $endDate = null;
  79.     #[ORM\Column(nullable: true)]
  80.     #[Groups(['objectif:read', 'activity:read', 'entity:write'])]
  81.     #[Assert\NotBlank(message: "Veuillez remplir ce champ")]
  82.     private ?int $quantity = null;
  84.     #[ORM\OneToMany(mappedBy: 'activity', targetEntity: ActiviteBailleur::class, cascade: ['remove'])]
  85.     #[Groups(['objectif:read', 'activity:read'])]
  87.     private Collection $activiteBailleurs;
  89.     #[ORM\OneToMany(mappedBy: 'activity', targetEntity: RateOfProgress::class,  cascade: ['persist', 'remove'])]
  90.     #[Groups(['objectif:read', 'activity:read', 'activity:read'])]
  92.     private Collection $rateOfProgress;
  94.     #[ORM\Column]
  95.     private ?bool $isValided = null;
  97.     #[ORM\OneToMany(mappedBy: 'activity', targetEntity: Comment::class,  cascade: ['persist', 'remove'])]
  98.     private Collection $comments;
  100.     #[ORM\ManyToOne(inversedBy: 'activities')]
  101.     private ?User $createdBy = null;
  103.     #[ORM\Column]
  104.     #[Groups(['objectif:read', 'activity:read', 'entity:write'])]
  105.     private ?int $reference = null;
  107.     public function __construct()
  108.     {
  109.         $this->createdAt = new \DateTimeImmutable();
  110.         $this->status = 1;
  111.         $this->quantity = 0;
  112.         $this->activiteBailleurs = new ArrayCollection();
  113.         $this->rateOfProgress = new ArrayCollection();
  114.         $this->isValided = false;
  115.         $this->comments = new ArrayCollection();
  116.         $this->reference = 0;
  117.     }
  119.     public function getId(): ?int
  120.     {
  121.         return $this->id;
  122.     }
  124.     public function getCode(): ?string
  125.     {
  126.         return $this->code;
  127.     }
  129.     public function setCode(?string $code): static
  130.     {
  131.         $this->code = $code;
  133.         return $this;
  134.     }
  136.     public function getObjectif(): ?Objectif
  137.     {
  138.         return $this->objectif;
  139.     }
  141.     public function setObjectif(?Objectif $objectif): static
  142.     {
  143.         $this->objectif = $objectif;
  145.         return $this;
  146.     }
  148.     public function getUnite(): ?Unite
  149.     {
  150.         return $this->unite;
  151.     }
  153.     public function setUnite(?Unite $unite): static
  154.     {
  155.         $this->unite = $unite;
  157.         return $this;
  158.     }
  160.     public function getDescription(): ?string
  161.     {
  162.         return $this->description;
  163.     }
  165.     public function setDescription(?string $description): static
  166.     {
  167.         $this->description = $description;
  169.         return $this;
  170.     }
  172.     // public function getPriority(): ?Priority
  173.     // {
  174.     //     return $this->priority;
  175.     // }
  177.     // public function setPriority(?Priority $priority): static
  178.     // {
  179.     //     $this->priority = $priority;
  181.     //     return $this;
  182.     // }
  184.     public function getStatus(): ?int
  185.     {
  186.         return $this->status;
  187.     }
  189.     public function setStatus(?int $status): static
  190.     {
  191.         $this->status = $status;
  193.         return $this;
  194.     }
  196.     public function getStartDateEstimate(): ?\DateTimeInterface
  197.     {
  198.         return $this->StartDateEstimate;
  199.     }
  201.     public function setStartDateEstimate(?\DateTimeInterface $StartDateEstimate): static
  202.     {
  203.         $this->StartDateEstimate = $StartDateEstimate;
  205.         return $this;
  206.     }
  208.     public function getEndDateEstimate(): ?\DateTimeInterface
  209.     {
  210.         return $this->endDateEstimate;
  211.     }
  213.     public function setEndDateEstimate(?\DateTimeInterface $endDateEstimate): static
  214.     {
  215.         $this->endDateEstimate = $endDateEstimate;
  217.         return $this;
  218.     }
  220.     public function getStartDate(): ?\DateTimeInterface
  221.     {
  222.         return $this->startDate;
  223.     }
  225.     public function setStartDate(?\DateTimeInterface $startDate): static
  226.     {
  227.         $this->startDate = $startDate;
  229.         return $this;
  230.     }
  232.     public function getEndDate(): ?\DateTimeInterface
  233.     {
  234.         return $this->endDate;
  235.     }
  237.     public function setEndDate(?\DateTimeInterface $endDate): static
  238.     {
  239.         $this->endDate = $endDate;
  241.         return $this;
  242.     }
  244.     public function status(): string
  245.     {
  246.         if ($this->status ==  1) {
  247.             return 'En cours';
  248.         } elseif ($this->status == 2) {
  249.             return 'Terminé';
  250.         } elseif ($this->status == 3) {
  251.             return 'Terminer';
  252.         } else {
  253.             return  '';
  254.         }
  255.     }
  257.     public function getQuantity(): ?int
  258.     {
  259.         return $this->quantity;
  260.     }
  262.     public function setQuantity(?int $quantity): static
  263.     {
  264.         $this->quantity = $quantity;
  266.         return $this;
  267.     }
  269.     /**
  270.      * @return Collection<int, ActiviteBailleur>
  271.      */
  272.     public function getActiviteBailleurs(): Collection
  273.     {
  274.         return $this->activiteBailleurs;
  275.     }
  277.     public function addActiviteBailleur(ActiviteBailleur $activiteBailleur): static
  278.     {
  279.         if (!$this->activiteBailleurs->contains($activiteBailleur)) {
  280.             $this->activiteBailleurs->add($activiteBailleur);
  281.             $activiteBailleur->setActivity($this);
  282.         }
  284.         return $this;
  285.     }
  287.     public function removeActiviteBailleur(ActiviteBailleur $activiteBailleur): static
  288.     {
  289.         if ($this->activiteBailleurs->removeElement($activiteBailleur)) {
  290.             // set the owning side to null (unless already changed)
  291.             if ($activiteBailleur->getActivity() === $this) {
  292.                 $activiteBailleur->setActivity(null);
  293.             }
  294.         }
  296.         return $this;
  297.     }
  299.     /**
  300.      * @return Collection<int, RateOfProgress>
  301.      */
  302.     public function getRateOfProgress(): Collection
  303.     {
  304.         return $this->rateOfProgress;
  305.     }
  307.     public function addRateOfProgress(RateOfProgress $rateOfProgress): static
  308.     {
  309.         if (!$this->rateOfProgress->contains($rateOfProgress)) {
  310.             $this->rateOfProgress->add($rateOfProgress);
  311.             $rateOfProgress->setActivity($this);
  312.         }
  314.         return $this;
  315.     }
  317.     public function removeRateOfProgress(RateOfProgress $rateOfProgress): static
  318.     {
  319.         if ($this->rateOfProgress->removeElement($rateOfProgress)) {
  320.             // set the owning side to null (unless already changed)
  321.             if ($rateOfProgress->getActivity() === $this) {
  322.                 $rateOfProgress->setActivity(null);
  323.             }
  324.         }
  326.         return $this;
  327.     }
  329.     // public function getUsersAssign(): array
  330.     // {
  331.     //     $userAssing = [];
  332.     //     foreach ($this->taskAssigns as $assig) {
  333.     //         $userAssing[] = $assig->getUser();
  334.     //     }
  336.     //     return $userAssing;
  337.     // }
  339.     // public function getUserNotAssign(array $users): array
  340.     // {
  341.     //     $userAssign = $this->getUsersAssign();
  342.     //     $userNotAssing = array_diff($users, $userAssign);
  344.     //     return $userNotAssing;
  345.     // }
  347.     public function isIsValided(): ?bool
  348.     {
  349.         return $this->isValided;
  350.     }
  352.     public function setIsValided(bool $isValided): static
  353.     {
  354.         $this->isValided = $isValided;
  356.         return $this;
  357.     }
  359.     #[Groups(['activity:read', 'objectif:read'])]
  360.     public function getTauxAvancement(): int
  361.     {
  362.         $taux = [];
  363.         $countAvaluation = count($this->getRateOfProgress());
  365.         foreach ($this->rateOfProgress as $rate) {
  366.             if ($rate->isIsValided()) {
  367.                 $taux[] = 100;
  368.             } else {
  369.                 $taux[] = 0;
  370.             }
  371.         }
  373.         $sumTaux = array_sum($taux) > 0 ? array_sum($taux) / $countAvaluation : 0;
  375.         return $sumTaux;
  376.     }
  378.     /**
  379.      * @return Collection<int, Comment>
  380.      */
  381.     public function getComments(): Collection
  382.     {
  383.         return $this->comments;
  384.     }
  386.     public function addComment(Comment $comment): static
  387.     {
  388.         if (!$this->comments->contains($comment)) {
  389.             $this->comments->add($comment);
  390.             $comment->setActivity($this);
  391.         }
  393.         return $this;
  394.     }
  396.     public function removeComment(Comment $comment): static
  397.     {
  398.         if ($this->comments->removeElement($comment)) {
  399.             // set the owning side to null (unless already changed)
  400.             if ($comment->getActivity() === $this) {
  401.                 $comment->setActivity(null);
  402.             }
  403.         }
  405.         return $this;
  406.     }
  408.     #[Groups(['activity:read', 'objectif:read'])]
  409.     public function getLastTaux()
  410.     {
  411.       
  412.         $lastValidedRate = $this->getLastRateValided();
  413.         return $this->getLastRateValided() ? $this->getLastRateValided()->getValeur() : 0;
  415.     }
  416.     public function getLastRateValided()
  417.     {
  418.         $validedRates = array_filter($this->rateOfProgress->toArray(), function ($rateOf) {
  419.             return $rateOf->isIsValided();
  420.         });
  422.         return end($validedRates) ?: null;
  423.     }
  425.     public function pao(){
  426.         return $this->objectif->getPao();
  427.     }
  429.     public function getCreatedBy(): ?User
  430.     {
  431.         return $this->createdBy;
  432.     }
  434.     public function setCreatedBy(?User $createdBy): static
  435.     {
  436.         $this->createdBy = $createdBy;
  438.         return $this;
  439.     }
  441.     public function getReference(): ?int
  442.     {
  443.         return $this->reference;
  444.     }
  446.     public function setReference(int $reference): static
  447.     {
  448.         $this->reference = $reference;
  450.         return $this;
  451.     }
  453.     public function getCommentaireRateOf(RateOfProgress $rateOfProgress) {
  454.         return $rateOfProgress?->getComment();
  455.     }
  456. }