src/Entity/Sales/WorkOrder.php line 196

  1. <?php
  3. namespace App\Entity\Sales;
  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\Delete;
  10. use ApiPlatform\Metadata\Get;
  11. use ApiPlatform\Metadata\GetCollection;
  12. use ApiPlatform\Metadata\Link;
  13. use ApiPlatform\Metadata\Patch;
  14. use ApiPlatform\Metadata\Post;
  15. use ApiPlatform\Metadata\Put;
  16. use ApiPlatform\OpenApi\Model;
  17. use App\Controller\Expediting\FreightDatasheetUploadAction;
  18. use App\Controller\Sales\WorkOrderDocumentUploadAction;
  19. use App\Doctrine\Type\Sales\Incoterm;
  20. use App\Doctrine\Type\Sales\WorkOrderStatus;
  21. use App\Dto\Common\ObservationInput;
  22. use App\Dto\Expediting\FreightDatasheetInput;
  23. use App\Dto\Expediting\ReceptionInput;
  24. use App\Dto\Expediting\ReceptionPlanInput;
  25. use App\Dto\Expediting\ShippingPlanInput;
  26. use App\Dto\Sales\WorkOrderInput;
  27. use App\Dto\Sales\WorkOrderOutput;
  28. use App\Dto\Sales\WorkOrderStatusInput;
  29. use App\Entity\Common\Blameable;
  30. use App\Entity\Common\Company;
  31. use App\Entity\Common\Observation;
  32. use App\Entity\Common\Trackable;
  33. use App\Entity\Delete\Waybill;
  34. use App\Entity\Expediting\Freight;
  35. use App\Entity\Expediting\Item;
  36. use App\Entity\Expediting\Package;
  37. use App\Entity\Expediting\ShippingPlan;
  38. use App\Entity\File\File;
  39. use App\Entity\File\Parsable;
  40. use App\Entity\Identity\User;
  41. use App\Entity\Places\Facility;
  42. use App\Entity\Scheduler\Task;
  43. use App\Processor\Expediting\ReceptionInputProcessor;
  44. use App\Processor\Expediting\ReceptionPlanInputProcessor;
  45. use App\Processor\Expediting\ShippingPlanCreationProcessor;
  46. use App\Processor\Sales\FreightDatasheetProcessor;
  47. use App\Processor\Sales\WorkOrderCreationProcessor;
  48. use App\Processor\Sales\WorkOrderObservationProcessor;
  49. use App\Processor\Sales\WorkOrderStatusInputProcessor;
  50. use App\Provider\Finance\WorkOrderQuotationsProvider;
  51. use App\Provider\Sales\WorkOrderProvider;
  52. use App\Validator\IsValidEnum\IsValidEnum;
  53. use ArrayObject;
  54. use DateTimeInterface;
  55. use Doctrine\Common\Collections\ArrayCollection;
  56. use Doctrine\Common\Collections\Collection;
  57. use Doctrine\DBAL\Types\Types;
  58. use Doctrine\ORM\Mapping as ORM;
  59. use Gedmo\Mapping\Annotation as Gedmo;
  60. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  61. use Symfony\Component\Validator\Constraints as Assert;
  63. #[ORM\Table(name: 'work_order')]
  64. #[ORM\Index(columns: ['issued_by'], name: 'work_order_issued_by_idx')]
  65. #[ORM\Index(columns: ['client_id'], name: 'work_order_client_id_idx')]
  66. #[ORM\Index(columns: ['supplier_id'], name: 'work_order_supplier_id_idx')]
  67. #[ORM\Index(columns: ['contract_id'], name: 'work_order_contract_id_idx')]
  68. #[ORM\Index(columns: ['place_of_loading_id'], name: 'work_order_place_of_loading_id_idx')]
  69. #[ORM\Index(columns: ['place_of_discharge_id'], name: 'work_order_place_of_discharge_id_idx')]
  70. #[ORM\Index(columns: ['source_id'], name: 'work_order_source_id_idx')]
  71. #[ORM\Index(columns: ['created_by'], name: 'work_order_created_by_idx')]
  72. #[ORM\Index(columns: ['updated_by'], name: 'work_order_updated_by_idx')]
  73. #[ORM\UniqueConstraint(name: 'work_order_slug_key', columns: ['slug'])]
  74. #[ORM\UniqueConstraint(name: 'work_order_reference_key', columns: ['reference'])]
  75. #[ORM\Entity]
  76. #[UniqueEntity(fields: ['reference', 'slug'])]
  77. #[ApiResource(
  78.     shortName: 'WorkOrder',
  79.     operations: [
  80.         new Get(output: WorkOrderOutput::class, provider: WorkOrderProvider::class),
  81.         new GetCollection(),
  82.         new GetCollection(uriTemplate: '/procurement/work_orders', name: 'work_order_procurement'),
  83.         new GetCollection(uriTemplate: '/work_orders/{slug}/quotations', shortName: 'Quotation', provider: WorkOrderQuotationsProvider::class),
  84.         new Post(input: WorkOrderInput::class, processor: WorkOrderCreationProcessor::class),
  85.         new Patch(inputFormats: ['json' => ['application/merge-patch+json']], input: WorkOrderInput::class, processor: WorkOrderCreationProcessor::class),
  86.         new Put(),
  87.         new Delete(),
  88.     ],
  89.     order: ['id' => 'DESC']
  90. )]
  91. #[ApiResource(
  92.     operations: [
  93.         new Patch(
  94.             uriTemplate: '/work_orders/{slug}/status',
  95.             inputFormats: ['json' => ['application/merge-patch+json']],
  96.             input: WorkOrderStatusInput::class,
  97.             processor: WorkOrderStatusInputProcessor::class
  98.         ),
  99.         new Post(
  100.             uriTemplate: '/work_orders/{slug}/plan',
  101.             input: ShippingPlanInput::class,
  102.             processor: ShippingPlanCreationProcessor::class
  103.         ),
  104.         new Post(
  105.             uriTemplate: '/work_orders/{slug}/etr',
  106.             input: ReceptionPlanInput::class,
  107.             processor: ReceptionPlanInputProcessor::class
  108.         ),
  109.         new Post(
  110.             uriTemplate: '/work_orders/{slug}/atr',
  111.             input: ReceptionInput::class,
  112.             processor: ReceptionInputProcessor::class
  113.         ),
  114.         new Post(
  115.             uriTemplate: '/work_orders/{slug}/datasheet',
  116.             input: FreightDatasheetInput::class,
  117.             processor: FreightDatasheetProcessor::class
  118.         ),
  119.         new Post(
  120.             uriTemplate: '/work_orders/{slug}/observations',
  121.             input: ObservationInput::class,
  122.             processor: WorkOrderObservationProcessor::class
  123.         ),
  124.         new GetCollection(
  125.             uriTemplate: '/scope/{slug}/work_orders',
  126.             uriVariables: [
  127.                 'slug' => new Link(fromProperty: 'workOrders', fromClass: Contract::class),
  128.             ],
  129.         ),
  130.     ]
  131. )]
  132. #[ApiResource(
  133.     // FIXME : This does not work well with docker
  134.     uriTemplate: '/work_orders/{slug}/import',
  135.     operations: [
  136.         new Post(
  137.             controller: FreightDatasheetUploadAction::class,
  138.             openapi: new Model\Operation(
  139.                 requestBody: new Model\RequestBody(
  140.                     content: new ArrayObject([
  141.                         'multipart/form-data' => [
  142.                             'schema' => [
  143.                                 'type' => 'object',
  144.                                 'properties' => [
  145.                                     'file' => [
  146.                                         'type' => 'string',
  147.                                         'format' => 'binary'
  148.                                     ]
  149.                                 ]
  150.                             ]
  151.                         ]
  152.                     ])
  153.                 )
  154.             ),
  155.             shortName: 'Upload',
  156.             validationContext: ['groups' => ['Default', 'upload:create']],
  157.             deserialize: false,
  158.         ),
  159.     ],
  160. )]
  161. #[ApiResource(
  162.     // FIXME : This does not work well with docker
  163.     uriTemplate: '/work_orders/{slug}/attachments',
  164.     operations: [
  165.         new Post(
  166.             controller: WorkOrderDocumentUploadAction::class,
  167.             openapi: new Model\Operation(
  168.                 requestBody: new Model\RequestBody(
  169.                     content: new ArrayObject([
  170.                         'multipart/form-data' => [
  171.                             'schema' => [
  172.                                 'type' => 'object',
  173.                                 'properties' => [
  174.                                     'file' => [
  175.                                         'type' => 'string',
  176.                                         'format' => 'binary'
  177.                                     ]
  178.                                 ]
  179.                             ]
  180.                         ]
  181.                     ])
  182.                 )
  183.             ),
  184.             shortName: 'Upload',
  185.             validationContext: ['groups' => ['Default', 'upload:create']],
  186.             deserialize: false,
  187.         ),
  188.     ],
  189. )]
  190. #[ApiFilter(SearchFilter::class, properties: [
  191.     'reference' => 'ipartial',
  192.     'tasks.type' => 'exact',
  193.     'tasks.status' => 'exact',
  194.     'freights.order.number' => 'ipartial',
  195. ])]
  196. class WorkOrder
  197. {
  198.     use Blameable;
  199.     use Trackable;
  201.     #[ORM\Id]
  202.     #[ORM\GeneratedValue(strategy: 'IDENTITY')]
  203.     #[ORM\SequenceGenerator(sequenceName: 'work_order_id_seq')]
  204.     #[ORM\Column(type: Types::INTEGER)]
  205.     #[ApiProperty(identifier: false)]
  206.     private ?int $id = null;
  208.     #[Gedmo\Slug(fields: ['reference'])]
  209.     #[ORM\Column(type: Types::STRING)]
  210.     #[ApiProperty(identifier: true)]
  211.     private ?string $slug = null;
  213.     #[Assert\NotNull]
  214.     #[Assert\Length(min: 5)]
  215.     #[ORM\Column(type: Types::STRING)]
  216.     private ?string $reference = null;
  218.     #[Assert\Type(type: User::class)]
  219.     #[ORM\ManyToOne(targetEntity: User::class)]
  220.     #[ORM\JoinColumn(name: 'issued_by')]
  221.     private ?User $issuedBy = null;
  223.     #[Assert\NotNull]
  224.     #[Assert\Type(type: Company::class)]
  225.     #[ORM\ManyToOne(targetEntity: Company::class)]
  226.     #[ORM\JoinColumn(name: 'client_id', nullable: false)]
  227.     private ?Company $client = null;
  229.     #[Assert\Type(type: Company::class)]
  230.     #[ORM\ManyToOne(targetEntity: Company::class)]
  231.     #[ORM\JoinColumn(name: 'supplier_id')]
  232.     private ?Company $supplier = null;
  234.     #[Assert\Type(type: Contract::class)]
  235.     #[ORM\ManyToOne(targetEntity: Contract::class, inversedBy: 'workOrders')]
  236.     #[ORM\JoinColumn(name: 'contract_id')]
  237.     private ?Contract $contract = null;
  239.     #[Assert\NotNull]
  240.     #[ORM\ManyToOne(targetEntity: Facility::class)]
  241.     #[ORM\JoinColumn(name: 'place_of_loading_id', nullable: false)]
  242.     private ?Facility $placeOfLoading = null;
  244.     #[Assert\NotNull]
  245.     #[ORM\ManyToOne(targetEntity: Facility::class)]
  246.     #[ORM\JoinColumn(name: 'place_of_discharge_id', nullable: false)]
  247.     private ?Facility $placeOfDischarge = null;
  249.     #[Assert\Type(type: Parsable::class)]
  250.     #[ORM\OneToOne(inversedBy: 'workOrder', targetEntity: Parsable::class)]
  251.     #[ORM\JoinColumn(name: 'source_id')]
  252.     private ?Parsable $source = null;
  254.     /** @var Collection<int, ShippingPlan> */
  255.     #[ORM\OneToMany(mappedBy: 'workOrder', targetEntity: ShippingPlan::class)]
  256.     #[ORM\OrderBy(['id' => 'DESC'])]
  257.     private Collection $shippingPlans;
  259.     #[IsValidEnum(enum: Incoterm::class)]
  260.     #[ORM\Column(type: Types::STRING, nullable: true, enumType: Incoterm::class)]
  261.     private ?Incoterm $incoterm = null;
  263.     #[Assert\NotNull]
  264.     #[Assert\Type(type: DateTimeInterface::class)]
  265.     #[ORM\Column(type: Types::DATE_MUTABLE)]
  266.     private ?DateTimeInterface $requestedOn = null;
  268.     #[Assert\NotNull]
  269.     #[Assert\Type(type: DateTimeInterface::class)]
  270.     #[ORM\Column(type: Types::DATE_MUTABLE)]
  271.     private ?DateTimeInterface $availableOn = null;
  273.     #[Assert\NotNull]
  274.     #[IsValidEnum(enum: WorkOrderStatus::class)]
  275.     #[ORM\Column(type: Types::STRING, enumType: WorkOrderStatus::class, options: ['default' => 'DRAFTED'])]
  276.     private ?WorkOrderStatus $status = WorkOrderStatus::DRAFTED;
  278.     /** @var Collection<int, Task> */
  279.     #[ORM\ManyToMany(targetEntity: Task::class, mappedBy: 'workOrders')]
  280.     private Collection $tasks;
  282.     /** @var Collection<int, Freight> */
  283.     #[ORM\OneToMany(mappedBy: 'workOrder', targetEntity: Freight::class, cascade: ['persist', 'remove'])]
  284.     private Collection $freights;
  286.     /** @var Collection<int, User> */
  287.     #[ORM\ManyToMany(targetEntity: User::class)]
  288.     #[ORM\JoinTable(name: 'work_order_customer_contact_map')]
  289.     #[ORM\JoinColumn(name: 'work_order_id')]
  290.     #[ORM\InverseJoinColumn(name: 'customer_contact_id')]
  291.     private Collection $customerContacts;
  293.     /** @var Collection<int, User> */
  294.     #[ORM\ManyToMany(targetEntity: User::class)]
  295.     #[ORM\JoinTable(name: 'work_order_supplier_contact_map')]
  296.     #[ORM\JoinColumn(name: 'work_order_id')]
  297.     #[ORM\InverseJoinColumn(name: 'supplier_contact_id')]
  298.     private Collection $supplierContacts;
  300.     /** @var Collection<int, File> */
  301.     #[ORM\ManyToMany(targetEntity: File::class, cascade: ['persist', 'remove'])]
  302.     #[ORM\JoinTable(name: 'work_order_file_map')]
  303.     #[ORM\JoinColumn(name: 'work_order_id')]
  304.     #[ORM\InverseJoinColumn(name: 'file_id')]
  305.     #[ORM\OrderBy(['id' => 'ASC'])]
  306.     private Collection $attachments;
  308.     /** @var Collection<int, Observation> */
  309.     #[ORM\OneToMany(mappedBy: 'workOrder', targetEntity: Observation::class, cascade: ['persist', 'remove'])]
  310.     private Collection $observations;
  312.     #[Assert\Type(type: FreightDatasheetInput::class)]
  313.     #[ORM\Column(type: 'json_document', options: ['jsonb' => true])]
  314.     private FreightDatasheetInput $datasheet;
  316.     #[Assert\Valid]
  317.     #[Assert\Type(type: Waybill::class)]
  318.     #[ORM\Column(type: 'json_document', nullable: true, options: ['jsonb' => true])]
  319.     private Waybill $waybill;
  321.     public function __construct()
  322.     {
  323.         $this->tasks = new ArrayCollection();
  324.         $this->freights = new ArrayCollection();
  325.         $this->customerContacts = new ArrayCollection();
  326.         $this->supplierContacts = new ArrayCollection();
  327.         $this->datasheet = new FreightDatasheetInput();
  328.         $this->attachments = new ArrayCollection();
  329.         $this->observations = new ArrayCollection();
  330.         $this->shippingPlans = new ArrayCollection();
  331.     }
  333.     public function getId(): ?int
  334.     {
  335.         return $this->id;
  336.     }
  338.     public function getSlug(): ?string
  339.     {
  340.         return $this->slug;
  341.     }
  343.     public function setSlug(string $slug): self
  344.     {
  345.         $this->slug = $slug;
  347.         return $this;
  348.     }
  350.     public function getReference(): ?string
  351.     {
  352.         return $this->reference;
  353.     }
  355.     public function setReference(string $reference): self
  356.     {
  357.         $this->reference = $reference;
  359.         return $this;
  360.     }
  362.     public function getIssuedBy(): ?User
  363.     {
  364.         return $this->issuedBy;
  365.     }
  367.     public function setIssuedBy(?User $issuedBy): self
  368.     {
  369.         $this->issuedBy = $issuedBy;
  371.         return $this;
  372.     }
  374.     public function getClient(): ?Company
  375.     {
  376.         return $this->client;
  377.     }
  379.     public function setClient(?Company $client): self
  380.     {
  381.         $this->client = $client;
  383.         return $this;
  384.     }
  386.     public function getSupplier(): ?Company
  387.     {
  388.         return $this->supplier;
  389.     }
  391.     public function setSupplier(?Company $supplier): self
  392.     {
  393.         $this->supplier = $supplier;
  395.         return $this;
  396.     }
  398.     public function getContract(): ?Contract
  399.     {
  400.         return $this->contract;
  401.     }
  403.     public function setContract(?Contract $contract): self
  404.     {
  405.         $this->contract = $contract;
  407.         return $this;
  408.     }
  410.     public function getPlaceOfLoading(): ?Facility
  411.     {
  412.         return $this->placeOfLoading;
  413.     }
  415.     public function setPlaceOfLoading(?Facility $placeOfLoading): self
  416.     {
  417.         $this->placeOfLoading = $placeOfLoading;
  419.         return $this;
  420.     }
  422.     public function getPlaceOfDischarge(): ?Facility
  423.     {
  424.         return $this->placeOfDischarge;
  425.     }
  427.     public function setPlaceOfDischarge(?Facility $placeOfDischarge): self
  428.     {
  429.         $this->placeOfDischarge = $placeOfDischarge;
  431.         return $this;
  432.     }
  434.     public function getSource(): ?Parsable
  435.     {
  436.         return $this->source;
  437.     }
  439.     public function setSource(?Parsable $source): self
  440.     {
  441.         $this->source = $source;
  443.         return $this;
  444.     }
  446.     /** @return Collection<int, ShippingPlan> */
  447.     public function getShippingPlans(): Collection
  448.     {
  449.         return $this->shippingPlans;
  450.     }
  452.     public function addShippingPlan(ShippingPlan $shippingPlan): static
  453.     {
  454.         if (!$this->shippingPlans->contains($shippingPlan)) {
  455.             $this->shippingPlans[] = $shippingPlan;
  456.             $shippingPlan->setWorkOrder($this);
  457.         }
  459.         return $this;
  460.     }
  462.     public function removeShippingPlan(ShippingPlan $shippingPlan): static
  463.     {
  464.         if ($this->shippingPlans->removeElement($shippingPlan)) {
  465.             // set the owning side to null (unless already changed)
  466.             if ($shippingPlan->getWorkOrder() === $this) {
  467.                 $shippingPlan->setWorkOrder(null);
  468.             }
  469.         }
  471.         return $this;
  472.     }
  474.     public function getIncoterm(): ?Incoterm
  475.     {
  476.         return $this->incoterm;
  477.     }
  479.     public function setIncoterm(?Incoterm $incoterm): self
  480.     {
  481.         $this->incoterm = $incoterm;
  483.         return $this;
  484.     }
  486.     public function getRequestedOn(): ?DateTimeInterface
  487.     {
  488.         return $this->requestedOn;
  489.     }
  491.     public function setRequestedOn(?DateTimeInterface $requestedOn): self
  492.     {
  493.         $this->requestedOn = $requestedOn;
  495.         return $this;
  496.     }
  498.     public function getAvailableOn(): ?DateTimeInterface
  499.     {
  500.         return $this->availableOn;
  501.     }
  503.     public function setAvailableOn(?DateTimeInterface $availableOn): self
  504.     {
  505.         $this->availableOn = $availableOn;
  507.         return $this;
  508.     }
  510.     public function getStatus(): ?WorkOrderStatus
  511.     {
  512.         return $this->status;
  513.     }
  515.     public function setStatus(WorkOrderStatus $status): self
  516.     {
  517.         $this->status = $status;
  519.         return $this;
  520.     }
  522.     /**
  523.      * @return Collection<int, Task>
  524.      */
  525.     public function getTasks(): Collection
  526.     {
  527.         return $this->tasks;
  528.     }
  530.     public function addTask(Task $task): self
  531.     {
  532.         if (!$this->tasks->contains($task)) {
  533.             $this->tasks[] = $task;
  534.             $task->addWorkOrder($this);
  535.         }
  537.         return $this;
  538.     }
  540.     public function removeTask(Task $task): self
  541.     {
  542.         if ($this->tasks->removeElement($task)) {
  543.             $task->removeWorkOrder($this);
  544.         }
  546.         return $this;
  547.     }
  549.     /**
  550.      * @return Collection<int, Freight>
  551.      */
  552.     public function getFreights(): Collection
  553.     {
  554.         return $this->freights;
  555.     }
  557.     public function addFreight(Freight $freight): self
  558.     {
  559.         if (!$this->freights->contains($freight)) {
  560.             $this->freights->add($freight);
  561.             $freight->setWorkOrder($this);
  562.         }
  564.         return $this;
  565.     }
  567.     public function removeFreight(Freight $freight): self
  568.     {
  569.         if ($this->freights->removeElement($freight)) {
  570.             // set the owning side to null (unless already changed)
  571.             if ($freight->getWorkOrder() === $this) {
  572.                 $freight->setWorkOrder(null);
  573.             }
  574.         }
  576.         return $this;
  577.     }
  579.     /**
  580.      * @return Collection<int, Package>
  581.      */
  582.     public function getPackages(): Collection
  583.     {
  584.         $packages = new ArrayCollection();
  585.         foreach ($this->freights as $freight) {
  586.             foreach ($freight->getItems() as $item) {
  587.                 foreach ($item->getPackages() as $package) {
  588.                     if (!$packages->contains($package)) {
  589.                         $packages->add($package);
  590.                     }
  591.                 }
  592.             }
  593.         }
  595.         return $packages;
  596.     }
  598.     /**
  599.      * @return Collection<int, Item>
  600.      */
  601.     public function getItems(): Collection
  602.     {
  603.         $items = new ArrayCollection();
  604.         foreach ($this->freights as $freight) {
  605.             foreach ($freight->getItems() as $item) {
  606.                 if (!$items->contains($item)) {
  607.                     $items->add($item);
  608.                 }
  609.             }
  610.         }
  612.         return $items;
  613.     }
  615.     /**
  616.      * @return Collection<int, User>
  617.      */
  618.     public function getCustomerContacts(): Collection
  619.     {
  620.         return $this->customerContacts;
  621.     }
  623.     public function addCustomerContact(User $customerContact): self
  624.     {
  625.         if (!$this->customerContacts->contains($customerContact)) {
  626.             $this->customerContacts->add($customerContact);
  627.         }
  629.         return $this;
  630.     }
  632.     public function removeCustomerContact(User $customerContact): self
  633.     {
  634.         $this->customerContacts->removeElement($customerContact);
  636.         return $this;
  637.     }
  639.     /**
  640.      * @return Collection<int, User>
  641.      */
  642.     public function getSupplierContacts(): Collection
  643.     {
  644.         return $this->supplierContacts;
  645.     }
  647.     public function addSupplierContact(User $supplierContact): self
  648.     {
  649.         if (!$this->supplierContacts->contains($supplierContact)) {
  650.             $this->supplierContacts->add($supplierContact);
  651.         }
  653.         return $this;
  654.     }
  656.     public function removeSupplierContact(User $supplierContact): self
  657.     {
  658.         $this->supplierContacts->removeElement($supplierContact);
  660.         return $this;
  661.     }
  663.     /**
  664.      * @return Collection<int, File>
  665.      */
  666.     public function getAttachments(): Collection
  667.     {
  668.         return $this->attachments;
  669.     }
  671.     public function addAttachment(File $attachment): self
  672.     {
  673.         if (!$this->attachments->contains($attachment)) {
  674.             $this->attachments->add($attachment);
  675.         }
  677.         return $this;
  678.     }
  680.     public function removeAttachment(File $attachment): self
  681.     {
  682.         $this->attachments->removeElement($attachment);
  684.         return $this;
  685.     }
  687.     /**
  688.      * @return Collection<int, Observation>
  689.      */
  690.     public function getObservations(): Collection
  691.     {
  692.         return $this->observations;
  693.     }
  695.     public function addObservation(Observation $observation): self
  696.     {
  697.         if (!$this->observations->contains($observation)) {
  698.             $this->observations->add($observation);
  699.             $observation->setWorkOrder($this);
  700.         }
  702.         return $this;
  703.     }
  705.     public function removeObservation(Observation $observation): self
  706.     {
  707.         if ($this->observations->removeElement($observation)) {
  708.             // set the owning side to null (unless already changed)
  709.             if ($observation->getWorkOrder() === $this) {
  710.                 $observation->setWorkOrder(null);
  711.             }
  712.         }
  714.         return $this;
  715.     }
  717.     public function getDatasheet(): FreightDatasheetInput
  718.     {
  719.         return $this->datasheet;
  720.     }
  722.     public function setDatasheet(FreightDatasheetInput $datasheet): self
  723.     {
  724.         $this->datasheet = $datasheet;
  726.         return $this;
  727.     }
  729.     public function getWaybill(): Waybill
  730.     {
  731.         return $this->waybill;
  732.     }
  734.     public function setWaybill(?Waybill $waybill): static
  735.     {
  736.         $this->waybill = $waybill;
  738.         return $this;
  739.     }
  740. }