src/Entity/Storage.php line 25

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Metadata\ApiResource;
  6. use App\Repository\StorageRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\DBAL\Types\Types;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use ApiPlatform\Metadata\ApiFilter;
  12. use ApiPlatform\Doctrine\Orm\Filter\SearchFilter;
  13. use Symfony\Component\Serializer\Annotation\Groups;
  16. #[ORM\Entity(repositoryClass: StorageRepository::class)]
  17. #[ApiResource(
  18.     normalizationContext: ['groups' => ['storage:read']],
  19.     denormalizationContext: ['groups' => ['storage:write']],
  20.     order: ['id' => 'DESC']
  21. )]
  22. #[ApiFilter(SearchFilter::class, properties: ['code1c' => 'exact', 'name' => 'ipartial'])]
  23. #[ORM\HasLifecycleCallbacks]
  25. class Storage 
  26. {
  27.     #[ORM\Id]
  28.     #[ORM\GeneratedValue]
  29.     #[ORM\Column]
  30.     #[Groups(['storage:read', 'storage:write', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invocie:read', 'storage_element:read', 'product:read', 'order_product:read', 'product_storage_balance:read'])]
  31.     private ?int $id = null;
  33.     #[ORM\Column(length: 255, nullable: true)]
  34.     #[Groups(['storage:read', 'storage:write', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invocie:read', 'storage_element:read', 'product:read', 'order_product:read', 'product_storage_balance:read'])]
  35.     private ?string $name = null;
  37.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  38.     private ?\DateTimeInterface $date_entered = null;
  40.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  41.     private ?\DateTimeInterface $date_modified = null;
  43.     #[ORM\ManyToOne]
  44.     private ?User $created_by = null;
  46.     #[ORM\ManyToOne]
  47.     private ?User $modified_user = null;
  49.     #[ORM\Column(length: 100, nullable: true)]
  50.     #[Groups(['storage:read', 'storage:write'])]
  51.     private ?string $status = null;
  53.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  54.     #[Groups(['storage:read', 'storage:write'])]
  55.     private ?string $description = null;
  57.     #[ORM\Column(length: 20, nullable: true)]
  58.     #[Groups(['storage:read', 'storage:write'])]
  59.     private ?string $stock_id = null;
  61.     #[ORM\ManyToOne(targetEntity: self::class)]
  62.     #[Groups(['storage:read', 'storage:write'])]
  63.     private ?self $parent = null;
  65.     #[ORM\Column(length: 20, nullable: true)]
  66.     #[Groups(['storage:read', 'storage:write', 'storage_element:read', 'product:read', 'order:read', 'order_product:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'product_storage_balance:read', 'product:read'])]
  67.     private ?string $c1id = null;
  69.     #[ORM\OneToMany(mappedBy: 'storage', targetEntity: IncomingInvoice::class)]
  70.     private Collection $incomingInvoices;
  72.     #[ORM\OneToMany(mappedBy: 'storage', targetEntity: IncomingInvoiceProduct::class)]
  73.     private Collection $incomingInvoiceProducts;
  75.     #[ORM\OneToMany(mappedBy: 'storage', targetEntity: Orders::class)]
  76.     private Collection $orders;
  78.     #[ORM\Column(length: 20, nullable: true)]
  79.     #[Groups(['storage:read', 'storage:write', 'order:read', 'order_product:read', 'pre_order_product:read', 'pre_order:read', 'load_invocie:read', 'product_storage_balance:read', 'product:read'])]
  80.     private ?string $code1c = null;
  82.     #[ORM\OneToMany(mappedBy: 'storage', targetEntity: Products::class)]
  83.     private Collection $products;
  85.     #[Groups(['storage:read', 'storage:write', 'product:read'])]
  86.     #[ORM\OneToMany(mappedBy: 'storage', targetEntity: StorageElement::class)]
  87.     private Collection $storageElements;
  89.     #[ORM\OneToMany(mappedBy: 'storage', targetEntity: ProductBalanceInStorage::class)]
  90.     private Collection $productBalanceInStorages;
  92.     #[Groups(['storage:read', 'storage:write'])]
  93.     #[ORM\ManyToMany(targetEntity: Location::class, inversedBy: 'storages', cascade:['persist', 'remove'])]
  94.     private Collection $location;
  96.     public function __construct()
  97.     {
  98.         $this->incomingInvoices = new ArrayCollection();
  99.         $this->incomingInvoiceProducts = new ArrayCollection();
  100.         $this->orders = new ArrayCollection();
  101.         $this->products = new ArrayCollection();
  102.         $this->storageElements = new ArrayCollection();
  103.         $this->productBalanceInStorages = new ArrayCollection();
  104.         $this->location = new ArrayCollection();
  105.     }
  107.     public function getId(): ?int
  108.     {
  109.         return $this->id;
  110.     }
  112.     public function getName(): ?string
  113.     {
  114.         return $this->name;
  115.     }
  117.     public function setName(?string $name): self
  118.     {
  119.         $this->name = $name;
  121.         return $this;
  122.     }
  124.     public function getDateEntered(): ?\DateTimeInterface
  125.     {
  126.         return $this->date_entered;
  127.     }
  129.     public function setDateEntered(?\DateTimeInterface $date_entered): self
  130.     {
  131.         $this->date_entered = $date_entered;
  133.         return $this;
  134.     }
  136.     public function getDateModified(): ?\DateTimeInterface
  137.     {
  138.         return $this->date_modified;
  139.     }
  141.     public function setDateModified(?\DateTimeInterface $date_modified): self
  142.     {
  143.         $this->date_modified = $date_modified;
  145.         return $this;
  146.     }
  148.     public function getCreatedBy(): ?User
  149.     {
  150.         return $this->created_by;
  151.     }
  153.     public function setCreatedBy(?User $created_by): self
  154.     {
  155.         $this->created_by = $created_by;
  157.         return $this;
  158.     }
  160.     public function getModifiedUser(): ?User
  161.     {
  162.         return $this->modified_user;
  163.     }
  165.     public function setModifiedUser(?User $modified_user): self
  166.     {
  167.         $this->modified_user = $modified_user;
  169.         return $this;
  170.     }
  172.     public function getStatus(): ?string
  173.     {
  174.         return $this->status;
  175.     }
  177.     public function setStatus(?string $status): self
  178.     {
  179.         $this->status = $status;
  181.         return $this;
  182.     }
  184.     public function getDescription(): ?string
  185.     {
  186.         return $this->description;
  187.     }
  189.     public function setDescription(?string $description): self
  190.     {
  191.         $this->description = $description;
  193.         return $this;
  194.     }
  196.     public function getStockId(): ?string
  197.     {
  198.         return $this->stock_id;
  199.     }
  201.     public function setStockId(?string $stock_id): self
  202.     {
  203.         $this->stock_id = $stock_id;
  205.         return $this;
  206.     }
  208.     public function getParent(): ?self
  209.     {
  210.         return $this->parent;
  211.     }
  213.     public function setParent(?self $parent): self
  214.     {
  215.         $this->parent = $parent;
  217.         return $this;
  218.     }
  220.     public function getC1Id(): ?string
  221.     {
  222.         return $this->c1id;
  223.     }
  225.     public function setC1Id(?string $c1id): self
  226.     {
  227.         $this->c1id = $c1id;
  229.         return $this;
  230.     }
  232.     /**
  233.      * @return Collection<int, IncomingInvoice>
  234.      */
  235.     public function getIncomingInvoices(): Collection
  236.     {
  237.         return $this->incomingInvoices;
  238.     }
  240.     public function addIncomingInvoice(IncomingInvoice $incomingInvoice): self
  241.     {
  242.         if (!$this->incomingInvoices->contains($incomingInvoice)) {
  243.             $this->incomingInvoices->add($incomingInvoice);
  244.             $incomingInvoice->setStorage($this);
  245.         }
  247.         return $this;
  248.     }
  250.     public function removeIncomingInvoice(IncomingInvoice $incomingInvoice): self
  251.     {
  252.         if ($this->incomingInvoices->removeElement($incomingInvoice)) {
  253.             // set the owning side to null (unless already changed)
  254.             if ($incomingInvoice->getStorage() === $this) {
  255.                 $incomingInvoice->setStorage(null);
  256.             }
  257.         }
  259.         return $this;
  260.     }
  262.     /**
  263.      * @return Collection<int, IncomingInvoiceProduct>
  264.      */
  265.     public function getIncomingInvoiceProducts(): Collection
  266.     {
  267.         return $this->incomingInvoiceProducts;
  268.     }
  270.     public function addIncomingInvoiceProduct(IncomingInvoiceProduct $incomingInvoiceProduct): self
  271.     {
  272.         if (!$this->incomingInvoiceProducts->contains($incomingInvoiceProduct)) {
  273.             $this->incomingInvoiceProducts->add($incomingInvoiceProduct);
  274.             $incomingInvoiceProduct->setStorage($this);
  275.         }
  277.         return $this;
  278.     }
  280.     public function removeIncomingInvoiceProduct(IncomingInvoiceProduct $incomingInvoiceProduct): self
  281.     {
  282.         if ($this->incomingInvoiceProducts->removeElement($incomingInvoiceProduct)) {
  283.             // set the owning side to null (unless already changed)
  284.             if ($incomingInvoiceProduct->getStorage() === $this) {
  285.                 $incomingInvoiceProduct->setStorage(null);
  286.             }
  287.         }
  289.         return $this;
  290.     }
  292.     /**
  293.      * @return Collection<int, Orders>
  294.      */
  295.     public function getOrders(): Collection
  296.     {
  297.         return $this->orders;
  298.     }
  300.     public function addOrder(Orders $order): self
  301.     {
  302.         if (!$this->orders->contains($order)) {
  303.             $this->orders->add($order);
  304.             $order->setStorage($this);
  305.         }
  307.         return $this;
  308.     }
  310.     public function removeOrder(Orders $order): self
  311.     {
  312.         if ($this->orders->removeElement($order)) {
  313.             // set the owning side to null (unless already changed)
  314.             if ($order->getStorage() === $this) {
  315.                 $order->setStorage(null);
  316.             }
  317.         }
  319.         return $this;
  320.     }
  323.     #[ORM\PrePersist]
  324.     public function setCreatedAtValue(): void
  325.     {
  326.         $this->date_entered = new \DateTime();
  327.     }
  329.     // #[ORM\PrePersist]
  330.     #[ORM\PreUpdate]
  331.     public function setUpdatedAtValue(): void
  332.     {
  333.         $this->date_modified = new \DateTime();
  334.     }
  336.     public function getCode1c(): ?string
  337.     {
  338.         return $this->code1c;
  339.     }
  341.     public function setCode1c(?string $code1c): self
  342.     {
  343.         $this->code1c = $code1c;
  344.         return $this;
  345.     }
  347.     /**
  348.      * @return Collection<int, Products>
  349.      */
  350.     public function getProducts(): Collection
  351.     {
  352.         return $this->products;
  353.     }
  355.     public function addProduct(Products $product): self
  356.     {
  357.         if (!$this->products->contains($product)) {
  358.             $this->products->add($product);
  359.             $product->setStorage($this);
  360.         }
  362.         return $this;
  363.     }
  365.     public function removeProduct(Products $product): self
  366.     {
  367.         if ($this->products->removeElement($product)) {
  368.             // set the owning side to null (unless already changed)
  369.             if ($product->getStorage() === $this) {
  370.                 $product->setStorage(null);
  371.             }
  372.         }
  374.         return $this;
  375.     }
  377.     /**
  378.      * @return Collection<int, StorageElement>
  379.      */
  380.     public function getStorageElements(): Collection
  381.     {
  382.         return $this->storageElements;
  383.     }
  385.     public function addStorageElement(StorageElement $storageElement): self
  386.     {
  387.         if (!$this->storageElements->contains($storageElement)) {
  388.             $this->storageElements->add($storageElement);
  389.             $storageElement->setStorage($this);
  390.         }
  392.         return $this;
  393.     }
  395.     public function removeStorageElement(StorageElement $storageElement): self
  396.     {
  397.         if ($this->storageElements->removeElement($storageElement)) {
  398.             // set the owning side to null (unless already changed)
  399.             if ($storageElement->getStorage() === $this) {
  400.                 $storageElement->setStorage(null);
  401.             }
  402.         }
  404.         return $this;
  405.     }
  407.     /**
  408.      * @return Collection<int, ProductBalanceInStorage>
  409.      */
  410.     public function getProductBalanceInStorages(): Collection
  411.     {
  412.         return $this->productBalanceInStorages;
  413.     }
  415.     public function addProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  416.     {
  417.         if (!$this->productBalanceInStorages->contains($productBalanceInStorage)) {
  418.             $this->productBalanceInStorages->add($productBalanceInStorage);
  419.             $productBalanceInStorage->setStorage($this);
  420.         }
  422.         return $this;
  423.     }
  425.     public function removeProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  426.     {
  427.         if ($this->productBalanceInStorages->removeElement($productBalanceInStorage)) {
  428.             // set the owning side to null (unless already changed)
  429.             if ($productBalanceInStorage->getStorage() === $this) {
  430.                 $productBalanceInStorage->setStorage(null);
  431.             }
  432.         }
  434.         return $this;
  435.     }
  437.     /**
  438.      * @return Collection<int, Location>
  439.      */
  440.     public function getLocation(): Collection
  441.     {
  442.         return $this->location;
  443.     }
  445.     public function addLocation(Location $location): self
  446.     {
  447.         if (!$this->location->contains($location)) {
  448.             $this->location->add($location);
  449.         }
  451.         return $this;
  452.     }
  454.     public function removeLocation(Location $location): self
  455.     {
  456.         $this->location->removeElement($location);
  458.         return $this;
  459.     }
  460. }