src/Entity/Sales.php line 14

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Enum\SalesStatus;
  6. use App\Repository\SalesRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\ORM\Mapping as ORM;
  11. #[ORM\Entity(repositoryClass: SalesRepository::class)]
  12. #[ORM\HasLifecycleCallbacks]
  13. #[ORM\Table(name: 'sales')]
  14. class Sales extends BaseEntity
  15. {
  16.     #[ORM\Id]
  17.     #[ORM\GeneratedValue]
  18.     #[ORM\Column(type: 'integer')]
  19.     private $id;
  21.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  22.     private $invoiceNumber;
  24.     #[ORM\Column(type: 'decimal', precision: 19, scale: 4)]
  25.     private $totalPurchasePrice;
  27.     #[ORM\OneToMany(mappedBy: 'sales', targetEntity: ProductsSold::class)]
  28.     private $productsSolds;
  30.     #[ORM\ManyToOne(targetEntity: User::class, inversedBy: 'sales')]
  31.     #[ORM\JoinColumn(nullable: false)]
  32.     private $seller;
  34.     #[ORM\ManyToOne(targetEntity: Warehouse::class, inversedBy: 'sales')]
  35.     private $warehouse;
  37.     #[ORM\Column(type: 'date', nullable: true)]
  38.     private $salesDate;
  40.     #[ORM\Column(type: 'date', nullable: true)]
  41.     private $deliveryDate;
  43.     #[ORM\Column(type: 'date', nullable: true)]
  44.     private $dueDate;
  46.     #[ORM\Column(type: 'date', nullable: true)]
  47.     private $validDate;
  49.     #[ORM\ManyToOne(targetEntity: Customer::class, inversedBy: 'sales')]
  50.     #[ORM\JoinColumn(nullable: false)]
  51.     private $customer;
  53.     #[ORM\OneToMany(mappedBy: 'sales', targetEntity: Payment::class)]
  54.     private $payments;
  56.     #[ORM\OneToMany(mappedBy: 'sale', targetEntity: StockTransaction::class)]
  57.     private $stockTransactions;
  59.     #[ORM\OneToMany(mappedBy: 'sale', targetEntity: SalesReturn::class, cascade: ['persist'], orphanRemoval: true)]
  60.     private Collection $returns;
  62.     #[ORM\OneToMany(mappedBy: 'sale', targetEntity: EmailMessage::class)]
  63.     private Collection $emailMessages;
  65.     #[ORM\OneToMany(mappedBy: 'sale', targetEntity: SalesHistory::class, cascade: ['persist'], orphanRemoval: true)]
  66.     private Collection $historyEntries;
  68.     #[ORM\OneToMany(mappedBy: 'sale', targetEntity: GiftProduct::class, cascade: ['persist'], orphanRemoval: true)]
  69.     private Collection $giftProducts;
  71.     #[ORM\OneToOne(targetEntity: Invoice::class, inversedBy: 'proforma', cascade: ['persist', 'remove'], orphanRemoval: true)]
  72.     #[ORM\JoinColumn(name: 'invoice_id', referencedColumnName: 'id', nullable: true, onDelete: 'SET NULL')]
  73.     private ?Invoice $invoice = null;
  75.     #[ORM\Column(length: 255, nullable: true)]
  76.     private ?string $description = null;
  78.     #[ORM\Column(length: 255, nullable: true)]
  79.     private ?string $shippingNotes = null;
  81.     #[ORM\Column(length: 255, nullable: true)]
  82.     private ?string $paymentNotes = null;
  84.     #[ORM\Column(length: 255, nullable: true)]
  85.     private SalesStatus|null $status = null;
  87.     #[ORM\Column]
  88.     private ?bool $visible = true;
  90.     #[ORM\Column(nullable: true)]
  91.     private ?bool $deleted = false;
  93.     /**
  94.      * @return mixed
  95.      */
  96.     public function getCustomer()
  97.     {
  98.         return $this->customer;
  99.     }
  101.     /**
  102.      * @param mixed $customer
  103.      */
  104.     public function setCustomer($customer): void
  105.     {
  106.         $this->customer = $customer;
  107.     }
  111.     public function __construct()
  112.     {
  113.         $this->productsSolds = new ArrayCollection();
  114.         $this->payments = new ArrayCollection();
  115.         $this->stockTransactions = new ArrayCollection();
  116.         $this->emailMessages = new ArrayCollection();
  117.         $this->historyEntries = new ArrayCollection();
  118.         $this->returns = new ArrayCollection();
  119.         $this->giftProducts = new ArrayCollection();
  120.     }
  122.     /**
  123.      * @return Collection<int, SalesReturn>
  124.      */
  125.     public function getReturns(): Collection
  126.     {
  127.         return $this->returns;
  128.     }
  130.     public function addReturn(SalesReturn $salesReturn): self
  131.     {
  132.         if (!$this->returns->contains($salesReturn)) {
  133.             $this->returns->add($salesReturn);
  134.             $salesReturn->setSale($this);
  135.         }
  137.         return $this;
  138.     }
  140.     public function removeReturn(SalesReturn $salesReturn): self
  141.     {
  142.         if ($this->returns->removeElement($salesReturn)) {
  143.             if ($salesReturn->getSale() === $this) {
  144.                 $salesReturn->setSale(null);
  145.             }
  146.         }
  148.         return $this;
  149.     }
  152.     public function getId(): ?int
  153.     {
  154.         return $this->id;
  155.     }
  157.     public function getInvoiceNumber(): ?string
  158.     {
  159.         return $this->invoiceNumber;
  160.     }
  162.     public function setInvoiceNumber(?string $invoiceNumber): self
  163.     {
  164.         $this->invoiceNumber = $invoiceNumber;
  166.         return $this;
  167.     }
  169.     /**
  170.      * @return Collection<int, EmailMessage>
  171.      */
  172.     public function getEmailMessages(): Collection
  173.     {
  174.         return $this->emailMessages;
  175.     }
  177.     public function addEmailMessage(EmailMessage $emailMessage): self
  178.     {
  179.         if (!$this->emailMessages->contains($emailMessage)) {
  180.             $this->emailMessages->add($emailMessage);
  181.             $emailMessage->setSale($this);
  182.         }
  184.         return $this;
  185.     }
  187.     public function removeEmailMessage(EmailMessage $emailMessage): self
  188.     {
  189.         if ($this->emailMessages->removeElement($emailMessage)) {
  190.             if ($emailMessage->getSale() === $this) {
  191.                 $emailMessage->setSale(null);
  192.             }
  193.         }
  195.         return $this;
  196.     }
  198.     /**
  199.      * @return Collection<int, SalesHistory>
  200.      */
  201.     public function getHistoryEntries(): Collection
  202.     {
  203.         return $this->historyEntries;
  204.     }
  206.     public function addHistoryEntry(SalesHistory $historyEntry): self
  207.     {
  208.         if (!$this->historyEntries->contains($historyEntry)) {
  209.             $this->historyEntries->add($historyEntry);
  210.             $historyEntry->setSale($this);
  211.         }
  213.         return $this;
  214.     }
  216.     public function removeHistoryEntry(SalesHistory $historyEntry): self
  217.     {
  218.         if ($this->historyEntries->removeElement($historyEntry)) {
  219.             if ($historyEntry->getSale() === $this) {
  220.                 $historyEntry->setSale(null);
  221.             }
  222.         }
  224.         return $this;
  225.     }
  227.     /**
  228.      * @return mixed
  229.      */
  230.     public function getSalesDate()
  231.     {
  232.         return $this->salesDate;
  233.     }
  235.     /**
  236.      * @param mixed $salesDate
  237.      */
  238.     public function setSalesDate($salesDate): void
  239.     {
  240.         $this->salesDate = $salesDate;
  241.     }
  243.     public function getTotalPurchasePrice(): ?float
  244.     {
  245.         return $this->totalPurchasePrice;
  246.     }
  248.     public function setTotalPurchasePrice(float $totalPurchasePrice): self
  249.     {
  250.         $this->totalPurchasePrice = $totalPurchasePrice;
  252.         return $this;
  253.     }
  256.     /**
  257.      * @return Collection<int, ProductsSold>
  258.      */
  259.     public function getProductsSolds(): Collection
  260.     {
  261.         return $this->productsSolds;
  262.     }
  264.     public function addProductsSold(ProductsSold $productsSold): self
  265.     {
  266.         if (!$this->productsSolds->contains($productsSold)) {
  267.             $this->productsSolds[] = $productsSold;
  268.             $productsSold->setSales($this);
  269.         }
  271.         return $this;
  272.     }
  274.     public function removeProductsSold(ProductsSold $productsSold): self
  275.     {
  276.         if ($this->productsSolds->removeElement($productsSold)) {
  277.             // set the owning side to null (unless already changed)
  278.             if ($productsSold->getSales() === $this) {
  279.                 $productsSold->setSales(null);
  280.             }
  281.         }
  283.         return $this;
  284.     }
  286.     public function getSeller(): ?User
  287.     {
  288.         return $this->seller;
  289.     }
  291.     public function setSeller(?User $seller): self
  292.     {
  293.         $this->seller = $seller;
  295.         return $this;
  296.     }
  298.     public function getWarehouse(): ?Warehouse
  299.     {
  300.         return $this->warehouse;
  301.     }
  303.     public function setWarehouse(?Warehouse $warehouse): self
  304.     {
  305.         $this->warehouse = $warehouse;
  307.         return $this;
  308.     }
  310.     /**
  311.      * @return Collection<int, Payment>
  312.      */
  313.     public function getPayments(): Collection
  314.     {
  315.         return $this->payments;
  316.     }
  318.     public function addPayment(Payment $payment): self
  319.     {
  320.         if (!$this->payments->contains($payment)) {
  321.             $this->payments[] = $payment;
  322.             $payment->setSales($this);
  323.         }
  325.         return $this;
  326.     }
  328.     public function removePayment(Payment $payment): self
  329.     {
  330.         if ($this->payments->removeElement($payment)) {
  331.             // set the owning side to null (unless already changed)
  332.             if ($payment->getSales() === $this) {
  333.                 $payment->setSales(null);
  334.             }
  335.         }
  337.         return $this;
  338.     }
  340.     /**
  341.      * @return Collection<int, StockTransaction>
  342.      */
  343.     public function getStockTransactions(): Collection
  344.     {
  345.         return $this->stockTransactions;
  346.     }
  348.     public function addStockTransaction(StockTransaction $stockTransaction): self
  349.     {
  350.         if (!$this->stockTransactions->contains($stockTransaction)) {
  351.             $this->stockTransactions[] = $stockTransaction;
  352.             $stockTransaction->setSale($this);
  353.         }
  355.         return $this;
  356.     }
  358.     public function removeStockTransaction(StockTransaction $stockTransaction): self
  359.     {
  360.         if ($this->stockTransactions->removeElement($stockTransaction)) {
  361.             // set the owning side to null (unless already changed)
  362.             if ($stockTransaction->getSale() === $this) {
  363.                 $stockTransaction->setSale(null);
  364.             }
  365.         }
  367.         return $this;
  368.     }
  370.     public function getInvoice(): ?Invoice
  371.     {
  372.         return $this->invoice;
  373.     }
  375.     public function setInvoice(?Invoice $invoice): self
  376.     {
  377.         $this->invoice = $invoice;
  379.         return $this;
  380.     }
  382.     public function getDescription(): ?string
  383.     {
  384.         return $this->description;
  385.     }
  387.     public function setDescription(?string $description): static
  388.     {
  389.         $this->description = $description;
  391.         return $this;
  392.     }
  394.     public function getShippingNotes(): ?string
  395.     {
  396.         return $this->shippingNotes;
  397.     }
  399.     public function setShippingNotes(?string $shippingNotes): static
  400.     {
  401.         $this->shippingNotes = $shippingNotes;
  403.         return $this;
  404.     }
  406.     public function getPaymentNotes(): ?string
  407.     {
  408.         return $this->paymentNotes;
  409.     }
  411.     public function setPaymentNotes(?string $paymentNotes): static
  412.     {
  413.         $this->paymentNotes = $paymentNotes;
  415.         return $this;
  416.     }
  418.     /**
  419.      * @return mixed
  420.      */
  421.     public function getDeliveryDate()
  422.     {
  423.         return $this->deliveryDate;
  424.     }
  426.     /**
  427.      * @param mixed $deliveryDate
  428.      */
  429.     public function setDeliveryDate($deliveryDate): void
  430.     {
  431.         $this->deliveryDate = $deliveryDate;
  432.     }
  434.     /**
  435.      * @return mixed
  436.      */
  437.     public function getDueDate()
  438.     {
  439.         return $this->dueDate;
  440.     }
  442.     /**
  443.      * @param mixed $dueDate
  444.      */
  445.     public function setDueDate($dueDate): void
  446.     {
  447.         $this->dueDate = $dueDate;
  448.     }
  450.     /**
  451.      * @return mixed
  452.      */
  453.     public function getValidDate()
  454.     {
  455.         return $this->validDate;
  456.     }
  458.     /**
  459.      * @param mixed $validDate
  460.      */
  461.     public function setValidDate($validDate): void
  462.     {
  463.         $this->validDate = $validDate;
  464.     }
  466.     public function getStatus(): ?SalesStatus
  467.     {
  468.         return $this->status;
  469.     }
  471.     public function setStatus(?SalesStatus $status): void
  472.     {
  473.         $this->status = $status;
  474.     }
  476.     public function isVisible(): ?bool
  477.     {
  478.         return $this->visible;
  479.     }
  481.     public function setVisible(bool $visible): static
  482.     {
  483.         $this->visible = $visible;
  485.         return $this;
  486.     }
  488.     public function isDeleted(): ?bool
  489.     {
  490.         return $this->deleted;
  491.     }
  493.     public function setDeleted(?bool $deleted): self
  494.     {
  495.         $this->deleted = $deleted;
  497.         return $this;
  498.     }
  500.     /**
  501.      * @return Collection<int, GiftProduct>
  502.      */
  503.     public function getGiftProducts(): Collection
  504.     {
  505.         return $this->giftProducts;
  506.     }
  508.     public function addGiftProduct(GiftProduct $giftProduct): self
  509.     {
  510.         if (!$this->giftProducts->contains($giftProduct)) {
  511.             $this->giftProducts->add($giftProduct);
  512.             $giftProduct->setSale($this);
  513.         }
  515.         return $this;
  516.     }
  518.     public function removeGiftProduct(GiftProduct $giftProduct): self
  519.     {
  520.         if ($this->giftProducts->removeElement($giftProduct)) {
  521.             if ($giftProduct->getSale() === $this) {
  522.                 $giftProduct->setSale(null);
  523.             }
  524.         }
  526.         return $this;
  527.     }
  530. }