src/Entity/Item.php line 92

  1. <?php
  3. declare(strict_types=1);
  5. namespace App\Entity;
  7. use ApiPlatform\Core\Annotation\ApiResource;
  8. use ApiPlatform\Core\Annotation\ApiSubresource;
  9. use App\Controller\Api\Action\Item\ItemDeleteAction;
  10. use App\Controller\Api\Action\Item\ItemDuplicateAction;
  11. use App\Controller\Api\Action\Item\ItemToChildAction;
  12. use App\Controller\Api\Action\Item\ItemToParentAction;
  13. use App\Controller\Api\Action\Item\ItemChildrenBudgetAction;
  14. use App\Repository\ItemRepository;
  15. use App\Validator\Constraint as CustomValidator;
  16. use DateTime;
  17. use Doctrine\Common\Collections\ArrayCollection;
  18. use Doctrine\ORM\Mapping as ORM;
  19. use Symfony\Component\Validator\Constraints as Assert;
  21. #[ORM\Entity(
  22.     repositoryClass: ItemRepository::class
  23. )]
  24. #[ORM\Table(
  25.     name: 'item'
  26. )]
  27. #[ApiResource(
  28.     collectionOperations: [
  29.         'post' => [
  30.             'validation_groups' => [
  31.                 'create'
  32.             ]
  33.         ]
  34.     ],
  35.     itemOperations: [
  36.         'get',
  37.         'put' => [
  38.             'validation_groups' => [
  39.                 'create'
  40.             ]
  41.         ],
  42.         'delete' => [
  43.             'access_control' => 'is_granted("ROLE_USER")',
  44.             'controller' => ItemDeleteAction::class
  45.         ],
  46.         'duplicate' => [
  47.             'access_control' => 'is_granted("ROLE_USER")',
  48.             'controller' => ItemDuplicateAction::class,
  49.             'method' => 'POST',
  50.             'path' => '/items/duplicate/{id}'
  51.         ],
  52.         'to_child' => [
  53.             'access_control' => 'is_granted("ROLE_USER")',
  54.             'controller' => ItemToChildAction::class,
  55.             'method' => 'POST',
  56.             'path' => '/items/to-child/{id}'
  57.         ],
  58.         'to_parent' => [
  59.             'access_control' => 'is_granted("ROLE_USER")',
  60.             'controller' => ItemToParentAction::class,
  61.             'method' => 'PUT',
  62.             'path' => '/items/to-parent/{id}'
  63.         ],
  64.         'children_budget' => [
  65.             'access_control' => 'is_granted("ROLE_USER")',
  66.             'controller' => ItemChildrenBudgetAction::class,
  67.             'method' => 'GET',
  68.             'path' => '/items/budget/{id}'
  69.         ]
  70.     ]
  71. )]
  72. #[CustomValidator\ItemPlannedStartDate(
  73.     message: 'item.plannedStartDate',
  74.     fields: ['plannedStartDate'],
  75.     groups: ['create']
  76. )]
  77. #[CustomValidator\ItemPlannedEndDate(
  78.     message: 'item.plannedEndDate',
  79.     fields: ['plannedEndDate'],
  80.     groups: ['create']
  81. )]
  82. #[CustomValidator\ItemRealizedStartDate(
  83.     message: 'item.realizedStartDate',
  84.     fields: ['realizedStartDate'],
  85.     groups: ['create']
  86. )]
  87. #[CustomValidator\ItemRealizedEndDate(
  88.     message: 'item.realizedEndDate',
  89.     fields: ['realizedEndDate'],
  90.     groups: ['create']
  91. )]
  92. class Item implements CollectionItemInterface
  93. {
  94.     #[ORM\Id]
  95.     #[ORM\GeneratedValue]
  96.     #[ORM\Column(
  97.         type: 'integer'
  98.     )]
  99.     private ?int $id = null;
  101.     #[ORM\Column(
  102.         name: 'date_created',
  103.         type: 'datetime',
  104.         nullable: true
  105.     )]
  106.     private ?DateTime $dateCreated = null;
  108.     #[ORM\Column(
  109.         name: 'date_changed',
  110.         type: 'datetime',
  111.         nullable: true
  112.     )]
  113.     private ?DateTime $dateChanged = null;
  115.     #[ORM\ManyToOne(
  116.         targetEntity: User::class,
  117.         cascade: ['persist']
  118.     )]
  119.     #[ORM\JoinColumn(
  120.         name: 'user_created'
  121.     )]
  122.     private ?User $userCreated = null;
  124.     #[ORM\ManyToOne(
  125.         targetEntity: User::class,
  126.         cascade: ['persist']
  127.     )]
  128.     #[ORM\JoinColumn(
  129.         name: 'user_changed'
  130.     )]
  131.     private ?User $userChanged = null;
  133.     #[ORM\Column(
  134.         name: 'active',
  135.         type: 'boolean',
  136.         options: ['default' => true]
  137.     )]
  138.     private bool $active = true;
  140.     #[ORM\Column(
  141.         name: 'visible_in_the_calendar',
  142.         type: 'boolean',
  143.         options: ['default' => true]
  144.     )]
  145.     private bool $visibleInTheCalendar = true;
  147.     #[ORM\Column(
  148.         name: 'name',
  149.         type: 'string',
  150.         length: 181,
  151.         nullable: true
  152.     )]
  153.     #[Assert\NotBlank(
  154.         groups: ['create']
  155.     )]
  156.     private ?string $name = null;
  158.     #[ORM\Column(
  159.         name: 'sequence',
  160.         type: 'integer',
  161.         nullable: true
  162.     )]
  163.     private ?int $sequence = null;
  165.     #[ORM\Column(
  166.         name: 'description',
  167.         type: 'text',
  168.         nullable: true
  169.     )]
  170.     private ?string $description = null;
  172.     #[ORM\Column(
  173.         name: 'planned_start_date',
  174.         type: 'datetime',
  175.         nullable: true
  176.     )]
  177.     #[Assert\NotBlank(
  178.         groups: ['create']
  179.     )]
  180.     private ?DateTime $plannedStartDate = null;
  182.     #[ORM\Column(
  183.         name: 'planned_end_date',
  184.         type: 'datetime',
  185.         nullable: true
  186.     )]
  187.     #[Assert\NotBlank(
  188.         groups: ['create']
  189.     )]
  190.     #[Assert\GreaterThanOrEqual(
  191.         propertyPath: 'plannedStartDate',
  192.         message: 'item.plannedEndDateLessThanStartDate',
  193.         groups: ['create']
  194.     )]
  195.     private ?DateTime $plannedEndDate = null;
  197.     #[ORM\Column(
  198.         name: 'realized_start_date',
  199.         type: 'datetime',
  200.         nullable: true
  201.     )]
  202.     private ?DateTime $realizedStartDate = null;
  204.     #[ORM\Column(
  205.         name: 'realized_end_date',
  206.         type: 'datetime',
  207.         nullable: true
  208.     )]
  209.     #[Assert\GreaterThanOrEqual(
  210.         propertyPath: 'realizedStartDate',
  211.         message: 'item.realizedEndDateLessThanStartDate',
  212.         groups: ['create']
  213.     )]
  214.     private ?DateTime $realizedEndDate = null;
  216.     #[ORM\Column(
  217.         name: 'budget',
  218.         type: 'decimal',
  219.         precision: 20,
  220.         scale: 2,
  221.         nullable: true
  222.     )]
  223.     #[Assert\NotBlank(
  224.         groups: ['create']
  225.     )]
  226.     #[CustomValidator\PriceFormat(
  227.         groups: ['create'],
  228.         message: 'item.invalidFormat'
  229.     )]
  230.     private ?string $budget = null;
  232.     #[ORM\Column(
  233.         name: 'external_budget',
  234.         type: 'decimal',
  235.         precision: 20,
  236.         scale: 2,
  237.         nullable: true
  238.     )]
  239.     #[Assert\NotBlank(
  240.         groups: ['create']
  241.     )]
  242.     #[CustomValidator\PriceFormat(
  243.         groups: ['create'],
  244.         message: 'item.invalidFormat'
  245.     )]
  246.     private ?string $externalBudget = null;
  248.     #[ORM\ManyToOne(
  249.         targetEntity: Project::class,
  250.         cascade: ['persist'],
  251.         inversedBy: 'items'
  252.     )]
  253.     #[ORM\JoinColumn(
  254.         name: 'project',
  255.         nullable: true,
  256.         onDelete: 'CASCADE'
  257.     )]
  258.     #[ApiSubresource]
  259.     private ?Project $project = null;
  261.     #[ORM\ManyToOne(
  262.         targetEntity: Item::class,
  263.         cascade: ['persist'],
  264.         inversedBy: 'children'
  265.     )]
  266.     #[ORM\JoinColumn(
  267.         name: 'parent',
  268.         nullable: true,
  269.         onDelete: 'CASCADE'
  270.     )]
  271.     #[ApiSubresource]
  272.     private ?Item $parent = null;
  274.     #[ORM\OneToMany(
  275.         mappedBy: 'item',
  276.         targetEntity: ItemUser::class,
  277.         cascade: ['persist', 'remove'],
  278.         fetch: 'EXTRA_LAZY',
  279.         orphanRemoval: true
  280.     )]
  281.     private ?iterable $users;
  283.     #[ORM\OneToMany(
  284.         mappedBy: 'item',
  285.         targetEntity: ItemDocument::class,
  286.         cascade: ['persist', 'remove'],
  287.         fetch: 'EXTRA_LAZY',
  288.         orphanRemoval: true
  289.     )]
  290.     private ?iterable $document;
  292.     #[ORM\OneToMany(
  293.         mappedBy: 'item',
  294.         targetEntity: ItemLabel::class,
  295.         cascade: ['persist', 'remove'],
  296.         fetch: 'EXTRA_LAZY',
  297.         orphanRemoval: true
  298.     )]
  299.     private ?iterable $label;
  301.     #[ORM\OneToMany(
  302.         mappedBy: 'item',
  303.         targetEntity: ItemIndicator::class,
  304.         cascade: ['persist'],
  305.         fetch: 'EXTRA_LAZY',
  306.         orphanRemoval: true
  307.     )]
  308.     private ?iterable $indicators;
  310.     #[ORM\OneToMany(
  311.         mappedBy: 'parent',
  312.         targetEntity: Item::class,
  313.         cascade: ['persist', 'remove'],
  314.         fetch: 'EXTRA_LAZY',
  315.         orphanRemoval: true
  316.     )]
  317.     private ?iterable $children;
  319.     public function __construct()
  320.     {
  321.         $this->users = new ArrayCollection();
  322.         $this->document = new ArrayCollection();
  323.         $this->label = new ArrayCollection();
  324.         $this->indicators = new ArrayCollection();
  325.         $this->children = new ArrayCollection();
  326.     }
  328.     public function getId(): ?int
  329.     {
  330.         return $this->id;
  331.     }
  333.     public function setId($id): self
  334.     {
  335.         $this->id = $id;
  337.         return $this;
  338.     }
  340.     public function getDateCreated(): ?DateTime
  341.     {
  342.         return $this->dateCreated;
  343.     }
  345.     public function setDateCreated(?DateTime $dateCreated): self
  346.     {
  347.         $this->dateCreated = $dateCreated;
  349.         return $this;
  350.     }
  352.     public function getDateChanged(): ?DateTime
  353.     {
  354.         return $this->dateChanged;
  355.     }
  357.     public function setDateChanged(?DateTime $dateChanged): self
  358.     {
  359.         $this->dateChanged = $dateChanged;
  361.         return $this;
  362.     }
  364.     public function getUserCreated(): ?User
  365.     {
  366.         return $this->userCreated;
  367.     }
  369.     public function setUserCreated(?User $userCreated): self
  370.     {
  371.         $this->userCreated = $userCreated;
  373.         return $this;
  374.     }
  376.     public function getUserChanged(): ?User
  377.     {
  378.         return $this->userChanged;
  379.     }
  381.     public function setUserChanged(?User $userChanged): self
  382.     {
  383.         $this->userChanged = $userChanged;
  385.         return $this;
  386.     }
  388.     public function isActive(): bool
  389.     {
  390.         return $this->active;
  391.     }
  393.     public function setActive(bool $active): void
  394.     {
  395.         $this->active = $active;
  396.     }
  398.     public function isVisibleInTheCalendar(): bool
  399.     {
  400.         return $this->visibleInTheCalendar;
  401.     }
  403.     public function setVisibleInTheCalendar(bool $visibleInTheCalendar): void
  404.     {
  405.         $this->visibleInTheCalendar = $visibleInTheCalendar;
  406.     }
  408.     public function getName(): ?string
  409.     {
  410.         return $this->name;
  411.     }
  413.     public function setName(?string $name): self
  414.     {
  415.         $this->name = $name;
  417.         return $this;
  418.     }
  420.     public function getSequence(): ?int
  421.     {
  422.         return $this->sequence;
  423.     }
  425.     public function setSequence(?int $sequence): self
  426.     {
  427.         $this->sequence = $sequence;
  429.         return $this;
  430.     }
  432.     public function getDescription(): ?string
  433.     {
  434.         return $this->description;
  435.     }
  437.     public function setDescription(?string $description): self
  438.     {
  439.         $this->description = $description;
  441.         return $this;
  442.     }
  444.     public function getPlannedStartDate(): ?DateTime
  445.     {
  446.         return $this->plannedStartDate;
  447.     }
  449.     public function setPlannedStartDate(?DateTime $plannedStartDate): self
  450.     {
  451.         $this->plannedStartDate = $plannedStartDate;
  453.         return $this;
  454.     }
  456.     public function getPlannedEndDate(): ?DateTime
  457.     {
  458.         return $this->plannedEndDate;
  459.     }
  461.     public function setPlannedEndDate(?DateTime $plannedEndDate): self
  462.     {
  463.         $this->plannedEndDate = $plannedEndDate;
  465.         return $this;
  466.     }
  468.     public function getRealizedStartDate(): ?DateTime
  469.     {
  470.         return $this->realizedStartDate;
  471.     }
  473.     public function setRealizedStartDate(?DateTime $realizedStartDate): self
  474.     {
  475.         $this->realizedStartDate = $realizedStartDate;
  477.         return $this;
  478.     }
  480.     public function getRealizedEndDate(): ?DateTime
  481.     {
  482.         return $this->realizedEndDate;
  483.     }
  485.     public function setRealizedEndDate(?DateTime $realizedEndDate): self
  486.     {
  487.         $this->realizedEndDate = $realizedEndDate;
  489.         return $this;
  490.     }
  492.     public function getBudget(): ?string
  493.     {
  494.         if (
  495.             $this->budget
  496.             &&
  497.             str_contains($this->budget, ',')
  498.         ) {
  499.             return $this->budget;
  500.         }
  502.         return $this->budget ? number_format((float) $this->budget, 2, ',', '.') : null;
  503.     }
  505.     public function getRealBudget(): ?string
  506.     {
  507.         return $this->budget;
  508.     }
  510.     public function setBudget(?string $budget): self
  511.     {
  512.         $this->budget = $budget;
  514.         return $this;
  515.     }
  517.     public function getExternalBudget(): ?string
  518.     {
  519.         if (
  520.             $this->externalBudget
  521.             &&
  522.             str_contains($this->externalBudget, ',')
  523.         ) {
  524.             return $this->externalBudget;
  525.         }
  527.         return $this->externalBudget ? number_format((float) $this->externalBudget, 2, ',', '.') : null;
  528.     }
  530.     public function getRealExternalBudget(): ?string
  531.     {
  532.         return $this->externalBudget;
  533.     }
  535.     public function setExternalBudget(?string $externalBudget): self
  536.     {
  537.         $this->externalBudget = $externalBudget;
  539.         return $this;
  540.     }
  542.     public function getProject(): ?Project
  543.     {
  544.         return $this->project;
  545.     }
  547.     public function setProject(?Project $project): self
  548.     {
  549.         $this->project = $project;
  551.         return $this;
  552.     }
  554.     public function getParent(): ?Item
  555.     {
  556.         return $this->parent;
  557.     }
  559.     public function setParent(?Item $parent): self
  560.     {
  561.         $this->parent = $parent;
  563.         return $this;
  564.     }
  566.     public function getChildren(): ?iterable
  567.     {
  568.         return $this->children;
  569.     }
  571.     public function getUsers(): iterable
  572.     {
  573.         return $this->users;
  574.     }
  576.     public function addUser(ItemUser $itemUser): void
  577.     {
  578.         if ($this->users->contains($itemUser)) {
  579.             return;
  580.         }
  581.         $this->users[] = $itemUser;
  583.         $itemUser->setItem($this);
  584.     }
  586.     public function cloneUser(ItemUser $itemUser): void
  587.     {
  588.         if ($this->users->contains($itemUser)) {
  589.             return;
  590.         }
  591.         $clonedUser = clone $itemUser;
  593.         $this->users[] = $clonedUser;
  595.         $clonedUser->setItem($this);
  596.     }
  598.     public function removeUser(ItemUser $itemUser): void
  599.     {
  600.         if (!$this->users->contains($itemUser)) {
  601.             return;
  602.         }
  603.         $this->users->removeElement($itemUser);
  605.         $itemUser->setItem(null);
  606.     }
  608.     public function getDocument(): iterable
  609.     {
  610.         return $this->document;
  611.     }
  613.     public function addDocument(ItemDocument $itemDocument): void
  614.     {
  615.         if ($this->document->contains($itemDocument)) {
  616.             return;
  617.         }
  618.         $this->document[] = $itemDocument;
  620.         $itemDocument->setItem($this);
  621.     }
  624.     public function cloneDocument(ItemDocument $itemDocument): void
  625.     {
  626.         if ($this->document->contains($itemDocument)) {
  627.             return;
  628.         }
  629.         $clonedDocument = clone $itemDocument;
  631.         $this->document[] = $clonedDocument;
  633.         $clonedDocument->setItem($this);
  634.     }
  636.     public function removeDocument(ItemDocument $itemDocument): void
  637.     {
  638.         if (!$this->document->contains($itemDocument)) {
  639.             return;
  640.         }
  641.         $this->document->removeElement($itemDocument);
  643.         $itemDocument->setItem(null);
  644.     }
  646.     public function getLabel(): iterable
  647.     {
  648.         return $this->label;
  649.     }
  651.     public function addLabel(ItemLabel $itemLabel): void
  652.     {
  653.         if ($this->label->contains($itemLabel)) {
  654.             return;
  655.         }
  656.         $this->label[] = $itemLabel;
  658.         $itemLabel->setItem($this);
  659.     }
  661.     public function cloneLabel(ItemLabel $itemLabel): void
  662.     {
  663.         if ($this->label->contains($itemLabel)) {
  664.             return;
  665.         }
  666.         $clonedLabel = clone $itemLabel;
  668.         $this->label[] = $clonedLabel;
  670.         $clonedLabel->setItem($this);
  671.     }
  673.     public function removeLabel(ItemLabel $itemLabel): void
  674.     {
  675.         if (!$this->label->contains($itemLabel)) {
  676.             return;
  677.         }
  678.         $this->label->removeElement($itemLabel);
  680.         $itemLabel->setItem(null);
  681.     }
  683.     public function getIndicators(): iterable
  684.     {
  685.         return $this->indicators;
  686.     }
  688.     public function addIndicator(ItemIndicator $itemIndicator): void
  689.     {
  690.         if ($this->indicators->contains($itemIndicator)) {
  691.             return;
  692.         }
  693.         $this->indicators[] = $itemIndicator;
  695.         $itemIndicator->setItem($this);
  696.     }
  698.     public function cloneIndicator(ItemIndicator $itemIndicator): void
  699.     {
  700.         if ($this->indicators->contains($itemIndicator)) {
  701.             return;
  702.         }
  703.         $clonedIndicator = clone $itemIndicator;
  705.         $this->indicators[] = $clonedIndicator;
  707.         $clonedIndicator->setItem($this);
  708.     }
  710.     public function removeIndicator(ItemIndicator $itemIndicator): void
  711.     {
  712.         if (!$this->indicators->contains($itemIndicator)) {
  713.             return;
  714.         }
  715.         $this->indicators->removeElement($itemIndicator);
  717.         $itemIndicator->setItem(null);
  718.     }
  719. }