src/Entity/Project.php line 13

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\ProjectRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  10. /**
  11.  * @ORM\Entity(repositoryClass=ProjectRepository::class)
  12.  */
  13. class Project
  14. {
  15.     /**
  16.      * @ORM\Id
  17.      * @ORM\GeneratedValue
  18.      * @ORM\Column(type="integer")
  19.      */
  20.     private $id;
  22.     /**
  23.      * @ORM\Column(type="string", length=255)
  24.      */
  25.     private $name;
  27.     /**
  28.      * @ORM\Column(type="text", nullable=true)
  29.      */
  30.     private $description;
  32.     /**
  33.      * @ORM\ManyToOne(targetEntity=User::class)
  34.      * @ORM\JoinColumn(nullable=false)
  35.      */
  36.     private $project_manager;
  38.     /**
  39.      * @ORM\ManyToOne(targetEntity=Currency::class)
  40.      * @ORM\JoinColumn(nullable=false)
  41.      */
  42.     private $currency;
  44.     /**
  45.      * @ORM\Column(type="float")
  46.      */
  47.     private $amount;
  49.     /**
  50.      * @ORM\Column(type="date")
  51.      */
  52.     private $start_date;
  54.     /**
  55.      * @ORM\Column(type="date")
  56.      */
  57.     private $end_date;
  59.     /**
  60.      * @ORM\ManyToOne(targetEntity=Program::class, inversedBy="projects")
  61.      */
  62.     private $program;
  64.     /**
  65.      * @ORM\Column(type="text", nullable=true)
  66.      */
  67.     private $outcome;
  69.     /**
  70.      * @ORM\Column(type="integer")
  71.      */
  72.     private $status;
  74.     /**
  75.      * @ORM\ManyToOne(targetEntity=User::class)
  76.      * @ORM\JoinColumn(nullable=false)
  77.      */
  78.     private $created_by;
  80.     /**
  81.      * @ORM\Column(type="datetime")
  82.      */
  83.     private $created_At;
  85.     /**
  86.      * @ORM\OneToMany(targetEntity=ProjectVersion::class, mappedBy="project")
  87.      */
  88.     private $projectVersions;
  90.     /**
  91.      * @ORM\OneToMany(targetEntity=ProjectSponsor::class, mappedBy="project")
  92.      */
  93.     private $projectSponsors;
  95.     /**
  96.      * @ORM\OneToMany(targetEntity=ProjectResource::class, mappedBy="project")
  97.      */
  98.     private $projectResources;
  100.     /**
  101.      * @ORM\OneToMany(targetEntity=ProjectDeliverable::class, mappedBy="project")
  102.      */
  103.     private $projectDeliverables;
  105.     /**
  106.      * @ORM\OneToMany(targetEntity=ProjectMilestone::class, mappedBy="project")
  107.      */
  108.     private $projectMilestones;
  110.     /**
  111.      * @ORM\OneToMany(targetEntity=ProjectMemberHistory::class, mappedBy="project")
  112.      */
  113.     private $projectMemberHistories;
  115.     /**
  116.      * @ORM\OneToMany(targetEntity=ProjectMembers::class, mappedBy="project")
  117.      */
  118.     private $projectMembers;
  120.     /**
  121.      * @ORM\OneToMany(targetEntity=ProjectActivity::class, mappedBy="project")
  122.      */
  123.     private $projectActivities;
  125.     /**
  126.      * @ORM\OneToMany(targetEntity=ProjectCollaborationTopic::class, mappedBy="project")
  127.      */
  128.     private $projectCollaborationTopics;
  130.     /**
  131.      * @ORM\OneToMany(targetEntity=ProjectStructure::class, mappedBy="project")
  132.      */
  133.     private $projectStructures;
  135.     /**
  136.      * @ORM\Column(type="string", length=255, nullable=true)
  137.      */
  138.     private $baseline;
  140.     /**
  141.      * @ORM\ManyToOne(targetEntity=OrganizationUnit::class, inversedBy="projects")
  142.      */
  143.     private $unit;
  145.     /**
  146.      * @ORM\OneToMany(targetEntity=ActivityChat::class, mappedBy="project")
  147.      */
  148.     private $activityChats;
  150.     /**
  151.      * @ORM\OneToMany(targetEntity=ProjectPlanRevision::class, mappedBy="project")
  152.      */
  153.     private $projectPlanRevisions;
  155.     /**
  156.      * @ORM\OneToMany(targetEntity=ProjectPlanStatus::class, mappedBy="project")
  157.      */
  158.     private $projectPlanStatuses;
  160.     /**
  161.      * @ORM\Column(type="integer")
  162.      */
  163.     private $planned_value;
  165.     /**
  166.      * @ORM\OneToMany(targetEntity=ProjectPlanComment::class, mappedBy="project")
  167.      */
  168.     private $planComments;
  170.     /**
  171.      * @ORM\ManyToOne(targetEntity=Objective::class, inversedBy="projects")
  172.      * @ORM\JoinColumn(nullable=false)
  173.      */
  174.     private $objective;
  176.     /**
  177.      * @ORM\ManyToMany(targetEntity=Organization::class)
  178.      */
  179.     private $stakeholder;
  181.     /**
  182.      * @ORM\OneToMany(targetEntity=PlanModificationRequest::class, mappedBy="project")
  183.      */
  184.     private $planModificationRequests;
  186.     /**
  187.      * @ORM\Column(type="boolean", nullable=false)
  188.      */
  189.     private $active = true;
  191.     public function __construct()
  192.     {
  193.         $this->projectVersions = new ArrayCollection();
  194.         $this->projectSponsors = new ArrayCollection();
  195.         $this->projectResources = new ArrayCollection();
  196.         $this->projectDeliverables = new ArrayCollection();
  197.         $this->projectMilestones = new ArrayCollection();
  198.         $this->projectMemberHistories = new ArrayCollection();
  199.         $this->projectMembers = new ArrayCollection();
  200.         $this->projectActivities = new ArrayCollection();
  201.         $this->projectCollaborationTopics = new ArrayCollection();
  202.         $this->projectStructures = new ArrayCollection();
  203.         $this->activityChats = new ArrayCollection();
  204.         $this->projectPlanRevisions = new ArrayCollection();
  205.         $this->projectPlanStatuses = new ArrayCollection();
  206.         $this->planComments = new ArrayCollection();
  207.         $this->stakeholder = new ArrayCollection();
  208.         $this->planModificationRequests = new ArrayCollection();
  209.     }
  211.     public function getId(): ?int
  212.     {
  213.         return $this->id;
  214.     }
  216.     public function getName(): ?string
  217.     {
  218.         return $this->name;
  219.     }
  221.     public function setName(string $name): self
  222.     {
  223.         $this->name = $name;
  225.         return $this;
  226.     }
  228.     public function getDescription(): ?string
  229.     {
  230.         return $this->description;
  231.     }
  233.     public function setDescription(?string $description): self
  234.     {
  235.         $this->description = $description;
  237.         return $this;
  238.     }
  240.     public function getProjectManager(): ?User
  241.     {
  242.         return $this->project_manager;
  243.     }
  245.     public function setProjectManager(?User $project_manager): self
  246.     {
  247.         $this->project_manager = $project_manager;
  249.         return $this;
  250.     }
  252.     public function getCurrency(): ?Currency
  253.     {
  254.         return $this->currency;
  255.     }
  257.     public function setCurrency(?Currency $currency): self
  258.     {
  259.         $this->currency = $currency;
  261.         return $this;
  262.     }
  264.     public function getAmount(): ?float
  265.     {
  266.         return $this->amount;
  267.     }
  269.     public function setAmount(float $amount): self
  270.     {
  271.         $this->amount = $amount;
  273.         return $this;
  274.     }
  276.     public function getStartDate(): ?\DateTimeInterface
  277.     {
  278.         return $this->start_date;
  279.     }
  281.     public function setStartDate(\DateTimeInterface $start_date): self
  282.     {
  283.         $this->start_date = $start_date;
  285.         return $this;
  286.     }
  288.     public function getEndDate(): ?\DateTimeInterface
  289.     {
  290.         return $this->end_date;
  291.     }
  293.     public function setEndDate(\DateTimeInterface $end_date): self
  294.     {
  295.         $this->end_date = $end_date;
  297.         return $this;
  298.     }
  300.     public function getProgram(): ?Program
  301.     {
  302.         return $this->program;
  303.     }
  305.     public function setProgram(?Program $program): self
  306.     {
  307.         $this->program = $program;
  309.         return $this;
  310.     }
  312.     public function getOutcome(): ?string
  313.     {
  314.         return $this->outcome;
  315.     }
  317.     public function setOutcome(?string $outcome): self
  318.     {
  319.         $this->outcome = $outcome;
  321.         return $this;
  322.     }
  324.     public function getStatus(): ?int
  325.     {
  326.         return $this->status;
  327.     }
  329.     public function setStatus(int $status): self
  330.     {
  331.         $this->status = $status;
  333.         return $this;
  334.     }
  336.     public function getCreatedBy(): ?User
  337.     {
  338.         return $this->created_by;
  339.     }
  341.     public function setCreatedBy(?User $created_by): self
  342.     {
  343.         $this->created_by = $created_by;
  345.         return $this;
  346.     }
  348.     public function getCreatedAt(): ?\DateTimeInterface
  349.     {
  350.         return $this->created_At;
  351.     }
  353.     public function setCreatedAt(\DateTimeInterface $created_At): self
  354.     {
  355.         $this->created_At = $created_At;
  357.         return $this;
  358.     }
  360.     /**
  361.      * @return Collection|ProjectVersion[]
  362.      */
  363.     public function getProjectVersions(): Collection
  364.     {
  365.         return $this->projectVersions;
  366.     }
  368.     public function addProjectVersion(ProjectVersion $projectVersion): self
  369.     {
  370.         if (!$this->projectVersions->contains($projectVersion)) {
  371.             $this->projectVersions[] = $projectVersion;
  372.             $projectVersion->setProject($this);
  373.         }
  375.         return $this;
  376.     }
  378.     public function removeProjectVersion(ProjectVersion $projectVersion): self
  379.     {
  380.         if ($this->projectVersions->removeElement($projectVersion)) {
  381.             // set the owning side to null (unless already changed)
  382.             if ($projectVersion->getProject() === $this) {
  383.                 $projectVersion->setProject(null);
  384.             }
  385.         }
  387.         return $this;
  388.     }
  390.     public function __toString()
  391.     {
  392.         return $this->name;
  393.     }
  395.     /**
  396.      * @return Collection|ProjectSponsor[]
  397.      */
  398.     public function getProjectSponsors(): Collection
  399.     {
  400.         return $this->projectSponsors;
  401.     }
  403.     public function addProjectSponsor(ProjectSponsor $projectSponsor): self
  404.     {
  405.         if (!$this->projectSponsors->contains($projectSponsor)) {
  406.             $this->projectSponsors[] = $projectSponsor;
  407.             $projectSponsor->setProject($this);
  408.         }
  410.         return $this;
  411.     }
  413.     public function removeProjectSponsor(ProjectSponsor $projectSponsor): self
  414.     {
  415.         if ($this->projectSponsors->removeElement($projectSponsor)) {
  416.             // set the owning side to null (unless already changed)
  417.             if ($projectSponsor->getProject() === $this) {
  418.                 $projectSponsor->setProject(null);
  419.             }
  420.         }
  422.         return $this;
  423.     }
  425.     /**
  426.      * @return Collection|ProjectResource[]
  427.      */
  428.     public function getProjectResources(): Collection
  429.     {
  430.         return $this->projectResources;
  431.     }
  433.     public function addProjectResource(ProjectResource $projectResource): self
  434.     {
  435.         if (!$this->projectResources->contains($projectResource)) {
  436.             $this->projectResources[] = $projectResource;
  437.             $projectResource->setProject($this);
  438.         }
  440.         return $this;
  441.     }
  443.     public function removeProjectResource(ProjectResource $projectResource): self
  444.     {
  445.         if ($this->projectResources->removeElement($projectResource)) {
  446.             // set the owning side to null (unless already changed)
  447.             if ($projectResource->getProject() === $this) {
  448.                 $projectResource->setProject(null);
  449.             }
  450.         }
  452.         return $this;
  453.     }
  455.     /**
  456.      * @return Collection|ProjectDeliverable[]
  457.      */
  458.     public function getProjectDeliverables(): Collection
  459.     {
  460.         return $this->projectDeliverables;
  461.     }
  463.     public function addProjectDeliverable(ProjectDeliverable $projectDeliverable): self
  464.     {
  465.         if (!$this->projectDeliverables->contains($projectDeliverable)) {
  466.             $this->projectDeliverables[] = $projectDeliverable;
  467.             $projectDeliverable->setProject($this);
  468.         }
  470.         return $this;
  471.     }
  473.     public function removeProjectDeliverable(ProjectDeliverable $projectDeliverable): self
  474.     {
  475.         if ($this->projectDeliverables->removeElement($projectDeliverable)) {
  476.             // set the owning side to null (unless already changed)
  477.             if ($projectDeliverable->getProject() === $this) {
  478.                 $projectDeliverable->setProject(null);
  479.             }
  480.         }
  482.         return $this;
  483.     }
  485.     /**
  486.      * @return Collection|ProjectMilestone[]
  487.      */
  488.     public function getProjectMilestones(): Collection
  489.     {
  490.         return $this->projectMilestones;
  491.     }
  493.     public function addProjectMilestone(ProjectMilestone $projectMilestone): self
  494.     {
  495.         if (!$this->projectMilestones->contains($projectMilestone)) {
  496.             $this->projectMilestones[] = $projectMilestone;
  497.             $projectMilestone->setProject($this);
  498.         }
  500.         return $this;
  501.     }
  503.     public function removeProjectMilestone(ProjectMilestone $projectMilestone): self
  504.     {
  505.         if ($this->projectMilestones->removeElement($projectMilestone)) {
  506.             // set the owning side to null (unless already changed)
  507.             if ($projectMilestone->getProject() === $this) {
  508.                 $projectMilestone->setProject(null);
  509.             }
  510.         }
  512.         return $this;
  513.     }
  515.     /**
  516.      * @return Collection|ProjectMemberHistory[]
  517.      */
  518.     public function getProjectMemberHistories(): Collection
  519.     {
  520.         return $this->projectMemberHistories;
  521.     }
  523.     public function addProjectMemberHistory(ProjectMemberHistory $projectMemberHistory): self
  524.     {
  525.         if (!$this->projectMemberHistories->contains($projectMemberHistory)) {
  526.             $this->projectMemberHistories[] = $projectMemberHistory;
  527.             $projectMemberHistory->setProject($this);
  528.         }
  530.         return $this;
  531.     }
  533.     public function removeProjectMemberHistory(ProjectMemberHistory $projectMemberHistory): self
  534.     {
  535.         if ($this->projectMemberHistories->removeElement($projectMemberHistory)) {
  536.             // set the owning side to null (unless already changed)
  537.             if ($projectMemberHistory->getProject() === $this) {
  538.                 $projectMemberHistory->setProject(null);
  539.             }
  540.         }
  542.         return $this;
  543.     }
  545.     /**
  546.      * @return Collection|ProjectMembers[]
  547.      */
  548.     public function getProjectMembers(): Collection
  549.     {
  550.         return $this->projectMembers;
  551.     }
  553.     public function addProjectMember(ProjectMembers $projectMember): self
  554.     {
  555.         if (!$this->projectMembers->contains($projectMember)) {
  556.             $this->projectMembers[] = $projectMember;
  557.             $projectMember->setProject($this);
  558.         }
  560.         return $this;
  561.     }
  563.     public function removeProjectMember(ProjectMembers $projectMember): self
  564.     {
  565.         if ($this->projectMembers->removeElement($projectMember)) {
  566.             // set the owning side to null (unless already changed)
  567.             if ($projectMember->getProject() === $this) {
  568.                 $projectMember->setProject(null);
  569.             }
  570.         }
  572.         return $this;
  573.     }
  575.     /**
  576.      * @return Collection|ProjectActivity[]
  577.      */
  578.     public function getProjectActivities(): Collection
  579.     {
  580.         return $this->projectActivities;
  581.     }
  583.     public function addProjectActivity(ProjectActivity $projectActivity): self
  584.     {
  585.         if (!$this->projectActivities->contains($projectActivity)) {
  586.             $this->projectActivities[] = $projectActivity;
  587.             $projectActivity->setProject($this);
  588.         }
  590.         return $this;
  591.     }
  593.     public function removeProjectActivity(ProjectActivity $projectActivity): self
  594.     {
  595.         if ($this->projectActivities->removeElement($projectActivity)) {
  596.             // set the owning side to null (unless already changed)
  597.             if ($projectActivity->getProject() === $this) {
  598.                 $projectActivity->setProject(null);
  599.             }
  600.         }
  602.         return $this;
  603.     }
  605.     /**
  606.      * @return Collection|ProjectCollaborationTopic[]
  607.      */
  608.     public function getProjectCollaborationTopics(): Collection
  609.     {
  610.         return $this->projectCollaborationTopics;
  611.     }
  613.     public function addProjectCollaborationTopic(ProjectCollaborationTopic $projectCollaborationTopic): self
  614.     {
  615.         if (!$this->projectCollaborationTopics->contains($projectCollaborationTopic)) {
  616.             $this->projectCollaborationTopics[] = $projectCollaborationTopic;
  617.             $projectCollaborationTopic->setProject($this);
  618.         }
  620.         return $this;
  621.     }
  623.     public function removeProjectCollaborationTopic(ProjectCollaborationTopic $projectCollaborationTopic): self
  624.     {
  625.         if ($this->projectCollaborationTopics->removeElement($projectCollaborationTopic)) {
  626.             // set the owning side to null (unless already changed)
  627.             if ($projectCollaborationTopic->getProject() === $this) {
  628.                 $projectCollaborationTopic->setProject(null);
  629.             }
  630.         }
  632.         return $this;
  633.     }
  635.     /**
  636.      * @return Collection|ProjectStructure[]
  637.      */
  638.     public function getProjectStructures(): Collection
  639.     {
  640.         return $this->projectStructures;
  641.     }
  643.     public function addProjectStructure(ProjectStructure $projectStructure): self
  644.     {
  645.         if (!$this->projectStructures->contains($projectStructure)) {
  646.             $this->projectStructures[] = $projectStructure;
  647.             $projectStructure->setProject($this);
  648.         }
  650.         return $this;
  651.     }
  653.     public function removeProjectStructure(ProjectStructure $projectStructure): self
  654.     {
  655.         if ($this->projectStructures->removeElement($projectStructure)) {
  656.             // set the owning side to null (unless already changed)
  657.             if ($projectStructure->getProject() === $this) {
  658.                 $projectStructure->setProject(null);
  659.             }
  660.         }
  662.         return $this;
  663.     }
  665.     public function getBaseline(): ?string
  666.     {
  667.         return $this->baseline;
  668.     }
  670.     public function setBaseline(?string $baseline): self
  671.     {
  672.         $this->baseline = $baseline;
  674.         return $this;
  675.     }
  677.     public function getUnit(): ?OrganizationUnit
  678.     {
  679.         return $this->unit;
  680.     }
  682.     public function setUnit(?OrganizationUnit $unit): self
  683.     {
  684.         $this->unit = $unit;
  686.         return $this;
  687.     }
  689.     /**
  690.      * @return Collection|ActivityChat[]
  691.      */
  692.     public function getActivityChats(): Collection
  693.     {
  694.         return $this->activityChats;
  695.     }
  697.     public function addActivityChat(ActivityChat $activityChat): self
  698.     {
  699.         if (!$this->activityChats->contains($activityChat)) {
  700.             $this->activityChats[] = $activityChat;
  701.             $activityChat->setProject($this);
  702.         }
  704.         return $this;
  705.     }
  707.     public function removeActivityChat(ActivityChat $activityChat): self
  708.     {
  709.         if ($this->activityChats->removeElement($activityChat)) {
  710.             // set the owning side to null (unless already changed)
  711.             if ($activityChat->getProject() === $this) {
  712.                 $activityChat->setProject(null);
  713.             }
  714.         }
  716.         return $this;
  717.     }
  719.     /**
  720.      * @return Collection|ProjectPlanRevision[]
  721.      */
  722.     public function getProjectPlanRevisions(): Collection
  723.     {
  724.         return $this->projectPlanRevisions;
  725.     }
  727.     public function addProjectPlanRevision(ProjectPlanRevision $projectPlanRevision): self
  728.     {
  729.         if (!$this->projectPlanRevisions->contains($projectPlanRevision)) {
  730.             $this->projectPlanRevisions[] = $projectPlanRevision;
  731.             $projectPlanRevision->setProject($this);
  732.         }
  734.         return $this;
  735.     }
  737.     public function removeProjectPlanRevision(ProjectPlanRevision $projectPlanRevision): self
  738.     {
  739.         if ($this->projectPlanRevisions->removeElement($projectPlanRevision)) {
  740.             // set the owning side to null (unless already changed)
  741.             if ($projectPlanRevision->getProject() === $this) {
  742.                 $projectPlanRevision->setProject(null);
  743.             }
  744.         }
  746.         return $this;
  747.     }
  749.     /**
  750.      * @return Collection|ProjectPlanStatus[]
  751.      */
  752.     public function getProjectPlanStatuses(): Collection
  753.     {
  754.         return $this->projectPlanStatuses;
  755.     }
  757.     public function addProjectPlanStatus(ProjectPlanStatus $projectPlanStatus): self
  758.     {
  759.         if (!$this->projectPlanStatuses->contains($projectPlanStatus)) {
  760.             $this->projectPlanStatuses[] = $projectPlanStatus;
  761.             $projectPlanStatus->setProject($this);
  762.         }
  764.         return $this;
  765.     }
  767.     public function removeProjectPlanStatus(ProjectPlanStatus $projectPlanStatus): self
  768.     {
  769.         if ($this->projectPlanStatuses->removeElement($projectPlanStatus)) {
  770.             // set the owning side to null (unless already changed)
  771.             if ($projectPlanStatus->getProject() === $this) {
  772.                 $projectPlanStatus->setProject(null);
  773.             }
  774.         }
  776.         return $this;
  777.     }
  779.     public function getPlannedValue(): ?int
  780.     {
  781.         return $this->planned_value;
  782.     }
  784.     public function setPlannedValue(int $planned_value): self
  785.     {
  786.         $this->planned_value = $planned_value;
  788.         return $this;
  789.     }
  791.     /**
  792.      * @return Collection|ProjectPlanComment[]
  793.      */
  794.     public function getPlanComments(): Collection
  795.     {
  796.         return $this->planComments;
  797.     }
  799.     public function addPlanComment(ProjectPlanComment $planComment): self
  800.     {
  801.         if (!$this->planComments->contains($planComment)) {
  802.             $this->planComments[] = $planComment;
  803.             $planComment->setProject($this);
  804.         }
  806.         return $this;
  807.     }
  809.     public function removePlanComment(ProjectPlanComment $planComment): self
  810.     {
  811.         if ($this->planComments->removeElement($planComment)) {
  812.             // set the owning side to null (unless already changed)
  813.             if ($planComment->getProject() === $this) {
  814.                 $planComment->setProject(null);
  815.             }
  816.         }
  818.         return $this;
  819.     }
  821.     public function getObjective(): ?Objective
  822.     {
  823.         return $this->objective;
  824.     }
  826.     public function setObjective(?Objective $objective): self
  827.     {
  828.         $this->objective = $objective;
  830.         return $this;
  831.     }
  833.     /**
  834.      * @return Collection|Organization[]
  835.      */
  836.     public function getStakeholder(): Collection
  837.     {
  838.         return $this->stakeholder;
  839.     }
  841.     public function addStakeholder(Organization $stakeholder): self
  842.     {
  843.         if (!$this->stakeholder->contains($stakeholder)) {
  844.             $this->stakeholder[] = $stakeholder;
  845.         }
  847.         return $this;
  848.     }
  850.     public function removeStakeholder(Organization $stakeholder): self
  851.     {
  852.         $this->stakeholder->removeElement($stakeholder);
  854.         return $this;
  855.     }
  857.     /**
  858.      * @return Collection|PlanModificationRequest[]
  859.      */
  860.     public function getPlanModificationRequests(): Collection
  861.     {
  862.         return $this->planModificationRequests;
  863.     }
  865.     public function addPlanModificationRequest(PlanModificationRequest $planModificationRequest): self
  866.     {
  867.         if (!$this->planModificationRequests->contains($planModificationRequest)) {
  868.             $this->planModificationRequests[] = $planModificationRequest;
  869.             $planModificationRequest->setProject($this);
  870.         }
  872.         return $this;
  873.     }
  875.     public function removePlanModificationRequest(PlanModificationRequest $planModificationRequest): self
  876.     {
  877.         if ($this->planModificationRequests->removeElement($planModificationRequest)) {
  878.             // set the owning side to null (unless already changed)
  879.             if ($planModificationRequest->getProject() === $this) {
  880.                 $planModificationRequest->setProject(null);
  881.             }
  882.         }
  884.         return $this;
  885.     }
  887.     public function isActive(): ?bool
  888.     {
  889.         return $this->active;
  890.     }
  892.     public function setActive(?bool $active): self
  893.     {
  894.         $this->active = $active;
  896.         return $this;
  897.     }
  898. }