src/Entity/Invoice.php line 13

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\InvoiceRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  11. #[ORM\Entity(repositoryClass: InvoiceRepository::class)]
  12. #[ORM\HasLifecycleCallbacks]
  13. class Invoice
  14. {
  15.     use \App\Traits\EntityDateTimeAbleTrait;
  16.     
  17.     #[ORM\Id]
  18.     #[ORM\GeneratedValue]
  19.     #[ORM\Column]
  20.     private ?int $id = null;
  22.     #[ORM\ManyToOne(inversedBy: 'invoices')]
  23.     private ?Program $program = null;
  25.     #[ORM\ManyToOne(inversedBy: 'invoices')]
  26.     private ?Billing $billing = null;
  28.     #[ORM\Column(nullable: true)]
  29.     private ?float $price = null;
  31.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
  32.     private ?\DateTimeInterface $startDate = null;
  34.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
  35.     private ?\DateTimeInterface $endDate = null;
  37.     #[ORM\Column(nullable: true)]
  38.     private ?int $method = null;
  40.     #[ORM\Column(nullable: true)]
  41.     private ?float $fixPrice = null;
  43.     #[ORM\Column(nullable: true)]
  44.     private ?int $paymentDeadline = null;
  46.     #[ORM\Column(length: 255, nullable: true)]
  47.     private ?string $name = null;
  49.     #[ORM\Column(length: 255, nullable: true)]
  50.     private ?string $number = null;
  52.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
  53.     private ?\DateTimeInterface $invoiceDate = null;
  55.     #[ORM\ManyToOne(inversedBy: 'invoices')]
  56.     private ?InvoiceAddress $address = null;
  58.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  59.     private ?string $note = null;
  61.     #[ORM\Column(length: 255, nullable: true)]
  62.     private ?string $orderNumber = null;
  64.     #[ORM\Column(nullable: true)]
  65.     private ?float $amount = null;
  67.     #[ORM\Column(nullable: true)]
  68.     private ?float $vat = null;
  70.     #[ORM\Column(nullable: true)]
  71.     private ?float $totalTTC = null;
  73.     #[ORM\Column(nullable: true)]
  74.     private ?int $paymentMethod = null;
  76.     #[ORM\Column(nullable: true)]
  77.     private ?int $year = null;
  79.     #[ORM\ManyToOne(inversedBy: 'invoices')]
  80.     private ?Bank $bank = null;
  82.     #[ORM\OneToMany(mappedBy: 'invoice', targetEntity: Payment::class, orphanRemoval: true, cascade: ['persist', 'remove'])]
  83.     private Collection $payments;
  85.     #[ORM\ManyToOne(inversedBy: 'invoices')]
  86.     private ?InvoiceContact $invoiceContact = null;
  88.     #[ORM\ManyToOne(inversedBy: 'invoices')]
  89.     private ?InvoicedEntity $invoicedEntity = null;
  91.     #[ORM\OneToMany(mappedBy: 'invoice', targetEntity: InvoicedEntity::class)]
  92.     private Collection $invoicedEntities;
  94.     #[ORM\OneToOne(mappedBy: 'invoice', cascade: ['persist', 'remove'])]
  95.     private ?InvoiceInfo $invoiceInfo = null;
  97.     #[ORM\Column(nullable: true)]
  98.     private ?int $receipt = null;
  100.     #[ORM\Column(nullable: true)]
  101.     private ?float $totalTH = null;
  103.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
  104.     private ?\DateTimeInterface $activeDate = null;
  106.     public function __construct()
  107.     {
  108.         $this->payments = new ArrayCollection();
  109.         $this->invoicedEntities = new ArrayCollection();
  110.     }
  112.     public function getId(): ?int
  113.     {
  114.         return $this->id;
  115.     }
  117.     public function getProgram(): ?Program
  118.     {
  119.         return $this->program;
  120.     }
  122.     public function setProgram(?Program $program): static
  123.     {
  124.         $this->program = $program;
  126.         return $this;
  127.     }
  129.     public function getBilling(): ?Billing
  130.     {
  131.         return $this->billing;
  132.     }
  134.     public function setBilling(?Billing $billing): static
  135.     {
  136.         $this->billing = $billing;
  138.         return $this;
  139.     }
  141.     public function getPrice(): ?float
  142.     {
  143.         return $this->price;
  144.     }
  146.     public function setPrice(?float $price): static
  147.     {
  148.         $this->price = $price;
  150.         return $this;
  151.     }
  153.     public function getStartDate(): ?\DateTimeInterface
  154.     {
  155.         return $this->startDate;
  156.     }
  158.     public function setStartDate(?\DateTimeInterface $startDate): static
  159.     {
  160.         $this->startDate = $startDate;
  162.         return $this;
  163.     }
  165.     public function getEndDate(): ?\DateTimeInterface
  166.     {
  167.         return $this->endDate;
  168.     }
  170.     public function setEndDate(?\DateTimeInterface $endDate): static
  171.     {
  172.         $this->endDate = $endDate;
  174.         return $this;
  175.     }
  177.     public function getMethod(): ?int
  178.     {
  179.         return $this->method;
  180.     }
  182.     public function setMethod(?int $method): static
  183.     {
  184.         $this->method = $method;
  186.         return $this;
  187.     }
  189.     public function getFixPrice(): ?float
  190.     {
  191.         return $this->fixPrice;
  192.     }
  194.     public function setFixPrice(?float $fixPrice): static
  195.     {
  196.         $this->fixPrice = $fixPrice;
  198.         return $this;
  199.     }
  201.     public function getPaymentDeadline(): ?int
  202.     {
  203.         return $this->paymentDeadline;
  204.     }
  206.     public function setPaymentDeadline(?int $paymentDeadline): static
  207.     {
  208.         $this->paymentDeadline = $paymentDeadline;
  210.         return $this;
  211.     }
  213.     public function getName(): ?string
  214.     {
  215.         return $this->name;
  216.     }
  218.     public function setName(?string $name): static
  219.     {
  220.         $this->name = $name;
  222.         return $this;
  223.     }
  225.     public function getNumber(): ?string
  226.     {
  227.         return $this->number;
  228.     }
  230.     public function setNumber(?string $number): static
  231.     {
  232.         $this->number = $number;
  234.         return $this;
  235.     }
  237.     public function getInvoiceDate(): ?\DateTimeInterface
  238.     {
  239.         return $this->invoiceDate;
  240.     }
  242.     public function setInvoiceDate(\DateTimeInterface $invoiceDate): static
  243.     {
  244.         $this->invoiceDate = $invoiceDate;
  246.         return $this;
  247.     }
  249.     public function getAddress(): ?InvoiceAddress
  250.     {
  251.         return $this->address;
  252.     }
  254.     public function setAddress(?InvoiceAddress $address): static
  255.     {
  256.         $this->address = $address;
  258.         return $this;
  259.     }
  261.     public function getNote(): ?string
  262.     {
  263.         return $this->note;
  264.     }
  266.     public function setNote(?string $note): static
  267.     {
  268.         $this->note = $note;
  270.         return $this;
  271.     }
  273.     public function getOrderNumber(): ?string
  274.     {
  275.         return $this->orderNumber;
  276.     }
  278.     public function setOrderNumber(?string $orderNumber): static
  279.     {
  280.         $this->orderNumber = $orderNumber;
  282.         return $this;
  283.     }
  285.     public function getAmount(): ?float
  286.     {
  287.         return $this->amount;
  288.     }
  290.     public function setAmount(?float $amount): static
  291.     {
  292.         $this->amount = $amount;
  294.         return $this;
  295.     }
  297.     public function getVat(): ?float
  298.     {
  299.         return $this->vat;
  300.     }
  302.     public function setVat(?float $vat): static
  303.     {
  304.         $this->vat = $vat;
  306.         return $this;
  307.     }
  309.     public function getTotalTTC(): ?float
  310.     {
  311.         return $this->totalTTC;
  312.     }
  314.     public function setTotalTTC(?float $totalTTC): static
  315.     {
  316.         $this->totalTTC = $totalTTC;
  318.         return $this;
  319.     }
  321.     public function getPaymentMethod(): ?int
  322.     {
  323.         return $this->paymentMethod;
  324.     }
  326.     public function setPaymentMethod(?int $paymentMethod): static
  327.     {
  328.         $this->paymentMethod = $paymentMethod;
  330.         return $this;
  331.     }
  333.     public function getYear(): ?int
  334.     {
  335.         return $this->year;
  336.     }
  338.     public function setYear(?int $year): static
  339.     {
  340.         $this->year = $year;
  342.         return $this;
  343.     }
  345.     public function getBank(): ?Bank
  346.     {
  347.         return $this->bank;
  348.     }
  350.     public function setBank(?Bank $bank): static
  351.     {
  352.         $this->bank = $bank;
  354.         return $this;
  355.     }
  357.     /**
  358.      * @return Collection<int, Payment>
  359.      */
  360.     public function getPayments(): Collection
  361.     {
  362.         return $this->payments;
  363.     }
  365.     public function addPayment(Payment $payment): static
  366.     {
  367.         if (!$this->payments->contains($payment)) {
  368.             $this->payments->add($payment);
  369.             $payment->setInvoice($this);
  370.         }
  372.         return $this;
  373.     }
  375.     public function removePayment(Payment $payment): static
  376.     {
  377.         if ($this->payments->removeElement($payment)) {
  378.             // set the owning side to null (unless already changed)
  379.             if ($payment->getInvoice() === $this) {
  380.                 $payment->setInvoice(null);
  381.             }
  382.         }
  384.         return $this;
  385.     }
  387.     public function getInvoiceContact(): ?InvoiceContact
  388.     {
  389.         return $this->invoiceContact;
  390.     }
  392.     public function setInvoiceContact(?InvoiceContact $invoiceContact): static
  393.     {
  394.         $this->invoiceContact = $invoiceContact;
  396.         return $this;
  397.     }
  399.     public function getInvoicedEntity(): ?InvoicedEntity
  400.     {
  401.         return $this->invoicedEntity;
  402.     }
  404.     public function setInvoicedEntity(?InvoicedEntity $invoicedEntity): static
  405.     {
  406.         $this->invoicedEntity = $invoicedEntity;
  408.         return $this;
  409.     }
  411.     /**
  412.      * @return Collection<int, InvoicedEntity>
  413.      */
  414.     public function getInvoicedEntities(): Collection
  415.     {
  416.         return $this->invoicedEntities;
  417.     }
  419.     public function addInvoicedEntity(InvoicedEntity $invoicedEntity): static
  420.     {
  421.         if (!$this->invoicedEntities->contains($invoicedEntity)) {
  422.             $this->invoicedEntities->add($invoicedEntity);
  423.             $invoicedEntity->setInvoice($this);
  424.         }
  426.         return $this;
  427.     }
  429.     public function removeInvoicedEntity(InvoicedEntity $invoicedEntity): static
  430.     {
  431.         if ($this->invoicedEntities->removeElement($invoicedEntity)) {
  432.             // set the owning side to null (unless already changed)
  433.             if ($invoicedEntity->getInvoice() === $this) {
  434.                 $invoicedEntity->setInvoice(null);
  435.             }
  436.         }
  438.         return $this;
  439.     }
  441.     public function getInvoiceInfo(): ?InvoiceInfo
  442.     {
  443.         return $this->invoiceInfo;
  444.     }
  446.     public function setInvoiceInfo(?InvoiceInfo $invoiceInfo): static
  447.     {
  448.         // unset the owning side of the relation if necessary
  449.         if ($invoiceInfo === null && $this->invoiceInfo !== null) {
  450.             $this->invoiceInfo->setInvoice(null);
  451.         }
  453.         // set the owning side of the relation if necessary
  454.         if ($invoiceInfo !== null && $invoiceInfo->getInvoice() !== $this) {
  455.             $invoiceInfo->setInvoice($this);
  456.         }
  458.         $this->invoiceInfo = $invoiceInfo;
  460.         return $this;
  461.     }
  463.     public function getReceipt(): ?int
  464.     {
  465.         return $this->receipt;
  466.     }
  468.     public function setReceipt(?int $receipt): static
  469.     {
  470.         $this->receipt = $receipt;
  472.         return $this;
  473.     }
  475.     public function getTotalTH(): ?float
  476.     {
  477.         return $this->totalTH;
  478.     }
  480.     public function setTotalTH(?float $totalTH): static
  481.     {
  482.         $this->totalTH = $totalTH;
  484.         return $this;
  485.     }
  487.     public function getActiveDate(): ?\DateTimeInterface
  488.     {
  489.         return $this->activeDate;
  490.     }
  492.     public function setActiveDate(?\DateTimeInterface $activeDate): static
  493.     {
  494.         $this->activeDate = $activeDate;
  496.         return $this;
  497.     }
  498. }