src/Entity/File/Parsable.php line 54

  1. <?php
  3. namespace App\Entity\File;
  5. use ApiPlatform\Metadata\ApiResource;
  6. use ApiPlatform\Metadata\Post;
  7. use ApiPlatform\OpenApi\Model;
  8. use App\Controller\Purchasing\PurchaseOrderDatasheetUploadAction;
  9. use App\Doctrine\Type\File\ParsableStatus;
  10. use App\Doctrine\Type\File\ParsableType;
  11. use App\Dto\Expediting\FreightDatasheetInput;
  12. use App\Entity\Purchasing\Order;
  13. use App\Entity\Sales\WorkOrder;
  14. use App\Validator\IsValidEnum\IsValidEnum;
  15. use ArrayObject;
  16. use Doctrine\Common\Collections\ArrayCollection;
  17. use Doctrine\Common\Collections\Collection;
  18. use Doctrine\DBAL\Types\Types;
  19. use Doctrine\ORM\Mapping as ORM;
  20. use Symfony\Component\Validator\Constraints as Assert;
  21. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  23. #[ORM\Entity]
  24. #[Vich\Uploadable]
  25. #[ApiResource(
  26.     // FIXME : This does not work well with docker
  27.     uriTemplate: '/purchasing/orders/import',
  28.     operations: [
  29.         new Post(
  30.             controller: PurchaseOrderDatasheetUploadAction::class,
  31.             openapi: new Model\Operation(
  32.                 requestBody: new Model\RequestBody(
  33.                     content: new ArrayObject([
  34.                         'multipart/form-data' => [
  35.                             'schema' => [
  36.                                 'type' => 'object',
  37.                                 'properties' => [
  38.                                     'file' => [
  39.                                         'type' => 'string',
  40.                                         'format' => 'binary'
  41.                                     ]
  42.                                 ]
  43.                             ]
  44.                         ]
  45.                     ])
  46.                 )
  47.             ),
  48.             shortName: 'Upload',
  49.             validationContext: ['groups' => ['Default', 'upload:create']],
  50.             deserialize: false,
  51.         ),
  52.     ],
  53. )]
  54. class Parsable extends File
  55. {
  56.     use Archivable;
  58.     #[Assert\Type(type: FreightDatasheetInput::class)]
  59.     #[ORM\Column(type: 'json_document', options: ['jsonb' => true])]
  60.     private ?FreightDatasheetInput $data = null;
  62.     #[ORM\Column(type: Types::JSON, nullable: true, options: ['jsonb' => true])]
  63.     private ?array $errors = [];
  65.     #[Assert\NotNull]
  66.     #[IsValidEnum(enum: ParsableType::class)]
  67.     #[ORM\Column(name: 'parsable_type', type: Types::STRING, nullable: false, enumType: ParsableType::class)]
  68.     private ?ParsableType $type = null;
  70.     #[Assert\NotNull]
  71.     #[IsValidEnum(enum: ParsableStatus::class)]
  72.     #[ORM\Column(name: 'parsable_status', type: Types::STRING, nullable: true, enumType: ParsableStatus::class)]
  73.     private ?ParsableStatus $status = ParsableStatus::UPLOADED;
  75.     #[ORM\OneToOne(mappedBy: 'source', targetEntity: WorkOrder::class)]
  76.     private ?WorkOrder $workOrder = null;
  78.     /** @var Collection<int, Order> $orders */
  79.     #[ORM\OneToMany(mappedBy: 'source', targetEntity: Order::class)]
  80.     private Collection $orders;
  82.     public function __construct()
  83.     {
  84.         $this->orders = new ArrayCollection();
  85.     }
  87.     public function getData(): ?FreightDatasheetInput
  88.     {
  89.         return $this->data;
  90.     }
  92.     public function setData(?FreightDatasheetInput $data): self
  93.     {
  94.         $this->data = $data;
  96.         return $this;
  97.     }
  99.     public function getErrors(): array
  100.     {
  101.         return $this->errors;
  102.     }
  104.     public function setErrors(?array $errors): self
  105.     {
  106.         $this->errors = $errors;
  108.         return $this;
  109.     }
  111.     public function getType(): ?ParsableType
  112.     {
  113.         return $this->type;
  114.     }
  116.     public function setType(ParsableType $type): self
  117.     {
  118.         $this->type = $type;
  120.         return $this;
  121.     }
  123.     public function getStatus(): ?ParsableStatus
  124.     {
  125.         return $this->status;
  126.     }
  128.     public function setStatus(?ParsableStatus $status): self
  129.     {
  130.         $this->status = $status;
  132.         return $this;
  133.     }
  135.     public function getWorkOrder(): ?WorkOrder
  136.     {
  137.         return $this->workOrder;
  138.     }
  140.     public function setWorkOrder(?WorkOrder $workOrder): self
  141.     {
  142.         $this->workOrder = $workOrder;
  144.         return $this;
  145.     }
  147.     /**
  148.      * @return Collection<int, Order>
  149.      */
  150.     public function getOrders(): Collection
  151.     {
  152.         return $this->orders;
  153.     }
  155.     public function addOrder(Order $order): self
  156.     {
  157.         if (!$this->orders->contains($order)) {
  158.             $this->orders->add($order);
  159.             $order->setSource($this);
  160.         }
  162.         return $this;
  163.     }
  165.     public function removeOrder(Order $order): self
  166.     {
  167.         if ($this->orders->removeElement($order)) {
  168.             // set the owning side to null (unless already changed)
  169.             if ($order->getSource() === $this) {
  170.                 $order->setSource(null);
  171.             }
  172.         }
  174.         return $this;
  175.     }
  176. }