src/Entity/Expediting/Repacking.php line 24

  1. <?php
  3. namespace App\Entity\Expediting;
  5. use ApiPlatform\Metadata\ApiProperty;
  6. use App\Doctrine\Type\Expediting\RepackingMotivation;
  7. use App\Entity\Common as Common;
  8. use App\Entity\Inventory\PackageMovement;
  9. use App\Validator\IsValidEnumArray\IsValidEnumArray;
  10. use DateTimeInterface;
  11. use Doctrine\Common\Collections\ArrayCollection;
  12. use Doctrine\Common\Collections\Collection;
  13. use Doctrine\DBAL\Types\Types;
  14. use Doctrine\ORM\Mapping as ORM;
  15. use Symfony\Component\Serializer\Annotation\Ignore;
  16. use Symfony\Component\Uid\Ulid;
  17. use Symfony\Component\Validator\Constraints as Assert;
  19. #[ORM\Table(name: 'expediting_repacking')]
  20. #[ORM\Index(columns: ['created_by'], name: 'expediting_repacking_created_by_idx')]
  21. #[ORM\Index(columns: ['updated_by'], name: 'expediting_repacking_updated_by_idx')]
  22. #[ORM\UniqueConstraint(name: 'expediting_repacking_identifier_key', columns: ['identifier'])]
  23. #[ORM\Entity]
  24. class Repacking
  25. {
  26.     use Common\Blameable;
  27.     use Common\Trackable;
  29.     #[ORM\Id]
  30.     #[ORM\GeneratedValue(strategy: 'IDENTITY')]
  31.     #[ORM\SequenceGenerator(sequenceName: 'expediting_repacking_id_seq')]
  32.     #[ORM\Column(type: Types::INTEGER)]
  33.     #[ApiProperty(identifier: false)]
  34.     private ?int $id = null;
  36.     #[Assert\Ulid]
  37.     #[Assert\NotNull]
  38.     #[ORM\Column(type: 'ulid', unique: true)]
  39.     #[ApiProperty(identifier: true)]
  40.     private ?Ulid $identifier = null;
  42.     /** @var Collection<int, Package> */
  43.     #[ORM\OneToMany(mappedBy: 'destinationRepacking', targetEntity: Package::class)]
  44.     private Collection $inputs;
  46.     /** @var Collection<int, Package> */
  47.     #[ORM\OneToMany(mappedBy: 'sourceRepacking', targetEntity: Package::class)]
  48.     private Collection $outputs;
  50.     #[Assert\Type(type: DateTimeInterface::class)]
  51.     #[ORM\Column(type: Types::DATETIMETZ_MUTABLE, nullable: false)]
  52.     private ?DateTimeInterface $completedAt = null;
  54.     #[Assert\NotNull]
  55.     #[IsValidEnumArray(enum: RepackingMotivation::class)]
  56.     #[ORM\Column(type: Types::STRING, nullable: false, enumType: RepackingMotivation::class)]
  57.     private ?RepackingMotivation $motivation = null;
  59.     /** @var Collection<int, PackageMovement> */
  60.     #[ORM\OneToMany(mappedBy: 'repacking', targetEntity: PackageMovement::class)]
  61.     #[Ignore]
  62.     private Collection $movements;
  64.     public function __construct()
  65.     {
  66.         $this->identifier = new Ulid();
  67.         $this->inputs = new ArrayCollection();
  68.         $this->outputs = new ArrayCollection();
  69.         $this->movements = new ArrayCollection();
  70.     }
  72.     public function getId(): ?int
  73.     {
  74.         return $this->id;
  75.     }
  77.     public function getIdentifier(): ?Ulid
  78.     {
  79.         return $this->identifier;
  80.     }
  82.     public function setIdentifier(Ulid $identifier): self
  83.     {
  84.         $this->identifier = $identifier;
  86.         return $this;
  87.     }
  89.     public function getCompletedAt(): ?\DateTimeInterface
  90.     {
  91.         return $this->completedAt;
  92.     }
  94.     public function setCompletedAt(\DateTimeInterface $completedAt): static
  95.     {
  96.         $this->completedAt = $completedAt;
  98.         return $this;
  99.     }
  101.     public function getMotivation(): ?RepackingMotivation
  102.     {
  103.         return $this->motivation;
  104.     }
  106.     public function setMotivation(RepackingMotivation $motivation): static
  107.     {
  108.         $this->motivation = $motivation;
  110.         return $this;
  111.     }
  113.     /**
  114.      * @return Collection<int, Package>
  115.      */
  116.     public function getInputs(): Collection
  117.     {
  118.         return $this->inputs;
  119.     }
  121.     public function addInput(Package $input): static
  122.     {
  123.         if (!$this->inputs->contains($input)) {
  124.             $this->inputs->add($input);
  125.             $input->setDestinationRepacking($this);
  126.         }
  128.         return $this;
  129.     }
  131.     public function removeInput(Package $input): static
  132.     {
  133.         if ($this->inputs->removeElement($input)) {
  134.             // set the owning side to null (unless already changed)
  135.             if ($input->getDestinationRepacking() === $this) {
  136.                 $input->setDestinationRepacking(null);
  137.             }
  138.         }
  140.         return $this;
  141.     }
  143.     /**
  144.      * @return Collection<int, Package>
  145.      */
  146.     public function getOutputs(): Collection
  147.     {
  148.         return $this->outputs;
  149.     }
  151.     public function addOutput(Package $output): static
  152.     {
  153.         if (!$this->outputs->contains($output)) {
  154.             $this->outputs->add($output);
  155.             $output->setSourceRepacking($this);
  156.         }
  158.         return $this;
  159.     }
  161.     public function removeOutput(Package $output): static
  162.     {
  163.         if ($this->outputs->removeElement($output)) {
  164.             // set the owning side to null (unless already changed)
  165.             if ($output->getSourceRepacking() === $this) {
  166.                 $output->setSourceRepacking(null);
  167.             }
  168.         }
  170.         return $this;
  171.     }
  173.     /**
  174.      * @return Collection<int, PackageMovement>
  175.      */
  176.     public function getMovements(): Collection
  177.     {
  178.         return $this->movements;
  179.     }
  181.     public function addMovement(PackageMovement $movement): static
  182.     {
  183.         if (!$this->movements->contains($movement)) {
  184.             $this->movements->add($movement);
  185.             $movement->setRepacking($this);
  186.         }
  188.         return $this;
  189.     }
  191.     public function removeMovement(PackageMovement $movement): static
  192.     {
  193.         if ($this->movements->removeElement($movement)) {
  194.             // set the owning side to null (unless already changed)
  195.             if ($movement->getRepacking() === $this) {
  196.                 $movement->setRepacking(null);
  197.             }
  198.         }
  200.         return $this;
  201.     }
  202. }