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: 10, scale: 2)]
  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, 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.     /**
  91.      * @return mixed
  92.      */
  93.     public function getCustomer()
  94.     {
  95.         return $this->customer;
  96.     }
  98.     /**
  99.      * @param mixed $customer
  100.      */
  101.     public function setCustomer($customer): void
  102.     {
  103.         $this->customer = $customer;
  104.     }
  108.     public function __construct()
  109.     {
  110.         $this->productsSolds = new ArrayCollection();
  111.         $this->payments = new ArrayCollection();
  112.         $this->stockTransactions = new ArrayCollection();
  113.         $this->emailMessages = new ArrayCollection();
  114.         $this->historyEntries = new ArrayCollection();
  115.         $this->returns = new ArrayCollection();
  116.         $this->giftProducts = new ArrayCollection();
  117.     }
  119.     /**
  120.      * @return Collection<int, SalesReturn>
  121.      */
  122.     public function getReturns(): Collection
  123.     {
  124.         return $this->returns;
  125.     }
  127.     public function addReturn(SalesReturn $salesReturn): self
  128.     {
  129.         if (!$this->returns->contains($salesReturn)) {
  130.             $this->returns->add($salesReturn);
  131.             $salesReturn->setSale($this);
  132.         }
  134.         return $this;
  135.     }
  137.     public function removeReturn(SalesReturn $salesReturn): self
  138.     {
  139.         if ($this->returns->removeElement($salesReturn)) {
  140.             if ($salesReturn->getSale() === $this) {
  141.                 $salesReturn->setSale(null);
  142.             }
  143.         }
  145.         return $this;
  146.     }
  149.     public function getId(): ?int
  150.     {
  151.         return $this->id;
  152.     }
  154.     public function getInvoiceNumber(): ?string
  155.     {
  156.         return $this->invoiceNumber;
  157.     }
  159.     public function setInvoiceNumber(?string $invoiceNumber): self
  160.     {
  161.         $this->invoiceNumber = $invoiceNumber;
  163.         return $this;
  164.     }
  166.     /**
  167.      * @return Collection<int, EmailMessage>
  168.      */
  169.     public function getEmailMessages(): Collection
  170.     {
  171.         return $this->emailMessages;
  172.     }
  174.     public function addEmailMessage(EmailMessage $emailMessage): self
  175.     {
  176.         if (!$this->emailMessages->contains($emailMessage)) {
  177.             $this->emailMessages->add($emailMessage);
  178.             $emailMessage->setSale($this);
  179.         }
  181.         return $this;
  182.     }
  184.     public function removeEmailMessage(EmailMessage $emailMessage): self
  185.     {
  186.         if ($this->emailMessages->removeElement($emailMessage)) {
  187.             if ($emailMessage->getSale() === $this) {
  188.                 $emailMessage->setSale(null);
  189.             }
  190.         }
  192.         return $this;
  193.     }
  195.     /**
  196.      * @return Collection<int, SalesHistory>
  197.      */
  198.     public function getHistoryEntries(): Collection
  199.     {
  200.         return $this->historyEntries;
  201.     }
  203.     public function addHistoryEntry(SalesHistory $historyEntry): self
  204.     {
  205.         if (!$this->historyEntries->contains($historyEntry)) {
  206.             $this->historyEntries->add($historyEntry);
  207.             $historyEntry->setSale($this);
  208.         }
  210.         return $this;
  211.     }
  213.     public function removeHistoryEntry(SalesHistory $historyEntry): self
  214.     {
  215.         if ($this->historyEntries->removeElement($historyEntry)) {
  216.             if ($historyEntry->getSale() === $this) {
  217.                 $historyEntry->setSale(null);
  218.             }
  219.         }
  221.         return $this;
  222.     }
  224.     /**
  225.      * @return mixed
  226.      */
  227.     public function getSalesDate()
  228.     {
  229.         return $this->salesDate;
  230.     }
  232.     /**
  233.      * @param mixed $salesDate
  234.      */
  235.     public function setSalesDate($salesDate): void
  236.     {
  237.         $this->salesDate = $salesDate;
  238.     }
  240.     public function getTotalPurchasePrice(): ?float
  241.     {
  242.         return $this->totalPurchasePrice;
  243.     }
  245.     public function setTotalPurchasePrice(float $totalPurchasePrice): self
  246.     {
  247.         $this->totalPurchasePrice = $totalPurchasePrice;
  249.         return $this;
  250.     }
  253.     /**
  254.      * @return Collection<int, ProductsSold>
  255.      */
  256.     public function getProductsSolds(): Collection
  257.     {
  258.         return $this->productsSolds;
  259.     }
  261.     public function addProductsSold(ProductsSold $productsSold): self
  262.     {
  263.         if (!$this->productsSolds->contains($productsSold)) {
  264.             $this->productsSolds[] = $productsSold;
  265.             $productsSold->setSales($this);
  266.         }
  268.         return $this;
  269.     }
  271.     public function removeProductsSold(ProductsSold $productsSold): self
  272.     {
  273.         if ($this->productsSolds->removeElement($productsSold)) {
  274.             // set the owning side to null (unless already changed)
  275.             if ($productsSold->getSales() === $this) {
  276.                 $productsSold->setSales(null);
  277.             }
  278.         }
  280.         return $this;
  281.     }
  283.     public function getSeller(): ?User
  284.     {
  285.         return $this->seller;
  286.     }
  288.     public function setSeller(?User $seller): self
  289.     {
  290.         $this->seller = $seller;
  292.         return $this;
  293.     }
  295.     public function getWarehouse(): ?Warehouse
  296.     {
  297.         return $this->warehouse;
  298.     }
  300.     public function setWarehouse(?Warehouse $warehouse): self
  301.     {
  302.         $this->warehouse = $warehouse;
  304.         return $this;
  305.     }
  307.     /**
  308.      * @return Collection<int, Payment>
  309.      */
  310.     public function getPayments(): Collection
  311.     {
  312.         return $this->payments;
  313.     }
  315.     public function addPayment(Payment $payment): self
  316.     {
  317.         if (!$this->payments->contains($payment)) {
  318.             $this->payments[] = $payment;
  319.             $payment->setSales($this);
  320.         }
  322.         return $this;
  323.     }
  325.     public function removePayment(Payment $payment): self
  326.     {
  327.         if ($this->payments->removeElement($payment)) {
  328.             // set the owning side to null (unless already changed)
  329.             if ($payment->getSales() === $this) {
  330.                 $payment->setSales(null);
  331.             }
  332.         }
  334.         return $this;
  335.     }
  337.     /**
  338.      * @return Collection<int, StockTransaction>
  339.      */
  340.     public function getStockTransactions(): Collection
  341.     {
  342.         return $this->stockTransactions;
  343.     }
  345.     public function addStockTransaction(StockTransaction $stockTransaction): self
  346.     {
  347.         if (!$this->stockTransactions->contains($stockTransaction)) {
  348.             $this->stockTransactions[] = $stockTransaction;
  349.             $stockTransaction->setSale($this);
  350.         }
  352.         return $this;
  353.     }
  355.     public function removeStockTransaction(StockTransaction $stockTransaction): self
  356.     {
  357.         if ($this->stockTransactions->removeElement($stockTransaction)) {
  358.             // set the owning side to null (unless already changed)
  359.             if ($stockTransaction->getSale() === $this) {
  360.                 $stockTransaction->setSale(null);
  361.             }
  362.         }
  364.         return $this;
  365.     }
  367.     public function getInvoice(): ?Invoice
  368.     {
  369.         return $this->invoice;
  370.     }
  372.     public function setInvoice(?Invoice $invoice): self
  373.     {
  374.         $this->invoice = $invoice;
  376.         return $this;
  377.     }
  379.     public function getDescription(): ?string
  380.     {
  381.         return $this->description;
  382.     }
  384.     public function setDescription(?string $description): static
  385.     {
  386.         $this->description = $description;
  388.         return $this;
  389.     }
  391.     public function getShippingNotes(): ?string
  392.     {
  393.         return $this->shippingNotes;
  394.     }
  396.     public function setShippingNotes(?string $shippingNotes): static
  397.     {
  398.         $this->shippingNotes = $shippingNotes;
  400.         return $this;
  401.     }
  403.     public function getPaymentNotes(): ?string
  404.     {
  405.         return $this->paymentNotes;
  406.     }
  408.     public function setPaymentNotes(?string $paymentNotes): static
  409.     {
  410.         $this->paymentNotes = $paymentNotes;
  412.         return $this;
  413.     }
  415.     /**
  416.      * @return mixed
  417.      */
  418.     public function getDeliveryDate()
  419.     {
  420.         return $this->deliveryDate;
  421.     }
  423.     /**
  424.      * @param mixed $deliveryDate
  425.      */
  426.     public function setDeliveryDate($deliveryDate): void
  427.     {
  428.         $this->deliveryDate = $deliveryDate;
  429.     }
  431.     /**
  432.      * @return mixed
  433.      */
  434.     public function getDueDate()
  435.     {
  436.         return $this->dueDate;
  437.     }
  439.     /**
  440.      * @param mixed $dueDate
  441.      */
  442.     public function setDueDate($dueDate): void
  443.     {
  444.         $this->dueDate = $dueDate;
  445.     }
  447.     /**
  448.      * @return mixed
  449.      */
  450.     public function getValidDate()
  451.     {
  452.         return $this->validDate;
  453.     }
  455.     /**
  456.      * @param mixed $validDate
  457.      */
  458.     public function setValidDate($validDate): void
  459.     {
  460.         $this->validDate = $validDate;
  461.     }
  463.     public function getStatus(): ?SalesStatus
  464.     {
  465.         return $this->status;
  466.     }
  468.     public function setStatus(?SalesStatus $status): void
  469.     {
  470.         $this->status = $status;
  471.     }
  473.     public function isVisible(): ?bool
  474.     {
  475.         return $this->visible;
  476.     }
  478.     public function setVisible(bool $visible): static
  479.     {
  480.         $this->visible = $visible;
  482.         return $this;
  483.     }
  485.     /**
  486.      * @return Collection<int, GiftProduct>
  487.      */
  488.     public function getGiftProducts(): Collection
  489.     {
  490.         return $this->giftProducts;
  491.     }
  493.     public function addGiftProduct(GiftProduct $giftProduct): self
  494.     {
  495.         if (!$this->giftProducts->contains($giftProduct)) {
  496.             $this->giftProducts->add($giftProduct);
  497.             $giftProduct->setSale($this);
  498.         }
  500.         return $this;
  501.     }
  503.     public function removeGiftProduct(GiftProduct $giftProduct): self
  504.     {
  505.         if ($this->giftProducts->removeElement($giftProduct)) {
  506.             if ($giftProduct->getSale() === $this) {
  507.                 $giftProduct->setSale(null);
  508.             }
  509.         }
  511.         return $this;
  512.     }
  515. }