src/Entity/ImportFile.php line 20

  1. <?php
  3. namespace App\Entity;
  5. use DateTimeImmutable;
  6. use DateTimeInterface;
  7. use App\Enum\ImportFileType;
  8. use App\Enum\ImportFileStatus;
  9. use Doctrine\Common\Collections\ArrayCollection;
  10. use Doctrine\Common\Collections\Collection;
  11. use Doctrine\ORM\Mapping as ORM;
  12. use Symfony\Component\HttpFoundation\File\File;
  13. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  14. use Gedmo\Timestampable\Traits\TimestampableEntity;
  15. use Symfony\Component\HttpFoundation\File\UploadedFile;
  18. #[ORM\Entity(repositoryClass: 'App\Repository\ImportFileRepository')]
  19. #[Vich\Uploadable]
  20. class ImportFile
  21. {
  22.     use TimestampableEntity;
  26.     #[ORM\Id]
  27.     #[ORM\GeneratedValue]
  28.     #[ORM\Column(type: 'integer')]
  29.     private $id;
  31.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  32.     private $file;
  34.     #[ORM\Column(type: 'integer')]
  35.     private $total = 0;
  37.     #[ORM\Column(type: 'integer')]
  38.     private $done = 0;
  40.     #[ORM\Column(length: 255)]
  41.     private ImportFileType $type;
  43.     #[ORM\Column(length: 255)]
  44.     private ImportFileStatus $status = ImportFileStatus::STATUS_NEW;
  46.     #[ORM\Column(type: 'integer')]
  47.     private $processed = 0;
  49.     #[ORM\Column(type: 'integer')]
  50.     private $success = 0;
  52.     #[ORM\Column(type: 'integer')]
  53.     private $failed = 0;
  55.     #[ORM\Column(type: 'datetime', nullable: true)]
  56.     private $started_at;
  58.     #[ORM\Column(type: 'datetime', nullable: true)]
  59.     private $completed_at;
  61.     #[ORM\Column(type: 'json', nullable: true)]
  62.     private $errors = [];
  64.     #[ORM\Column(type: 'json', nullable: true)]
  65.     private $data = [];
  67.     public $dataFormatted;
  68.     public function getId(): ?int
  69.     {
  70.         return $this->id;
  71.     }
  73.     public function getFile(): ?string
  74.     {
  75.         return $this->file;
  76.     }
  78.     public function setFile(?string $file): self
  79.     {
  80.         $this->file = $file;
  82.         return $this;
  83.     }
  86.     #[Vich\UploadableField(mapping: "import_file", fileNameProperty: "file")]
  87.     private $uploadedFile;
  89.     #[ORM\ManyToOne(inversedBy: 'importFiles')]
  90.     private ?User $user = null;
  92.     #[ORM\OneToMany(mappedBy: 'importFile', targetEntity: Order::class)]
  93.     private Collection $orders;
  95.     public function __construct()
  96.     {
  97.         $this->orders = new ArrayCollection();
  98.     }
  101.     public function getTotal(): ?int
  102.     {
  103.         return $this->total;
  104.     }
  106.     public function setTotal(int $total): self
  107.     {
  108.         $this->total = $total;
  110.         return $this;
  111.     }
  113.     public function getDone(): ?int
  114.     {
  115.         return $this->done;
  116.     }
  118.     public function setDone(int $done): self
  119.     {
  120.         $this->done = $done;
  122.         return $this;
  123.     }
  125.     public function getStatus(): ?ImportFileStatus
  126.     {
  127.         return $this->status;
  128.     }
  130.     public function setStatus(ImportFileStatus $status): self
  131.     {
  132.         $this->status = $status;
  134.         return $this;
  135.     }
  137.     public function getData(): ?array
  138.     {
  139.         return $this->data;
  140.     }
  142.     public function setData(?array $data): self
  143.     {
  144.         $this->data = $data;
  146.         return $this;
  147.     }
  149.     /**
  150.      * If manually uploading a file (i.e. not using Symfony Form) ensure an instance
  151.      * of 'UploadedFile' is injected into this setter to trigger the update. If this
  152.      * bundle's configuration parameter 'inject_on_load' is set to 'true' this setter
  153.      * must be able to accept an instance of 'File' as the bundle will inject one here
  154.      * during Doctrine hydration.
  155.      *
  156.      * @param File|UploadedFile|null $uploadedFile
  157.      */
  158.     public function setUploadedFile(?File $uploadedFile = null): void
  159.     {
  160.         $this->uploadedFile = $uploadedFile;
  162.         if (null !== $uploadedFile) {
  163.             // It is required that at least one field changes if you are using doctrine
  164.             // otherwise the event listeners won't be called and the file is lost
  165.             $this->updatedAt = new DateTimeImmutable();
  166.         }
  167.     }
  169.     /**
  170.      * @return File|null
  171.      */
  172.     public function getUploadedFile(): ?File
  173.     {
  174.         return $this->uploadedFile;
  175.     }
  179.     /**
  180.      * @return mixed
  181.      */
  182.     public function getType(): ImportFileType
  183.     {
  184.         return $this->type;
  185.     }
  187.     /**
  188.      * @param mixed $type
  189.      */
  190.     public function setType(ImportFileType $type): void
  191.     {
  192.         $this->type = $type;
  193.     }
  198.     public function getProcessed(): ?int
  199.     {
  200.         return $this->processed;
  201.     }
  203.     public function setProcessed(int $processed): self
  204.     {
  205.         $this->processed = $processed;
  207.         return $this;
  208.     }
  210.     public function getSuccess(): ?int
  211.     {
  212.         return $this->success;
  213.     }
  215.     public function setSuccess(int $success): self
  216.     {
  217.         $this->success = $success;
  219.         return $this;
  220.     }
  222.     public function getFailed(): ?int
  223.     {
  224.         return $this->failed;
  225.     }
  227.     public function setFailed(int $failed): self
  228.     {
  229.         $this->failed = $failed;
  231.         return $this;
  232.     }
  234.     public function getStartedAt(): ?DateTimeInterface
  235.     {
  236.         return $this->started_at;
  237.     }
  239.     public function setStartedAt(?DateTimeInterface $started_at): self
  240.     {
  241.         $this->started_at = $started_at;
  243.         return $this;
  244.     }
  246.     public function getCompletedAt(): ?DateTimeInterface
  247.     {
  248.         return $this->completed_at;
  249.     }
  251.     public function setCompletedAt(?DateTimeInterface $completed_at): self
  252.     {
  253.         $this->completed_at = $completed_at;
  255.         return $this;
  256.     }
  258.     public function getErrors(): ?array
  259.     {
  260.         return $this->errors;
  261.     }
  263.     public function setErrors(?array $errors): self
  264.     {
  265.         $this->errors = $errors;
  267.         return $this;
  268.     }
  270.     public function getUser(): ?User
  271.     {
  272.         return $this->user;
  273.     }
  275.     public function setUser(?User $user): static
  276.     {
  277.         $this->user = $user;
  279.         return $this;
  280.     }
  283.     public function __toString(): string
  284.     {
  285.         return $this->file;
  286.     }
  288.     /**
  289.      * @return Collection<int, Order>
  290.      */
  291.     public function getOrders(): Collection
  292.     {
  293.         return $this->orders;
  294.     }
  296.     public function addOrder(Order $order): static
  297.     {
  298.         if (!$this->orders->contains($order)) {
  299.             $this->orders->add($order);
  300.             $order->setImportFile($this);
  301.         }
  303.         return $this;
  304.     }
  306.     public function removeOrder(Order $order): static
  307.     {
  308.         if ($this->orders->removeElement($order)) {
  309.             // set the owning side to null (unless already changed)
  310.             if ($order->getImportFile() === $this) {
  311.                 $order->setImportFile(null);
  312.             }
  313.         }
  315.         return $this;
  316.     }
  317. }