src/Entity/RateOfProgress.php line 17

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Traits\TimeStampableTrait;
  6. use App\Repository\RateOfProgressRepository;
  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\HttpFoundation\File\File;
  12. use Symfony\Component\Serializer\Annotation\Groups;
  13. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  15. #[ORM\Entity(repositoryClass: RateOfProgressRepository::class)]
  16. #[Vich\Uploadable]
  17. class RateOfProgress
  18. {
  19.     const WAITTING = 'En attente de validation';
  20.     const VALIDED = 'Approver';
  21.     const REJECTED = 'Retourner';
  23.     use TimeStampableTrait;
  25.     #[ORM\Id]
  26.     #[ORM\GeneratedValue]
  27.     #[ORM\Column]
  28.     #[Groups(['task:read', 'rejetEvaluation:read', 'activity:read'])]
  29.     private ?int $id = null;
  31.     #[ORM\Column]
  32.     #[Groups(['task:read', 'rejetEvaluation:read', 'activity:read'])]
  33.     private ?int $valeur = null;
  35.     #[ORM\Column(type: Types::TEXT)]
  36.     #[Groups(['task:read', 'rejetEvaluation:read', 'activity:read'])]
  37.     private ?string $commentaire = null;
  39.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
  40.     #[Groups(['task:read', 'activity:read'])]
  41.     private ?\DateTimeInterface $dateValidation = null;
  43.     #[ORM\Column(length: 255, nullable: true)]
  44.     #[Groups(['task:read', 'rejetEvaluation:read', 'activity:read'])]
  45.     private ?string $piece = null;
  47.     #[Vich\UploadableField(mapping: 'documents_tache', fileNameProperty: 'piece')]
  48.     private ?File $imageFile = null;
  50.     #[ORM\Column(nullable: true)]
  51.     private ?\DateTimeImmutable $updatedAtFile = null;
  53.     #[ORM\ManyToOne(inversedBy: 'rateOfProgress')]
  54.     private ?Task $tache = null;
  56.     #[ORM\Column(nullable: true)]
  57.     #[Groups(['task:read', 'activity:read'])]
  58.     private ?int $status = null;
  60.     #[ORM\OneToMany(mappedBy: 'RateOfProgress', targetEntity: RejectEvaluation::class, cascade:['remove'])]
  61.     private Collection $rejectEvaluations;
  63.     #[ORM\ManyToOne(inversedBy: 'rateOfProgress')]
  64.     private ?User $author = null;
  66.     #[ORM\Column]
  67.     #[Groups(['task:read', 'rejetEvaluation:read', 'activity:read'])]
  69.     private ?bool $isValided = null;
  71.     #[Groups(['task:read'])]
  73.     #[ORM\OneToMany(mappedBy: 'rateOfProgress', targetEntity: Comment::class)]
  74.     private Collection $comment;
  76.     #[ORM\OneToMany(mappedBy: 'rateOfProgress', targetEntity: Document::class, cascade:['persist', 'remove'])]
  77.     private Collection $documents;
  79.     #[ORM\ManyToOne(inversedBy: 'rateOfProgress')]
  80.     private ?Activity $activity = null;
  82.     #[ORM\Column]
  83.     #[Groups(['task:read', 'rejetEvaluation:read', 'activity:read'])]
  84.     private ?int $reference = null;
  86.     public function __construct()
  87.     {
  88.         $this->createdAt = new \DateTimeImmutable();
  89.         $this->rejectEvaluations = new ArrayCollection();
  90.         $this->isValided = false;
  91.         $this->comment = new ArrayCollection();
  92.         $this->documents = new ArrayCollection();
  93.         $this->reference = 0;
  94.     }
  96.     public function getId(): ?int
  97.     {
  98.         return $this->id;
  99.     }
  101.     public function getValeur(): ?int
  102.     {
  103.         return $this->valeur;
  104.     }
  106.     public function setValeur(int $valeur): static
  107.     {
  108.         $this->valeur = $valeur;
  110.         return $this;
  111.     }
  113.     public function getCommentaire(): ?string
  114.     {
  115.         return $this->commentaire;
  116.     }
  118.     public function setCommentaire(string $commentaire): static
  119.     {
  120.         $this->commentaire = $commentaire;
  122.         return $this;
  123.     }
  125.     public function getDateValidation(): ?\DateTimeInterface
  126.     {
  127.         return $this->dateValidation;
  128.     }
  130.     public function setDateValidation(\DateTimeInterface $dateValidation): static
  131.     {
  132.         $this->dateValidation = $dateValidation;
  134.         return $this;
  135.     }
  137.     public function getPiece(): ?string
  138.     {
  139.         return $this->piece;
  140.     }
  142.     public function setPiece(?string $piece): static
  143.     {
  144.         $this->piece = $piece;
  146.         return $this;
  147.     }
  149.     public function getTache(): ?Task
  150.     {
  151.         return $this->tache;
  152.     }
  154.     public function setTache(?Task $tache): static
  155.     {
  156.         $this->tache = $tache;
  158.         return $this;
  159.     }
  161.     /**
  162.      * If manually uploading a file (i.e. not using Symfony Form) ensure an instance
  163.      * of 'UploadedFile' is injected into this setter to trigger the update. If this
  164.      * bundle's configuration parameter 'inject_on_load' is set to 'true' this setter
  165.      * must be able to accept an instance of 'File' as the bundle will inject one here
  166.      * during Doctrine hydration.
  167.      *
  168.      * @param File|\Symfony\Component\HttpFoundation\File\UploadedFile|null $imageFile
  169.      */
  170.     public function setImageFile(?File $imageFile = null): void
  171.     {
  172.         $this->imageFile = $imageFile;
  174.         if (null !== $imageFile) {
  175.             // It is required that at least one field changes if you are using doctrine
  176.             // otherwise the event listeners won't be called and the file is lost
  177.             $this->updatedAtFile = new \DateTimeImmutable();
  178.         }
  179.     }
  181.     public function getImageFile(): ?File
  182.     {
  183.         return $this->imageFile;
  184.     }
  186.     // public function setImageName(?string $imageName): void
  187.     // {
  188.     //     $this->imageName = $imageName;
  189.     // }
  191.     public function getStatus(): ?int
  192.     {
  193.         return $this->status;
  194.     }
  196.     public function setStatus(?int $status): static
  197.     {
  198.         $this->status = $status;
  200.         return $this;
  201.     }
  203.     #[Groups(['task:read', 'activity:read'])]
  204.     public function getStatusRate(): string
  205.     {
  206.         if ($this->getStatus() == 1) {
  207.             return self::WAITTING;
  208.         }
  209.         if ($this->getStatus() == 2) {
  210.             return self::REJECTED;
  211.         }
  212.         if ($this->getStatus() == 3) {
  213.             return self::VALIDED;
  214.         }
  216.         return '';
  217.     }
  219.     /**
  220.      * @return Collection<int, RejectEvaluation>
  221.      */
  222.     public function getRejectEvaluations(): Collection
  223.     {
  224.         return $this->rejectEvaluations;
  225.     }
  227.     public function addRejectEvaluation(RejectEvaluation $rejectEvaluation): static
  228.     {
  229.         if (!$this->rejectEvaluations->contains($rejectEvaluation)) {
  230.             $this->rejectEvaluations->add($rejectEvaluation);
  231.             $rejectEvaluation->setRateOfProgress($this);
  232.         }
  234.         return $this;
  235.     }
  237.     public function removeRejectEvaluation(RejectEvaluation $rejectEvaluation): static
  238.     {
  239.         if ($this->rejectEvaluations->removeElement($rejectEvaluation)) {
  240.             // set the owning side to null (unless already changed)
  241.             if ($rejectEvaluation->getRateOfProgress() === $this) {
  242.                 $rejectEvaluation->setRateOfProgress(null);
  243.             }
  244.         }
  246.         return $this;
  247.     }
  249.     public function getAuthor(): ?User
  250.     {
  251.         return $this->author;
  252.     }
  254.     public function setAuthor(?User $author): static
  255.     {
  256.         $this->author = $author;
  258.         return $this;
  259.     }
  261.     public function isIsValided(): ?bool
  262.     {
  263.         return $this->isValided;
  264.     }
  266.     public function setIsValided(bool $isValided): static
  267.     {
  268.         $this->isValided = $isValided;
  270.         return $this;
  271.     }
  273.     /**
  274.      * @return Collection<int, Comment>
  275.      */
  276.     public function getComment(): Collection
  277.     {
  278.         return $this->comment;
  279.     }
  281.     public function addComment(Comment $comment): static
  282.     {
  283.         if (!$this->comment->contains($comment)) {
  284.             $this->comment->add($comment);
  285.             $comment->setRateOfProgress($this);
  286.         }
  288.         return $this;
  289.     }
  291.     public function removeComment(Comment $comment): static
  292.     {
  293.         if ($this->comment->removeElement($comment)) {
  294.             // set the owning side to null (unless already changed)
  295.             if ($comment->getRateOfProgress() === $this) {
  296.                 $comment->setRateOfProgress(null);
  297.             }
  298.         }
  300.         return $this;
  301.     }
  303.     /**
  304.      * @return Collection<int, Document>
  305.      */
  306.     public function getDocuments(): Collection
  307.     {
  308.         return $this->documents;
  309.     }
  311.     public function addDocument(Document $document): static
  312.     {
  313.         if (!$this->documents->contains($document)) {
  314.             $this->documents->add($document);
  315.             $document->setRateOfProgress($this);
  316.         }
  318.         return $this;
  319.     }
  321.     public function removeDocument(Document $document): static
  322.     {
  323.         if ($this->documents->removeElement($document)) {
  324.             // set the owning side to null (unless already changed)
  325.             if ($document->getRateOfProgress() === $this) {
  326.                 $document->setRateOfProgress(null);
  327.             }
  328.         }
  330.         return $this;
  331.     }
  333.     public function getActivity(): ?Activity
  334.     {
  335.         return $this->activity;
  336.     }
  338.     public function setActivity(?Activity $activity): static
  339.     {
  340.         $this->activity = $activity;
  342.         return $this;
  343.     }
  345.     public function getReference(): ?int
  346.     {
  347.         return $this->reference;
  348.     }
  350.     public function setReference(int $reference): static
  351.     {
  352.         $this->reference = $reference;
  354.         return $this;
  355.     }
  357.     #[Groups(['task:read'])]
  358.     public function getUnite() {
  359.         return $this->activity->getUnite()?->getName();
  360.     }
  362.     #[Groups(['task:read'])]
  363.     public function getCountComment(): int {
  364.         return $this->getComment()->count();
  365.     }
  366. }