src/Entity/Expediting/Shipment.php line 178

  1. <?php
  3. namespace App\Entity\Expediting;
  5. use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
  6. use ApiPlatform\Metadata\ApiFilter;
  7. use ApiPlatform\Metadata\ApiProperty;
  8. use ApiPlatform\Metadata\ApiResource;
  9. use ApiPlatform\Metadata\Get;
  10. use ApiPlatform\Metadata\Patch;
  11. use ApiPlatform\Metadata\Post;
  12. use ApiPlatform\OpenApi\Model;
  13. use App\Controller\Expediting\ShipmentDocumentUploadAction;
  14. use App\Doctrine\Type\Expediting\ExpeditingStatus;
  15. use App\Doctrine\Type\Expediting\TransportMode;
  16. use App\Dto\Expediting\ConsolidationInput;
  17. use App\Dto\Expediting\ConsolidationOutput;
  18. use App\Dto\Expediting\ContainerRemovalInput;
  19. use App\Dto\Expediting\ContainersInput;
  20. use App\Dto\Expediting\ContainersOutput;
  21. use App\Dto\Expediting\DocumentationKitItemInput;
  22. use App\Dto\Expediting\DocumentationKitDetailsInput;
  23. use App\Dto\Expediting\ShipmentBookingInput;
  24. use App\Dto\Expediting\ShipmentInput;
  25. use App\Dto\Expediting\ShipmentMilestonesOutput;
  26. use App\Dto\Expediting\ShipmentPackageInput;
  27. use App\Dto\Expediting\ShipmentStatusInput;
  28. use App\Dto\Expediting\ShippingPlanInput;
  29. use App\Entity\Common as Common;
  30. use App\Entity\File\File;
  31. use App\Entity\Places\Facility;
  32. use App\Entity\Sales\WorkOrder;
  33. use App\Processor\Expediting\ConsolidationInputProcessor;
  34. use App\Processor\Expediting\ConsolidationPackageAdditionProcessor;
  35. use App\Processor\Expediting\ConsolidationPackageRemovalProcessor;
  36. use App\Processor\Expediting\ConsolidationPlanCreationProcessor;
  37. use App\Processor\Expediting\ContainerDeletionProcessor;
  38. use App\Processor\Expediting\DocumentationKitDetailsProcessor;
  39. use App\Processor\Expediting\DocumentationKitItemProcessor;
  40. use App\Processor\Expediting\ShipmentBookingInputProcessor;
  41. use App\Processor\Expediting\ShipmentContainersInputProcessor;
  42. use App\Processor\Expediting\ShipmentInputProcessor;
  43. use App\Processor\Expediting\ShipmentStatusInputProcessor;
  44. use App\Provider\Expediting\ConsolidationOutputProvider;
  45. use App\Provider\Expediting\ShipmentContainersProvider;
  46. use App\Provider\Expediting\ShipmentDocumentationKitRequestProvider;
  47. use App\Provider\Expediting\ShipmentMilestonesProvider;
  48. use App\Validator\IsValidEnum\IsValidEnum;
  49. use ArrayObject;
  50. use Doctrine\Common\Collections\ArrayCollection;
  51. use Doctrine\Common\Collections\Collection;
  52. use Doctrine\DBAL\Types\Types;
  53. use Doctrine\ORM\Mapping as ORM;
  54. use Gedmo\Mapping\Annotation as Gedmo;
  55. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  56. use Symfony\Component\Serializer\Annotation\Ignore;
  57. use Symfony\Component\Validator\Constraints as Assert;
  59. #[ORM\Table(name: 'expediting_shipment')]
  60. #[ORM\Index(columns: ['created_by'], name: 'expediting_shipment_created_by_idx')]
  61. #[ORM\Index(columns: ['updated_by'], name: 'expediting_shipment_updated_by_idx')]
  62. #[ORM\UniqueConstraint(name: 'expediting_shipment_reference_key', columns: ['reference'])]
  63. #[ORM\UniqueConstraint(name: 'expediting_shipment_slug_key', columns: ['slug'])]
  64. #[ORM\Entity]
  65. #[UniqueEntity(fields: ['reference', 'slug'])]
  66. #[ApiResource(
  67.     routePrefix: '/expediting',
  68.     input: ShipmentInput::class,
  69.     processor: ShipmentInputProcessor::class,
  70. )]
  71. #[ApiResource(
  72.     operations: [
  73.         new Get(
  74.             uriTemplate: '/expediting/shipments/{slug}/milestones',
  75.             output: ShipmentMilestonesOutput::class,
  76.             provider: ShipmentMilestonesProvider::class
  77.         ),
  78.         new Get(
  79.             uriTemplate: '/expediting/shipments/{slug}/containers',
  80.             output: ContainersOutput::class,
  81.             provider: ShipmentContainersProvider::class
  82.         ),
  83.         new Get(
  84.             uriTemplate: '/expediting/shipments/{slug}/shipment',
  85.             output: ConsolidationOutput::class,
  86.             provider: ConsolidationOutputProvider::class
  87.         ),
  88.         new Get(
  89.             uriTemplate: '/expediting/shipments/{slug}/kit-request',
  90.             provider: ShipmentDocumentationKitRequestProvider::class
  91.         ),
  92.         new Post(
  93.             uriTemplate: '/expediting/shipments/{slug}/kit/details',
  94.             input: DocumentationKitDetailsInput::class,
  95.             processor: DocumentationKitDetailsProcessor::class
  96.         ),
  97.         new Post(
  98.             uriTemplate: '/expediting/shipments/{slug}/kit/item',
  99.             input: DocumentationKitItemInput::class,
  100.             processor: DocumentationKitItemProcessor::class
  101.         ),
  102.         new Post(
  103.             uriTemplate: '/expediting/shipments/{slug}/containers',
  104.             input: ContainersInput::class,
  105.             processor: ShipmentContainersInputProcessor::class
  106.         ),
  107.         new Post(
  108.             uriTemplate: '/expediting/shipments/{slug}/container-remove',
  109.             input: ContainerRemovalInput::class,
  110.             processor: ContainerDeletionProcessor::class
  111.         ),
  112.         new Post(
  113.             uriTemplate: '/expediting/shipments/{slug}/plan',
  114.             input: ShippingPlanInput::class,
  115.             processor: ConsolidationPlanCreationProcessor::class
  116.         ),
  117.         new Post(
  118.             uriTemplate: '/expediting/shipments/{slug}/booking',
  119.             input: ShipmentBookingInput::class,
  120.             processor: ShipmentBookingInputProcessor::class
  121.         ),
  122.         new Post(
  123.             uriTemplate: '/expediting/shipments/{slug}/add',
  124.             input: ShipmentPackageInput::class,
  125.             processor: ConsolidationPackageAdditionProcessor::class
  126.         ),
  127.         new Post(
  128.             uriTemplate: '/expediting/shipments/{slug}/remove',
  129.             input: ShipmentPackageInput::class,
  130.             processor: ConsolidationPackageRemovalProcessor::class
  131.         ),
  132.         new Post(
  133.             uriTemplate: '/expediting/shipments/{slug}/shipment',
  134.             input: ConsolidationInput::class,
  135.             processor: ConsolidationInputProcessor::class
  136.         ),
  137.         new Patch(
  138.             uriTemplate: '/expediting/shipments/{slug}/status',
  139.             inputFormats: ['json' => ['application/merge-patch+json']],
  140.             input: ShipmentStatusInput::class,
  141.             processor: ShipmentStatusInputProcessor::class
  142.         ),
  143.     ]
  144. )]
  145. #[ApiResource(
  146.     // FIXME : This does not work well with docker
  147.     uriTemplate: '/shipments/{slug}/attachments',
  148.     operations: [
  149.         new Post(
  150.             controller: ShipmentDocumentUploadAction::class,
  151.             openapi: new Model\Operation(
  152.                 requestBody: new Model\RequestBody(
  153.                     content: new ArrayObject([
  154.                         'multipart/form-data' => [
  155.                             'schema' => [
  156.                                 'type' => 'object',
  157.                                 'properties' => [
  158.                                     'file' => [
  159.                                         'type' => 'string',
  160.                                         'format' => 'binary'
  161.                                     ]
  162.                                 ]
  163.                             ]
  164.                         ]
  165.                     ])
  166.                 )
  167.             ),
  168.             shortName: 'Upload',
  169.             validationContext: ['groups' => ['Default', 'upload:create']],
  170.             deserialize: false,
  171.         ),
  172.     ],
  173.     routePrefix: '/expediting',
  174. )]
  175. #[ApiFilter(SearchFilter::class, properties: [
  176.     'reference' => 'ipartial',
  177. ])]
  178. class Shipment
  179. {
  180.     use Common\Blameable;
  181.     use Common\Trackable;
  183.     #[ORM\Id]
  184.     #[ORM\GeneratedValue(strategy: 'IDENTITY')]
  185.     #[ORM\SequenceGenerator(sequenceName: 'expediting_shipment_id_seq')]
  186.     #[ORM\Column(type: Types::INTEGER)]
  187.     #[ApiProperty(identifier: false)]
  188.     private ?int $id = null;
  190.     #[Gedmo\Slug(fields: ['reference'])]
  191.     #[ORM\Column(type: Types::STRING)]
  192.     #[ApiProperty(identifier: true)]
  193.     private ?string $slug = null;
  195.     #[Assert\NotBlank]
  196.     #[Assert\Type(type: Types::STRING)]
  197.     #[ORM\Column(type: Types::STRING)]
  198.     private ?string $reference = null;
  200.     #[Assert\NotNull]
  201.     #[IsValidEnum(enum: ExpeditingStatus::class)]
  202.     #[ORM\Column(type: Types::STRING, nullable: false, enumType: ExpeditingStatus::class, options: ['default' => 'PLANNED'])]
  203.     private ?ExpeditingStatus $status = ExpeditingStatus::PLANNED;
  205.     /** @var Collection<int, ShippingPlan> */
  206.     #[ORM\OneToMany(mappedBy: 'shipment', targetEntity: ShippingPlan::class)]
  207.     private Collection $shippingPlans;
  209.     /** @var Collection<int, Container> */
  210.     #[ORM\OneToMany(mappedBy: 'shipment', targetEntity: Container::class)]
  211.     private Collection $containers;
  213.     /** @var Collection<int, Package> */
  214.     #[ORM\ManyToMany(targetEntity: Package::class, inversedBy: 'shipments')]
  215.     #[ORM\JoinTable(name: 'expediting_shipment_package_map')]
  216.     #[ORM\JoinColumn(name: 'shipment_id')]
  217.     #[ORM\InverseJoinColumn(name: 'package_id')]
  218.     private Collection $packages;
  220.     /** @var Collection<int, DocumentationKit> */
  221.     #[ORM\OneToMany(mappedBy: 'shipment', targetEntity: DocumentationKit::class, cascade: ['persist', 'remove'])]
  222.     #[ORM\OrderBy(['id' => 'ASC'])]
  223.     #[Ignore]
  224.     private Collection $documentationKits;
  226.     /** @var Collection<int, File> */
  227.     #[ORM\ManyToMany(targetEntity: File::class, cascade: ['persist', 'remove'])]
  228.     #[ORM\JoinTable(name: 'expediting_shipment_file_map')]
  229.     #[ORM\JoinColumn(name: 'shipment_id')]
  230.     #[ORM\InverseJoinColumn(name: 'file_id')]
  231.     #[ORM\OrderBy(['id' => 'ASC'])]
  232.     private Collection $attachments;
  234.     public function __construct()
  235.     {
  236.         $this->shippingPlans = new ArrayCollection();
  237.         $this->containers = new ArrayCollection();
  238.         $this->packages = new ArrayCollection();
  239.         $this->documentationKits = new ArrayCollection();
  240.         $this->attachments = new ArrayCollection();
  241.     }
  243.     public function getId(): ?int
  244.     {
  245.         return $this->id;
  246.     }
  248.     public function getSlug(): ?string
  249.     {
  250.         return $this->slug;
  251.     }
  253.     public function setSlug(string $slug): self
  254.     {
  255.         $this->slug = $slug;
  257.         return $this;
  258.     }
  260.     public function getReference(): ?string
  261.     {
  262.         return $this->reference;
  263.     }
  265.     public function setReference(string $reference): self
  266.     {
  267.         $this->reference = $reference;
  269.         return $this;
  270.     }
  272.     #[ApiProperty(readableLink: true)]
  273.     public function getShippingSegments(): ?Collection
  274.     {
  275.         $shippingPlan = $this->shippingPlans->first();
  276.         if (!$shippingPlan instanceof ShippingPlan) {
  277.             return null;
  278.         }
  280.         return $shippingPlan->getShippingSegments();
  281.     }
  283.     #[ApiProperty(readableLink: true)]
  284.     public function getPlaceOfLoading(): ?Facility
  285.     {
  286.         $shippingPlan = $this->shippingPlans->first();
  287.         if (!$shippingPlan instanceof ShippingPlan) {
  288.             return null;
  289.         }
  291.         return $shippingPlan->getShippingSegments()?->first()?->getPlaceOfLoading();
  292.     }
  294.     #[ApiProperty(readableLink: true)]
  295.     public function getPlaceOfDischarge(): ?Facility
  296.     {
  297.         $shippingPlan = $this->shippingPlans->first();
  298.         if (!$shippingPlan instanceof ShippingPlan) {
  299.             return null;
  300.         }
  302.         return $shippingPlan->getShippingSegments()?->last()?->getPlaceOfDischarge();
  303.     }
  305.     public function getTransportMode(): ?TransportMode
  306.     {
  307.         $shippingPlan = $this->shippingPlans->first();
  308.         if (!$shippingPlan instanceof ShippingPlan) {
  309.             return null;
  310.         }
  312.         return $shippingPlan->getShippingSegments()?->first()?->getTransportMode();
  313.     }
  315.     public function getStatus(): ?ExpeditingStatus
  316.     {
  317.         return $this->status;
  318.     }
  320.     public function setStatus(?ExpeditingStatus $status): self
  321.     {
  322.         $this->status = $status;
  324.         return $this;
  325.     }
  327.     /** @return Collection<int, ShippingPlan> */
  328.     public function getShippingPlans(): Collection
  329.     {
  330.         return $this->shippingPlans;
  331.     }
  333.     public function addShippingPlan(ShippingPlan $shippingPlan): static
  334.     {
  335.         if (!$this->shippingPlans->contains($shippingPlan)) {
  336.             $this->shippingPlans[] = $shippingPlan;
  337.             $shippingPlan->setShipment($this);
  338.         }
  340.         return $this;
  341.     }
  343.     public function removeShippingPlan(ShippingPlan $shippingPlan): static
  344.     {
  345.         if ($this->shippingPlans->removeElement($shippingPlan)) {
  346.             // set the owning side to null (unless already changed)
  347.             if ($shippingPlan->getShipment() === $this) {
  348.                 $shippingPlan->setShipment(null);
  349.             }
  350.         }
  352.         return $this;
  353.     }
  355.     /** @return Collection<int, Container> */
  356.     public function getContainers(): Collection
  357.     {
  358.         return $this->containers;
  359.     }
  361.     public function addContainer(Container $container): static
  362.     {
  363.         if (!$this->containers->contains($container)) {
  364.             $this->containers[] = $container;
  365.             $container->setShipment($this);
  366.         }
  368.         return $this;
  369.     }
  371.     public function removeContainer(Container $container): static
  372.     {
  373.         if ($this->containers->removeElement($container)) {
  374.             // set the owning side to null (unless already changed)
  375.             if ($container->getShipment() === $this) {
  376.                 $container->setShipment(null);
  377.             }
  378.         }
  380.         return $this;
  381.     }
  383.     /**
  384.      * @return Collection<int, WorkOrder>
  385.      */
  386.     public function getWorkOrders(): Collection
  387.     {
  388.         $workOrders = new ArrayCollection();
  389.         foreach ($this->packages as $package) {
  390.             foreach ($package->getItems() as $item) {
  391.                 if ($item instanceof Part) {
  392.                     $workOrder = $item->getItem()->getFreight()->getWorkOrder();
  393.                 } elseif ($item instanceof Item) {
  394.                     $workOrder = $item->getFreight()->getWorkOrder();
  395.                 } else {
  396.                     continue;
  397.                 }
  399.                 if (!$workOrders->contains($workOrder)) {
  400.                     $workOrders->add($workOrder);
  401.                 }
  402.             }
  403.         }
  405.         return $workOrders;
  406.     }
  408.     /**
  409.      * @return Collection<int, Package>
  410.      */
  411.     public function getPackages(): Collection
  412.     {
  413.         return $this->packages;
  414.     }
  416.     public function addPackage(Package $package): self
  417.     {
  418.         if (!$this->packages->contains($package)) {
  419.             $this->packages->add($package);
  420.         }
  422.         return $this;
  423.     }
  425.     public function removePackage(Package $package): self
  426.     {
  427.         $this->packages->removeElement($package);
  429.         return $this;
  430.     }
  432.     public function hasDocumentationKit(): ?bool
  433.     {
  434.         return !$this->documentationKits->isEmpty();
  435.     }
  437.     public function getDocumentationKit(): ?DocumentationKit
  438.     {
  439.         return !$this->documentationKits->isEmpty()
  440.             ? $this->documentationKits->last()
  441.             : null;
  442.     }
  444.     /**
  445.      * @return Collection<int, DocumentationKit>
  446.      */
  447.     public function getDocumentationKits(): Collection
  448.     {
  449.         return $this->documentationKits;
  450.     }
  452.     public function addDocumentationKit(DocumentationKit $documentationKit): self
  453.     {
  454.         if (!$this->documentationKits->contains($documentationKit)) {
  455.             $this->documentationKits->add($documentationKit);
  456.             $documentationKit->setShipment($this);
  457.         }
  459.         return $this;
  460.     }
  462.     public function removeFreight(DocumentationKit $documentationKit): self
  463.     {
  464.         if ($this->documentationKits->removeElement($documentationKit)) {
  465.             // set the owning side to null (unless already changed)
  466.             if ($documentationKit->getShipment() === $this) {
  467.                 $documentationKit->setShipment(null);
  468.             }
  469.         }
  471.         return $this;
  472.     }
  474.     /**
  475.      * @return Collection<int, File>
  476.      */
  477.     public function getAttachments(): Collection
  478.     {
  479.         return $this->attachments;
  480.     }
  482.     public function addAttachment(File $attachment): self
  483.     {
  484.         if (!$this->attachments->contains($attachment)) {
  485.             $this->attachments->add($attachment);
  486.         }
  488.         return $this;
  489.     }
  491.     public function removeAttachment(File $attachment): self
  492.     {
  493.         $this->attachments->removeElement($attachment);
  495.         return $this;
  496.     }
  497. }