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'])]
  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'])]
  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.     #[ORM\OneToMany(mappedBy: 'storage', targetEntity: OrderProduct::class)]
  97.     private Collection $orderProducts;
  99.     public function __construct()
  100.     {
  101.         $this->incomingInvoices = new ArrayCollection();
  102.         $this->incomingInvoiceProducts = new ArrayCollection();
  103.         $this->orders = new ArrayCollection();
  104.         $this->products = new ArrayCollection();
  105.         $this->storageElements = new ArrayCollection();
  106.         $this->productBalanceInStorages = new ArrayCollection();
  107.         $this->location = new ArrayCollection();
  108.         $this->orderProducts = new ArrayCollection();
  109.     }
  111.     public function getId(): ?int
  112.     {
  113.         return $this->id;
  114.     }
  116.     public function getName(): ?string
  117.     {
  118.         return $this->name;
  119.     }
  121.     public function setName(?string $name): self
  122.     {
  123.         $this->name = $name;
  125.         return $this;
  126.     }
  128.     public function getDateEntered(): ?\DateTimeInterface
  129.     {
  130.         return $this->date_entered;
  131.     }
  133.     public function setDateEntered(?\DateTimeInterface $date_entered): self
  134.     {
  135.         $this->date_entered = $date_entered;
  137.         return $this;
  138.     }
  140.     public function getDateModified(): ?\DateTimeInterface
  141.     {
  142.         return $this->date_modified;
  143.     }
  145.     public function setDateModified(?\DateTimeInterface $date_modified): self
  146.     {
  147.         $this->date_modified = $date_modified;
  149.         return $this;
  150.     }
  152.     public function getCreatedBy(): ?User
  153.     {
  154.         return $this->created_by;
  155.     }
  157.     public function setCreatedBy(?User $created_by): self
  158.     {
  159.         $this->created_by = $created_by;
  161.         return $this;
  162.     }
  164.     public function getModifiedUser(): ?User
  165.     {
  166.         return $this->modified_user;
  167.     }
  169.     public function setModifiedUser(?User $modified_user): self
  170.     {
  171.         $this->modified_user = $modified_user;
  173.         return $this;
  174.     }
  176.     public function getStatus(): ?string
  177.     {
  178.         return $this->status;
  179.     }
  181.     public function setStatus(?string $status): self
  182.     {
  183.         $this->status = $status;
  185.         return $this;
  186.     }
  188.     public function getDescription(): ?string
  189.     {
  190.         return $this->description;
  191.     }
  193.     public function setDescription(?string $description): self
  194.     {
  195.         $this->description = $description;
  197.         return $this;
  198.     }
  200.     public function getStockId(): ?string
  201.     {
  202.         return $this->stock_id;
  203.     }
  205.     public function setStockId(?string $stock_id): self
  206.     {
  207.         $this->stock_id = $stock_id;
  209.         return $this;
  210.     }
  212.     public function getParent(): ?self
  213.     {
  214.         return $this->parent;
  215.     }
  217.     public function setParent(?self $parent): self
  218.     {
  219.         $this->parent = $parent;
  221.         return $this;
  222.     }
  224.     public function getC1Id(): ?string
  225.     {
  226.         return $this->c1id;
  227.     }
  229.     public function setC1Id(?string $c1id): self
  230.     {
  231.         $this->c1id = $c1id;
  233.         return $this;
  234.     }
  236.     /**
  237.      * @return Collection<int, IncomingInvoice>
  238.      */
  239.     public function getIncomingInvoices(): Collection
  240.     {
  241.         return $this->incomingInvoices;
  242.     }
  244.     public function addIncomingInvoice(IncomingInvoice $incomingInvoice): self
  245.     {
  246.         if (!$this->incomingInvoices->contains($incomingInvoice)) {
  247.             $this->incomingInvoices->add($incomingInvoice);
  248.             $incomingInvoice->setStorage($this);
  249.         }
  251.         return $this;
  252.     }
  254.     public function removeIncomingInvoice(IncomingInvoice $incomingInvoice): self
  255.     {
  256.         if ($this->incomingInvoices->removeElement($incomingInvoice)) {
  257.             // set the owning side to null (unless already changed)
  258.             if ($incomingInvoice->getStorage() === $this) {
  259.                 $incomingInvoice->setStorage(null);
  260.             }
  261.         }
  263.         return $this;
  264.     }
  266.     /**
  267.      * @return Collection<int, IncomingInvoiceProduct>
  268.      */
  269.     public function getIncomingInvoiceProducts(): Collection
  270.     {
  271.         return $this->incomingInvoiceProducts;
  272.     }
  274.     public function addIncomingInvoiceProduct(IncomingInvoiceProduct $incomingInvoiceProduct): self
  275.     {
  276.         if (!$this->incomingInvoiceProducts->contains($incomingInvoiceProduct)) {
  277.             $this->incomingInvoiceProducts->add($incomingInvoiceProduct);
  278.             $incomingInvoiceProduct->setStorage($this);
  279.         }
  281.         return $this;
  282.     }
  284.     public function removeIncomingInvoiceProduct(IncomingInvoiceProduct $incomingInvoiceProduct): self
  285.     {
  286.         if ($this->incomingInvoiceProducts->removeElement($incomingInvoiceProduct)) {
  287.             // set the owning side to null (unless already changed)
  288.             if ($incomingInvoiceProduct->getStorage() === $this) {
  289.                 $incomingInvoiceProduct->setStorage(null);
  290.             }
  291.         }
  293.         return $this;
  294.     }
  296.     /**
  297.      * @return Collection<int, Orders>
  298.      */
  299.     public function getOrders(): Collection
  300.     {
  301.         return $this->orders;
  302.     }
  304.     public function addOrder(Orders $order): self
  305.     {
  306.         if (!$this->orders->contains($order)) {
  307.             $this->orders->add($order);
  308.             $order->setStorage($this);
  309.         }
  311.         return $this;
  312.     }
  314.     public function removeOrder(Orders $order): self
  315.     {
  316.         if ($this->orders->removeElement($order)) {
  317.             // set the owning side to null (unless already changed)
  318.             if ($order->getStorage() === $this) {
  319.                 $order->setStorage(null);
  320.             }
  321.         }
  323.         return $this;
  324.     }
  327.     #[ORM\PrePersist]
  328.     public function setCreatedAtValue(): void
  329.     {
  330.         $this->date_entered = new \DateTime();
  331.     }
  333.     // #[ORM\PrePersist]
  334.     #[ORM\PreUpdate]
  335.     public function setUpdatedAtValue(): void
  336.     {
  337.         $this->date_modified = new \DateTime();
  338.     }
  340.     public function getCode1c(): ?string
  341.     {
  342.         return $this->code1c;
  343.     }
  345.     public function setCode1c(?string $code1c): self
  346.     {
  347.         $this->code1c = $code1c;
  348.         return $this;
  349.     }
  351.     /**
  352.      * @return Collection<int, Products>
  353.      */
  354.     public function getProducts(): Collection
  355.     {
  356.         return $this->products;
  357.     }
  359.     public function addProduct(Products $product): self
  360.     {
  361.         if (!$this->products->contains($product)) {
  362.             $this->products->add($product);
  363.             $product->setStorage($this);
  364.         }
  366.         return $this;
  367.     }
  369.     public function removeProduct(Products $product): self
  370.     {
  371.         if ($this->products->removeElement($product)) {
  372.             // set the owning side to null (unless already changed)
  373.             if ($product->getStorage() === $this) {
  374.                 $product->setStorage(null);
  375.             }
  376.         }
  378.         return $this;
  379.     }
  381.     /**
  382.      * @return Collection<int, StorageElement>
  383.      */
  384.     public function getStorageElements(): Collection
  385.     {
  386.         return $this->storageElements;
  387.     }
  389.     public function addStorageElement(StorageElement $storageElement): self
  390.     {
  391.         if (!$this->storageElements->contains($storageElement)) {
  392.             $this->storageElements->add($storageElement);
  393.             $storageElement->setStorage($this);
  394.         }
  396.         return $this;
  397.     }
  399.     public function removeStorageElement(StorageElement $storageElement): self
  400.     {
  401.         if ($this->storageElements->removeElement($storageElement)) {
  402.             // set the owning side to null (unless already changed)
  403.             if ($storageElement->getStorage() === $this) {
  404.                 $storageElement->setStorage(null);
  405.             }
  406.         }
  408.         return $this;
  409.     }
  411.     /**
  412.      * @return Collection<int, ProductBalanceInStorage>
  413.      */
  414.     public function getProductBalanceInStorages(): Collection
  415.     {
  416.         return $this->productBalanceInStorages;
  417.     }
  419.     public function addProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  420.     {
  421.         if (!$this->productBalanceInStorages->contains($productBalanceInStorage)) {
  422.             $this->productBalanceInStorages->add($productBalanceInStorage);
  423.             $productBalanceInStorage->setStorage($this);
  424.         }
  426.         return $this;
  427.     }
  429.     public function removeProductBalanceInStorage(ProductBalanceInStorage $productBalanceInStorage): self
  430.     {
  431.         if ($this->productBalanceInStorages->removeElement($productBalanceInStorage)) {
  432.             // set the owning side to null (unless already changed)
  433.             if ($productBalanceInStorage->getStorage() === $this) {
  434.                 $productBalanceInStorage->setStorage(null);
  435.             }
  436.         }
  438.         return $this;
  439.     }
  441.     /**
  442.      * @return Collection<int, Location>
  443.      */
  444.     public function getLocation(): Collection
  445.     {
  446.         return $this->location;
  447.     }
  449.     public function addLocation(Location $location): self
  450.     {
  451.         if (!$this->location->contains($location)) {
  452.             $this->location->add($location);
  453.         }
  455.         return $this;
  456.     }
  458.     public function removeLocation(Location $location): self
  459.     {
  460.         $this->location->removeElement($location);
  462.         return $this;
  463.     }
  465.     /**
  466.      * @return Collection<int, OrderProduct>
  467.      */
  468.     public function getOrderProducts(): Collection
  469.     {
  470.         return $this->orderProducts;
  471.     }
  473.     public function addOrderProduct(OrderProduct $orderProduct): static
  474.     {
  475.         if (!$this->orderProducts->contains($orderProduct)) {
  476.             $this->orderProducts->add($orderProduct);
  477.             $orderProduct->setStorage($this);
  478.         }
  480.         return $this;
  481.     }
  483.     public function removeOrderProduct(OrderProduct $orderProduct): static
  484.     {
  485.         if ($this->orderProducts->removeElement($orderProduct)) {
  486.             // set the owning side to null (unless already changed)
  487.             if ($orderProduct->getStorage() === $this) {
  488.                 $orderProduct->setStorage(null);
  489.             }
  490.         }
  492.         return $this;
  493.     }
  494. }