src/Entity/ChecklistTask.php line 12

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\ChecklistTaskRepository;
  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;
  11. #[ORM\Entity(repositoryClass: ChecklistTaskRepository::class)]
  12. class ChecklistTask
  13. {
  15.     public const PRIORITY_LOW = 'LOW';
  16.     public const PRIORITY_MEDIUM = 'MEDIUM';
  17.     public const PRIORITY_HIGH = 'HIGH';
  19.     // Enum values for ChecklistVisibility
  20.     public const VISIBILITY_PUBLIC = 'PUBLIC';
  21.     public const VISIBILITY_PRIVATE = 'PRIVATE';
  23.     // Enum values for DependantOn
  24.     public const CHECKLIST_START_DATE = 'CHECKLIST_START_DATE';
  25.     public const CHECKLIST_END_DATE = 'CHECKLIST_END_DATE';
  26.     public const TASK = 'TASK';
  28.     #[ORM\Id]
  29.     #[ORM\GeneratedValue]
  30.     #[ORM\Column]
  31.     private ?int $id = null;
  33.     #[ORM\Column(length: 255)]
  34.     private ?string $name = null;
  36.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  37.     private ?string $description = null;
  39.     #[ORM\Column(length: 30, nullable: true)]
  40.     private ?string $priority = null;
  42.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  43.     private ?\DateTimeInterface $dueDate = null;
  45.     #[ORM\Column(nullable: true)]
  46.     private ?string $status = null;
  48.     #[ORM\Column(nullable: true)]
  49.     private ?string $dependantOn = null;
  51.     #[ORM\Column(length: 10, nullable: true)]
  52.     private ?string $visibility = null;
  54.     #[ORM\Column(nullable: true)]
  55.     private ?bool $requireDocument = null;
  57.     #[ORM\Column(nullable: true)]
  58.     private ?int $position = null;
  60.     #[ORM\OneToMany(mappedBy: 'task', targetEntity: ChecklistHowTo::class, orphanRemoval: true)]
  61.     private Collection $checklistHowTos;
  63.     #[ORM\OneToMany(mappedBy: 'task', targetEntity: ChecklistTaskDependency::class, orphanRemoval: true)]
  64.     private Collection $taskDependencies;
  66.     #[ORM\OneToMany(mappedBy: 'taskParent', targetEntity: ChecklistTaskDependency::class, orphanRemoval: true)]
  67.     private Collection $taskDependencyAsParent;
  69.     #[ORM\ManyToOne(inversedBy: 'tasks')]
  70.     #[ORM\JoinColumn(nullable: false, onDelete: 'CASCADE')]
  71.     private ?Checklist $checklist = null;
  73.     #[ORM\ManyToOne(inversedBy: 'checklistTasksAsAssignee')]
  74.     private ?User $defaultAssignee = null;
  76.     #[ORM\ManyToOne(inversedBy: 'checklistTaskAsVerifier')]
  77.     private ?User $verifier = null;
  79.     #[ORM\Column(length: 255, nullable: true)]
  80.     private ?string $document = null;
  82.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  83.     private ?string $comment = null;
  85.     #[ORM\OneToMany(mappedBy: 'task', targetEntity: ChecklistActivity::class)]
  86.     private Collection $checklistActivities;
  88.     #[ORM\OneToMany(mappedBy: 'task', targetEntity: ChecklistNotification::class)]
  89.     private Collection $checklistNotifications;
  91.     #[ORM\Column(nullable: true)]
  92.     private ?int $offsetInDays = null;
  94.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'offsetTasks')]
  95.     #[ORM\JoinColumn(onDelete: 'SET NULL')]
  96.     private ?self $offsetTask = null;
  98.     #[ORM\OneToMany(mappedBy: 'offsetTask', targetEntity: self::class)]
  99.     private Collection $offsetTasks;
  101.     #[ORM\Column(nullable: true)]
  102.     private ?\DateTimeImmutable $startDate = null;
  104.     #[ORM\Column(nullable: true)]
  105.     private ?int $durationInDays = null;
  107.     #[ORM\OneToMany(mappedBy: 'task', targetEntity: ProjectDynamicField::class, orphanRemoval: true)]
  108.     private Collection $projectDynamicFields;
  110.     public function __construct()
  111.     {
  112.         $this->checklistHowTos = new ArrayCollection();
  113.         $this->taskDependencies = new ArrayCollection();
  114.         $this->taskDependencyAsParent = new ArrayCollection();
  115.         $this->checklistActivities = new ArrayCollection();
  116.         $this->checklistNotifications = new ArrayCollection();
  117.         $this->offsetTasks = new ArrayCollection();
  118.         $this->projectDynamicFields = new ArrayCollection();
  119.     }
  121.     public function getId(): ?int
  122.     {
  123.         return $this->id;
  124.     }
  126.     public function getName(): ?string
  127.     {
  128.         return $this->name;
  129.     }
  131.     public function setName(string $name): self
  132.     {
  133.         $this->name = $name;
  135.         return $this;
  136.     }
  138.     public function getDescription(): ?string
  139.     {
  140.         return $this->description;
  141.     }
  143.     public function setDescription(?string $description): self
  144.     {
  145.         $this->description = $description;
  147.         return $this;
  148.     }
  150.     public function getPriority(): ?string
  151.     {
  152.         return $this->priority;
  153.     }
  155.     public function setPriority(?string $priority): self
  156.     {
  157.         $this->priority = $priority;
  159.         return $this;
  160.     }
  162.     public function getDueDate(): ?\DateTimeInterface
  163.     {
  164.         return $this->dueDate;
  165.     }
  167.     public function setDueDate(?\DateTimeInterface $dueDate): self
  168.     {
  169.         $this->dueDate = $dueDate;
  171.         return $this;
  172.     }
  174.     public function getVisibility(): ?string
  175.     {
  176.         return $this->visibility;
  177.     }
  179.     public function setVisibility(?string $visibility): self
  180.     {
  181.         $this->visibility = $visibility;
  183.         return $this;
  184.     }
  186.     public function isRequireDocument(): ?bool
  187.     {
  188.         return $this->requireDocument;
  189.     }
  191.     public function setRequireDocument(?bool $requireDocument): self
  192.     {
  193.         $this->requireDocument = $requireDocument;
  195.         return $this;
  196.     }
  198.     public function getPosition(): ?int
  199.     {
  200.         return $this->position;
  201.     }
  203.     public function setPosition(?int $position): self
  204.     {
  205.         $this->position = $position;
  207.         return $this;
  208.     }
  210.     /**
  211.      * @return Collection<int, ChecklistHowTo>
  212.      */
  213.     public function getChecklistHowTos(): Collection
  214.     {
  215.         return $this->checklistHowTos;
  216.     }
  218.     public function addChecklistHowTo(ChecklistHowTo $checklistHowTo): self
  219.     {
  220.         if (!$this->checklistHowTos->contains($checklistHowTo)) {
  221.             $this->checklistHowTos->add($checklistHowTo);
  222.             $checklistHowTo->setTask($this);
  223.         }
  225.         return $this;
  226.     }
  228.     public function removeChecklistHowTo(ChecklistHowTo $checklistHowTo): self
  229.     {
  230.         if ($this->checklistHowTos->removeElement($checklistHowTo)) {
  231.             // set the owning side to null (unless already changed)
  232.             if ($checklistHowTo->getTask() === $this) {
  233.                 $checklistHowTo->setTask(null);
  234.             }
  235.         }
  237.         return $this;
  238.     }
  240.     /**
  241.      * @return Collection<int, ChecklistTaskDependency>
  242.      */
  243.     public function getTaskDependencies(): Collection
  244.     {
  245.         return $this->taskDependencies;
  246.     }
  248.     public function addTaskDependency(ChecklistTaskDependency $taskDependency): self
  249.     {
  250.         if (!$this->taskDependencies->contains($taskDependency)) {
  251.             $this->taskDependencies->add($taskDependency);
  252.             $taskDependency->setTask($this);
  253.         }
  255.         return $this;
  256.     }
  258.     public function removeTaskDependency(ChecklistTaskDependency $taskDependency): self
  259.     {
  260.         if ($this->taskDependencies->removeElement($taskDependency)) {
  261.             // set the owning side to null (unless already changed)
  262.             if ($taskDependency->getTask() === $this) {
  263.                 $taskDependency->setTask(null);
  264.             }
  265.         }
  267.         return $this;
  268.     }
  270.     /**
  271.      * @return Collection<int, ChecklistTaskDependency>
  272.      */
  273.     public function getTaskDependencyAsParent(): Collection
  274.     {
  275.         return $this->taskDependencyAsParent;
  276.     }
  278.     public function addTaskDependencyAsParent(ChecklistTaskDependency $taskDependencyAsParent): self
  279.     {
  280.         if (!$this->taskDependencyAsParent->contains($taskDependencyAsParent)) {
  281.             $this->taskDependencyAsParent->add($taskDependencyAsParent);
  282.             $taskDependencyAsParent->setTaskParent($this);
  283.         }
  285.         return $this;
  286.     }
  288.     public function removeTaskDependencyAsParent(ChecklistTaskDependency $taskDependencyAsParent): self
  289.     {
  290.         if ($this->taskDependencyAsParent->removeElement($taskDependencyAsParent)) {
  291.             // set the owning side to null (unless already changed)
  292.             if ($taskDependencyAsParent->getTaskParent() === $this) {
  293.                 $taskDependencyAsParent->setTaskParent(null);
  294.             }
  295.         }
  297.         return $this;
  298.     }
  300.     public function getChecklist(): ?Checklist
  301.     {
  302.         return $this->checklist;
  303.     }
  305.     public function setChecklist(?Checklist $checklist): self
  306.     {
  307.         $this->checklist = $checklist;
  309.         return $this;
  310.     }
  312.     public function getDefaultAssignee(): ?User
  313.     {
  314.         return $this->defaultAssignee;
  315.     }
  317.     public function setDefaultAssignee(?User $defaultAssignee): self
  318.     {
  319.         $this->defaultAssignee = $defaultAssignee;
  321.         return $this;
  322.     }
  324.     public function getVerifier(): ?User
  325.     {
  326.         return $this->verifier;
  327.     }
  329.     public function setVerifier(?User $verifier): self
  330.     {
  331.         $this->verifier = $verifier;
  333.         return $this;
  334.     }
  336.     public function getDocument(): ?string
  337.     {
  338.         return $this->document;
  339.     }
  341.     public function setDocument(?string $document): self
  342.     {
  343.         $this->document = $document;
  345.         return $this;
  346.     }
  348.     public function getStatus(): ?string
  349.     {
  350.         return $this->status;
  351.     }
  353.     public function setStatus(?string $status): void
  354.     {
  355.         $this->status = $status;
  356.     }
  358.     public function getComment(): ?string
  359.     {
  360.         return $this->comment;
  361.     }
  363.     public function setComment(?string $comment): self
  364.     {
  365.         $this->comment = $comment;
  367.         return $this;
  368.     }
  370.     /**
  371.      * @return Collection<int, ChecklistActivity>
  372.      */
  373.     public function getChecklistActivities(): Collection
  374.     {
  375.         return $this->checklistActivities;
  376.     }
  378.     public function addChecklistActivity(ChecklistActivity $checklistActivity): self
  379.     {
  380.         if (!$this->checklistActivities->contains($checklistActivity)) {
  381.             $this->checklistActivities->add($checklistActivity);
  382.             $checklistActivity->setTask($this);
  383.         }
  385.         return $this;
  386.     }
  388.     public function removeChecklistActivity(ChecklistActivity $checklistActivity): self
  389.     {
  390.         if ($this->checklistActivities->removeElement($checklistActivity)) {
  391.             // set the owning side to null (unless already changed)
  392.             if ($checklistActivity->getTask() === $this) {
  393.                 $checklistActivity->setTask(null);
  394.             }
  395.         }
  397.         return $this;
  398.     }
  400.     /**
  401.      * @return Collection<int, ChecklistNotification>
  402.      */
  403.     public function getChecklistNotifications(): Collection
  404.     {
  405.         return $this->checklistNotifications;
  406.     }
  408.     public function addChecklistNotification(ChecklistNotification $checklistNotification): self
  409.     {
  410.         if (!$this->checklistNotifications->contains($checklistNotification)) {
  411.             $this->checklistNotifications->add($checklistNotification);
  412.             $checklistNotification->setTask($this);
  413.         }
  415.         return $this;
  416.     }
  418.     public function removeChecklistNotification(ChecklistNotification $checklistNotification): self
  419.     {
  420.         if ($this->checklistNotifications->removeElement($checklistNotification)) {
  421.             // set the owning side to null (unless already changed)
  422.             if ($checklistNotification->getTask() === $this) {
  423.                 $checklistNotification->setTask(null);
  424.             }
  425.         }
  427.         return $this;
  428.     }
  430.     public function getDependantOn(): ?string
  431.     {
  432.         return $this->dependantOn;
  433.     }
  435.     public function setDependantOn(?string $dependantOn)
  436.     {
  437.         $this->dependantOn = $dependantOn;
  439.         return $this;
  440.     }
  442.     public function getOffsetInDays(): ?int
  443.     {
  444.         return $this->offsetInDays;
  445.     }
  447.     public function setOffsetInDays(?int $offsetInDays): self
  448.     {
  449.         $this->offsetInDays = $offsetInDays;
  451.         return $this;
  452.     }
  454.     public function getOffsetTask(): ?self
  455.     {
  456.         return $this->offsetTask;
  457.     }
  459.     public function setOffsetTask(?self $offsetTask): self
  460.     {
  461.         $this->offsetTask = $offsetTask;
  463.         return $this;
  464.     }
  466.     /**
  467.      * @return Collection<int, self>
  468.      */
  469.     public function getOffsetTasks(): Collection
  470.     {
  471.         return $this->offsetTasks;
  472.     }
  474.     public function addOffsetTask(self $offsetTask): self
  475.     {
  476.         if (!$this->offsetTasks->contains($offsetTask)) {
  477.             $this->offsetTasks->add($offsetTask);
  478.             $offsetTask->setOffsetTask($this);
  479.         }
  481.         return $this;
  482.     }
  484.     public function removeOffsetTask(self $offsetTask): self
  485.     {
  486.         if ($this->offsetTasks->removeElement($offsetTask)) {
  487.             // set the owning side to null (unless already changed)
  488.             if ($offsetTask->getOffsetTask() === $this) {
  489.                 $offsetTask->setOffsetTask(null);
  490.             }
  491.         }
  493.         return $this;
  494.     }
  496.     public function getStartDate(): ?\DateTimeImmutable
  497.     {
  498.         return $this->startDate;
  499.     }
  501.     public function setStartDate(?\DateTimeImmutable $startDate): self
  502.     {
  503.         $this->startDate = $startDate;
  505.         return $this;
  506.     }
  508.     public function getDurationInDays(): ?int
  509.     {
  510.         return $this->durationInDays;
  511.     }
  513.     public function setDurationInDays(?int $durationInDays): self
  514.     {
  515.         $this->durationInDays = $durationInDays;
  517.         return $this;
  518.     }
  520.     /**
  521.      * @return Collection<int, ProjectDynamicField>
  522.      */
  523.     public function getProjectDynamicFields(): Collection
  524.     {
  525.         return $this->projectDynamicFields;
  526.     }
  528.     public function addProjectDynamicField(ProjectDynamicField $projectDynamicField): self
  529.     {
  530.         if (!$this->projectDynamicFields->contains($projectDynamicField)) {
  531.             $this->projectDynamicFields->add($projectDynamicField);
  532.             $projectDynamicField->setTask($this);
  533.         }
  535.         return $this;
  536.     }
  538.     public function removeProjectDynamicField(ProjectDynamicField $projectDynamicField): self
  539.     {
  540.         if ($this->projectDynamicFields->removeElement($projectDynamicField)) {
  541.             // set the owning side to null (unless already changed)
  542.             if ($projectDynamicField->getTask() === $this) {
  543.                 $projectDynamicField->setTask(null);
  544.             }
  545.         }
  547.         return $this;
  548.     }
  550. }