src/Entity/Receipt.php line 15

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Core\Annotation\ApiProperty;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Ramsey\Uuid\Uuid;
  10. use Ramsey\Uuid\UuidInterface;
  12. /**
  13.  * @ORM\Entity(repositoryClass="App\Repository\ReceiptRepository")
  14.  */
  15. class Receipt
  16. {
  17.     /**
  18.      * @ORM\Id
  19.      * @ORM\Column(type="integer")
  20.      * @ORM\GeneratedValue(strategy="AUTO")
  21.      * @ApiProperty(identifier=false)
  22.      */
  23.     private $id;
  25.     /**
  26.      * @ORM\Column(type="datetime", nullable=true)
  27.      */
  28.     private $create_date;
  30.     /**
  31.      * @ORM\Column(type="string", length=55, nullable=true)
  32.      */
  33.     private $status;
  35.     /**
  36.      * @ORM\Column(type="integer", nullable=true)
  37.      */
  38.     private $discount;
  40.     /**
  41.      * @ORM\Column(type="string", length=55, nullable=true)
  42.      */
  43.     private $discount_type;
  45.     /**
  46.      * @ORM\Column(type="text", nullable=true)
  47.      */
  48.     private $comment;
  50.     /**
  51.      * @ORM\Column(type="float", nullable=true)
  52.      */
  53.     private $total;
  55.     /**
  56.      * @ORM\Column(type="float", nullable=true)
  57.      */
  58.     private $total_otax;
  60.     /**
  61.      * @ORM\Column(type="float", nullable=true)
  62.      */
  63.     private $total_fixed;
  65.     /**
  66.      * @ORM\Column(type="float", nullable=true)
  67.      */
  68.     private $total_otax_fixed;
  70.     /**
  71.      * @ORM\Column(type="float", nullable=true)
  72.      */
  73.     private $total_tax;
  75.     /**
  76.      * @ORM\Column(type="float", nullable=true)
  77.      */
  78.     private $total_tax_fixed;
  80.     /**
  81.      * @ORM\Column(type="float", nullable=true)
  82.      */
  83.     private $cart_total;
  85.     /**
  86.      * @ORM\Column(type="float", nullable=true)
  87.      */
  88.     private $cart_total_otax;
  90.     /**
  91.      * @ORM\Column(type="float", nullable=true)
  92.      */
  93.     private $cart_total_fixed;
  95.     /**
  96.      * @ORM\Column(type="float", nullable=true)
  97.      */
  98.     private $cart_total_otax_fixed;
  100.     /**
  101.      * @ORM\Column(type="float", nullable=true)
  102.      */
  103.     private $cart_total_tax;
  105.     /**
  106.      * @ORM\Column(type="float", nullable=true)
  107.      */
  108.     private $cart_total_tax_fixed;
  110.     /**
  111.      * @ORM\Column(type="integer", nullable=true)
  112.      */
  113.     private $number;
  115.     /**
  116.      * @ORM\Column(type="uuid", unique=true, nullable=true)
  117.      */
  118.     private $uuid;
  120.     /**
  121.      * @ORM\Column(type="boolean", nullable=true)
  122.      */
  123.     private $canceled;
  125.     /**
  126.      * @ORM\Column(type="boolean", nullable=true)
  127.      */
  128.     private $reversal_receipt;
  130.     /**
  131.      * @ORM\OneToMany(targetEntity="App\Entity\ReceiptCustomer", mappedBy="receipt")
  132.      */
  133.     private $receiptCustomers;
  135.     /**
  136.      * @ORM\OneToMany(targetEntity="App\Entity\ReceiptCustomerAddress", mappedBy="receipt")
  137.      */
  138.     private $receiptCustomerAddresses;
  140.     /**
  141.      * @ORM\OneToMany(targetEntity="App\Entity\ReceiptCustomerGroup", mappedBy="receipt")
  142.      */
  143.     private $receiptCustomerGroups;
  145.     /**
  146.      * @ORM\OneToMany(targetEntity="App\Entity\ReceiptDiscount", mappedBy="receipt")
  147.      */
  148.     private $receiptDiscounts;
  150.     /**
  151.      * @ORM\OneToMany(targetEntity="App\Entity\ReceiptPrice", mappedBy="receipt")
  152.      */
  153.     private $receiptPrices;
  155.     /**
  156.      * @ORM\OneToMany(targetEntity="App\Entity\ReceiptPriceGroup", mappedBy="receipt")
  157.      */
  158.     private $receiptPriceGroups;
  160.     /**
  161.      * @ORM\OneToMany(targetEntity="App\Entity\ReceiptProduct", mappedBy="receipt")
  162.      */
  163.     private $receiptProducts;
  165.     /**
  166.      * @ORM\OneToMany(targetEntity="App\Entity\ReceiptScalePrice", mappedBy="receipt")
  167.      */
  168.     private $receiptScalePrices;
  170.     /**
  171.      * @ORM\OneToMany(targetEntity="App\Entity\ReceiptTax", mappedBy="receipt")
  172.      */
  173.     private $receiptTaxes;
  175.     /**
  176.      * @ORM\OneToMany(targetEntity="App\Entity\ReceiptUnit", mappedBy="receipt")
  177.      */
  178.     private $receiptUnits;
  180.     /**
  181.      * @ORM\OneToMany(targetEntity="App\Entity\ReceiptUser", mappedBy="receipt")
  182.      */
  183.     private $receiptUsers;
  185.     /**
  186.      * @ORM\OneToMany(targetEntity="App\Entity\ReceiptEmployeeGroup", mappedBy="receipt")
  187.      */
  188.     private $receiptEmployeeGroups;
  190.     /**
  191.      * @ORM\OneToMany(targetEntity="App\Entity\ReceiptCartProduct", mappedBy="receipt")
  192.      */
  193.     private $receiptCartProducts;
  195.     /**
  196.      * @ORM\OneToMany(targetEntity="App\Entity\ReceiptDocument", mappedBy="receipt")
  197.      */
  198.     private $receiptDocuments;
  200.     /**
  201.      * @ORM\OneToMany(targetEntity="App\Entity\FiskalyTransaction", mappedBy="receipt")
  202.      */
  203.     private $fiskalyTransactions;
  205.     /**
  206.      * @ORM\OneToMany(targetEntity="App\Entity\ReceiptTransaction", mappedBy="receipt")
  207.      */
  208.     private $receiptTransactions;
  210.     /**
  211.      * @ORM\OneToMany(targetEntity="App\Entity\ReceiptContraAccount", mappedBy="receipt")
  212.      */
  213.     private $receiptContraAccounts;
  215.     /**
  216.      * @ORM\OneToMany(targetEntity="App\Entity\Reversal", mappedBy="receipt")
  217.      */
  218.     private $reversals;
  220.     /**
  221.      * @ORM\OneToMany(targetEntity="App\Entity\Reversal", mappedBy="reversal_receipt")
  222.      */
  223.     private $reversal_receipt_reversals;
  225.     /**
  226.      * @ORM\ManyToOne(targetEntity="App\Entity\ReceiptCashbox", inversedBy="receipts")
  227.      * @ORM\JoinColumn(name="receipt_cashbox_id", referencedColumnName="id")
  228.      */
  229.     private $receiptCashbox;
  231.     /**
  232.      * @ORM\ManyToOne(targetEntity="App\Entity\ReceiptLocation", inversedBy="receipts")
  233.      * @ORM\JoinColumn(name="receipt_location_id", referencedColumnName="id")
  234.      */
  235.     private $receiptLocation;
  237.     /**
  238.      * @ORM\ManyToOne(targetEntity="App\Entity\ReceiptEmployee", inversedBy="receipts")
  239.      * @ORM\JoinColumn(name="receipt_employee_id", referencedColumnName="id")
  240.      */
  241.     private $receiptEmployee;
  243.     /**
  244.      * @ORM\ManyToOne(targetEntity="App\Entity\Customer", inversedBy="receipts")
  245.      * @ORM\JoinColumn(name="customer_id", referencedColumnName="id")
  246.      */
  247.     private $customer;
  249.     /**
  250.      * @ORM\ManyToOne(targetEntity="App\Entity\CustomerAddress", inversedBy="receipts")
  251.      * @ORM\JoinColumn(name="customer_address_id", referencedColumnName="id")
  252.      */
  253.     private $customerAddress;
  255.     /**
  256.      * @ORM\ManyToOne(targetEntity="App\Entity\DailyFinancialStatement", inversedBy="receipts")
  257.      * @ORM\JoinColumn(name="daily_financial_statement_id", referencedColumnName="id")
  258.      */
  259.     private $dailyFinancialStatement;
  261.     /**
  262.      * @ORM\ManyToMany(targetEntity="App\Entity\FiskalyReceiptType", mappedBy="receipts")
  263.      */
  264.     private $fiskalyReceiptTypes;
  266.     public function __construct()
  267.     {
  268.         $this->receiptCustomers = new ArrayCollection();
  269.         $this->receiptCustomerAddresses = new ArrayCollection();
  270.         $this->receiptCustomerGroups = new ArrayCollection();
  271.         $this->receiptDiscounts = new ArrayCollection();
  272.         $this->receiptPrices = new ArrayCollection();
  273.         $this->receiptPriceGroups = new ArrayCollection();
  274.         $this->receiptProducts = new ArrayCollection();
  275.         $this->receiptScalePrices = new ArrayCollection();
  276.         $this->receiptTaxes = new ArrayCollection();
  277.         $this->receiptUnits = new ArrayCollection();
  278.         $this->receiptUsers = new ArrayCollection();
  279.         $this->receiptEmployeeGroups = new ArrayCollection();
  280.         $this->receiptCartProducts = new ArrayCollection();
  281.         $this->receiptDocuments = new ArrayCollection();
  282.         $this->fiskalyTransactions = new ArrayCollection();
  283.         $this->receiptTransactions = new ArrayCollection();
  284.         $this->receiptContraAccounts = new ArrayCollection();
  285.         $this->reversals = new ArrayCollection();
  286.         $this->reversal_receipt_reversals = new ArrayCollection();
  287.         $this->fiskalyReceiptTypes = new ArrayCollection();
  288.     }
  290.     public function getId(): ?int
  291.     {
  292.         return $this->id;
  293.     }
  295.     public function getCreateDate(): ?\DateTimeInterface
  296.     {
  297.         return $this->create_date;
  298.     }
  300.     public function setCreateDate(?\DateTimeInterface $create_date): self
  301.     {
  302.         $this->create_date = $create_date;
  304.         return $this;
  305.     }
  307.     public function getStatus(): ?string
  308.     {
  309.         return $this->status;
  310.     }
  312.     public function setStatus(?string $status): self
  313.     {
  314.         $this->status = $status;
  316.         return $this;
  317.     }
  319.     public function getDiscount(): ?int
  320.     {
  321.         return $this->discount;
  322.     }
  324.     public function setDiscount(?int $discount): self
  325.     {
  326.         $this->discount = $discount;
  328.         return $this;
  329.     }
  331.     public function getDiscountType(): ?string
  332.     {
  333.         return $this->discount_type;
  334.     }
  336.     public function setDiscountType(?string $discount_type): self
  337.     {
  338.         $this->discount_type = $discount_type;
  340.         return $this;
  341.     }
  343.     public function getComment(): ?string
  344.     {
  345.         return $this->comment;
  346.     }
  348.     public function setComment(?string $comment): self
  349.     {
  350.         $this->comment = $comment;
  352.         return $this;
  353.     }
  355.     public function getTotal(): ?float
  356.     {
  357.         return $this->total;
  358.     }
  360.     public function setTotal(?float $total): self
  361.     {
  362.         $this->total = $total;
  364.         return $this;
  365.     }
  367.     public function getTotalOtax(): ?float
  368.     {
  369.         return $this->total_otax;
  370.     }
  372.     public function setTotalOtax(?float $total_otax): self
  373.     {
  374.         $this->total_otax = $total_otax;
  376.         return $this;
  377.     }
  379.     public function getTotalFixed(): ?float
  380.     {
  381.         return $this->total_fixed;
  382.     }
  384.     public function setTotalFixed(?float $total_fixed): self
  385.     {
  386.         $this->total_fixed = $total_fixed;
  388.         return $this;
  389.     }
  391.     public function getTotalOtaxFixed(): ?float
  392.     {
  393.         return $this->total_otax_fixed;
  394.     }
  396.     public function setTotalOtaxFixed(?float $total_otax_fixed): self
  397.     {
  398.         $this->total_otax_fixed = $total_otax_fixed;
  400.         return $this;
  401.     }
  403.     public function getTotalTax(): ?float
  404.     {
  405.         return $this->total_tax;
  406.     }
  408.     public function setTotalTax(?float $total_tax): self
  409.     {
  410.         $this->total_tax = $total_tax;
  412.         return $this;
  413.     }
  415.     public function getTotalTaxFixed(): ?float
  416.     {
  417.         return $this->total_tax_fixed;
  418.     }
  420.     public function setTotalTaxFixed(?float $total_tax_fixed): self
  421.     {
  422.         $this->total_tax_fixed = $total_tax_fixed;
  424.         return $this;
  425.     }
  427.     public function getCartTotal(): ?float
  428.     {
  429.         return $this->cart_total;
  430.     }
  432.     public function setCartTotal(?float $cart_total): self
  433.     {
  434.         $this->cart_total = $cart_total;
  436.         return $this;
  437.     }
  439.     public function getCartTotalOtax(): ?float
  440.     {
  441.         return $this->cart_total_otax;
  442.     }
  444.     public function setCartTotalOtax(?float $cart_total_otax): self
  445.     {
  446.         $this->cart_total_otax = $cart_total_otax;
  448.         return $this;
  449.     }
  451.     public function getCartTotalFixed(): ?float
  452.     {
  453.         return $this->cart_total_fixed;
  454.     }
  456.     public function setCartTotalFixed(?float $cart_total_fixed): self
  457.     {
  458.         $this->cart_total_fixed = $cart_total_fixed;
  460.         return $this;
  461.     }
  463.     public function getCartTotalOtaxFixed(): ?float
  464.     {
  465.         return $this->cart_total_otax_fixed;
  466.     }
  468.     public function setCartTotalOtaxFixed(?float $cart_total_otax_fixed): self
  469.     {
  470.         $this->cart_total_otax_fixed = $cart_total_otax_fixed;
  472.         return $this;
  473.     }
  475.     public function getCartTotalTax(): ?float
  476.     {
  477.         return $this->cart_total_tax;
  478.     }
  480.     public function setCartTotalTax(?float $cart_total_tax): self
  481.     {
  482.         $this->cart_total_tax = $cart_total_tax;
  484.         return $this;
  485.     }
  487.     public function getCartTotalTaxFixed(): ?float
  488.     {
  489.         return $this->cart_total_tax_fixed;
  490.     }
  492.     public function setCartTotalTaxFixed(?float $cart_total_tax_fixed): self
  493.     {
  494.         $this->cart_total_tax_fixed = $cart_total_tax_fixed;
  496.         return $this;
  497.     }
  499.     public function getNumber(): ?int
  500.     {
  501.         return $this->number;
  502.     }
  504.     public function setNumber(?int $number): self
  505.     {
  506.         $this->number = $number;
  508.         return $this;
  509.     }
  511.     public function getUuid()
  512.     {
  513.         return $this->uuid;
  514.     }
  516.     public function setUuid($uuid): self
  517.     {
  518.         $this->uuid = $uuid;
  520.         return $this;
  521.     }
  523.     public function getCanceled(): ?bool
  524.     {
  525.         return $this->canceled;
  526.     }
  528.     public function setCanceled(?bool $canceled): self
  529.     {
  530.         $this->canceled = $canceled;
  532.         return $this;
  533.     }
  535.     public function getReversalReceipt(): ?bool
  536.     {
  537.         return $this->reversal_receipt;
  538.     }
  540.     public function setReversalReceipt(?bool $reversal_receipt): self
  541.     {
  542.         $this->reversal_receipt = $reversal_receipt;
  544.         return $this;
  545.     }
  547.     /**
  548.      * @return Collection<int, ReceiptCustomer>
  549.      */
  550.     public function getReceiptCustomers(): Collection
  551.     {
  552.         return $this->receiptCustomers;
  553.     }
  555.     public function addReceiptCustomer(ReceiptCustomer $receiptCustomer): self
  556.     {
  557.         if (!$this->receiptCustomers->contains($receiptCustomer)) {
  558.             $this->receiptCustomers[] = $receiptCustomer;
  559.             $receiptCustomer->setReceipt($this);
  560.         }
  562.         return $this;
  563.     }
  565.     public function removeReceiptCustomer(ReceiptCustomer $receiptCustomer): self
  566.     {
  567.         if ($this->receiptCustomers->removeElement($receiptCustomer)) {
  568.             // set the owning side to null (unless already changed)
  569.             if ($receiptCustomer->getReceipt() === $this) {
  570.                 $receiptCustomer->setReceipt(null);
  571.             }
  572.         }
  574.         return $this;
  575.     }
  577.     /**
  578.      * @return Collection<int, ReceiptCustomerAddress>
  579.      */
  580.     public function getReceiptCustomerAddresses(): Collection
  581.     {
  582.         return $this->receiptCustomerAddresses;
  583.     }
  585.     public function addReceiptCustomerAddress(ReceiptCustomerAddress $receiptCustomerAddress): self
  586.     {
  587.         if (!$this->receiptCustomerAddresses->contains($receiptCustomerAddress)) {
  588.             $this->receiptCustomerAddresses[] = $receiptCustomerAddress;
  589.             $receiptCustomerAddress->setReceipt($this);
  590.         }
  592.         return $this;
  593.     }
  595.     public function removeReceiptCustomerAddress(ReceiptCustomerAddress $receiptCustomerAddress): self
  596.     {
  597.         if ($this->receiptCustomerAddresses->removeElement($receiptCustomerAddress)) {
  598.             // set the owning side to null (unless already changed)
  599.             if ($receiptCustomerAddress->getReceipt() === $this) {
  600.                 $receiptCustomerAddress->setReceipt(null);
  601.             }
  602.         }
  604.         return $this;
  605.     }
  607.     /**
  608.      * @return Collection<int, ReceiptCustomerGroup>
  609.      */
  610.     public function getReceiptCustomerGroups(): Collection
  611.     {
  612.         return $this->receiptCustomerGroups;
  613.     }
  615.     public function addReceiptCustomerGroup(ReceiptCustomerGroup $receiptCustomerGroup): self
  616.     {
  617.         if (!$this->receiptCustomerGroups->contains($receiptCustomerGroup)) {
  618.             $this->receiptCustomerGroups[] = $receiptCustomerGroup;
  619.             $receiptCustomerGroup->setReceipt($this);
  620.         }
  622.         return $this;
  623.     }
  625.     public function removeReceiptCustomerGroup(ReceiptCustomerGroup $receiptCustomerGroup): self
  626.     {
  627.         if ($this->receiptCustomerGroups->removeElement($receiptCustomerGroup)) {
  628.             // set the owning side to null (unless already changed)
  629.             if ($receiptCustomerGroup->getReceipt() === $this) {
  630.                 $receiptCustomerGroup->setReceipt(null);
  631.             }
  632.         }
  634.         return $this;
  635.     }
  637.     /**
  638.      * @return Collection<int, ReceiptDiscount>
  639.      */
  640.     public function getReceiptDiscounts(): Collection
  641.     {
  642.         return $this->receiptDiscounts;
  643.     }
  645.     public function addReceiptDiscount(ReceiptDiscount $receiptDiscount): self
  646.     {
  647.         if (!$this->receiptDiscounts->contains($receiptDiscount)) {
  648.             $this->receiptDiscounts[] = $receiptDiscount;
  649.             $receiptDiscount->setReceipt($this);
  650.         }
  652.         return $this;
  653.     }
  655.     public function removeReceiptDiscount(ReceiptDiscount $receiptDiscount): self
  656.     {
  657.         if ($this->receiptDiscounts->removeElement($receiptDiscount)) {
  658.             // set the owning side to null (unless already changed)
  659.             if ($receiptDiscount->getReceipt() === $this) {
  660.                 $receiptDiscount->setReceipt(null);
  661.             }
  662.         }
  664.         return $this;
  665.     }
  667.     /**
  668.      * @return Collection<int, ReceiptPrice>
  669.      */
  670.     public function getReceiptPrices(): Collection
  671.     {
  672.         return $this->receiptPrices;
  673.     }
  675.     public function addReceiptPrice(ReceiptPrice $receiptPrice): self
  676.     {
  677.         if (!$this->receiptPrices->contains($receiptPrice)) {
  678.             $this->receiptPrices[] = $receiptPrice;
  679.             $receiptPrice->setReceipt($this);
  680.         }
  682.         return $this;
  683.     }
  685.     public function removeReceiptPrice(ReceiptPrice $receiptPrice): self
  686.     {
  687.         if ($this->receiptPrices->removeElement($receiptPrice)) {
  688.             // set the owning side to null (unless already changed)
  689.             if ($receiptPrice->getReceipt() === $this) {
  690.                 $receiptPrice->setReceipt(null);
  691.             }
  692.         }
  694.         return $this;
  695.     }
  697.     /**
  698.      * @return Collection<int, ReceiptPriceGroup>
  699.      */
  700.     public function getReceiptPriceGroups(): Collection
  701.     {
  702.         return $this->receiptPriceGroups;
  703.     }
  705.     public function addReceiptPriceGroup(ReceiptPriceGroup $receiptPriceGroup): self
  706.     {
  707.         if (!$this->receiptPriceGroups->contains($receiptPriceGroup)) {
  708.             $this->receiptPriceGroups[] = $receiptPriceGroup;
  709.             $receiptPriceGroup->setReceipt($this);
  710.         }
  712.         return $this;
  713.     }
  715.     public function removeReceiptPriceGroup(ReceiptPriceGroup $receiptPriceGroup): self
  716.     {
  717.         if ($this->receiptPriceGroups->removeElement($receiptPriceGroup)) {
  718.             // set the owning side to null (unless already changed)
  719.             if ($receiptPriceGroup->getReceipt() === $this) {
  720.                 $receiptPriceGroup->setReceipt(null);
  721.             }
  722.         }
  724.         return $this;
  725.     }
  727.     /**
  728.      * @return Collection<int, ReceiptProduct>
  729.      */
  730.     public function getReceiptProducts(): Collection
  731.     {
  732.         return $this->receiptProducts;
  733.     }
  735.     public function addReceiptProduct(ReceiptProduct $receiptProduct): self
  736.     {
  737.         if (!$this->receiptProducts->contains($receiptProduct)) {
  738.             $this->receiptProducts[] = $receiptProduct;
  739.             $receiptProduct->setReceipt($this);
  740.         }
  742.         return $this;
  743.     }
  745.     public function removeReceiptProduct(ReceiptProduct $receiptProduct): self
  746.     {
  747.         if ($this->receiptProducts->removeElement($receiptProduct)) {
  748.             // set the owning side to null (unless already changed)
  749.             if ($receiptProduct->getReceipt() === $this) {
  750.                 $receiptProduct->setReceipt(null);
  751.             }
  752.         }
  754.         return $this;
  755.     }
  757.     /**
  758.      * @return Collection<int, ReceiptScalePrice>
  759.      */
  760.     public function getReceiptScalePrices(): Collection
  761.     {
  762.         return $this->receiptScalePrices;
  763.     }
  765.     public function addReceiptScalePrice(ReceiptScalePrice $receiptScalePrice): self
  766.     {
  767.         if (!$this->receiptScalePrices->contains($receiptScalePrice)) {
  768.             $this->receiptScalePrices[] = $receiptScalePrice;
  769.             $receiptScalePrice->setReceipt($this);
  770.         }
  772.         return $this;
  773.     }
  775.     public function removeReceiptScalePrice(ReceiptScalePrice $receiptScalePrice): self
  776.     {
  777.         if ($this->receiptScalePrices->removeElement($receiptScalePrice)) {
  778.             // set the owning side to null (unless already changed)
  779.             if ($receiptScalePrice->getReceipt() === $this) {
  780.                 $receiptScalePrice->setReceipt(null);
  781.             }
  782.         }
  784.         return $this;
  785.     }
  787.     /**
  788.      * @return Collection<int, ReceiptTax>
  789.      */
  790.     public function getReceiptTaxes(): Collection
  791.     {
  792.         return $this->receiptTaxes;
  793.     }
  795.     public function addReceiptTax(ReceiptTax $receiptTax): self
  796.     {
  797.         if (!$this->receiptTaxes->contains($receiptTax)) {
  798.             $this->receiptTaxes[] = $receiptTax;
  799.             $receiptTax->setReceipt($this);
  800.         }
  802.         return $this;
  803.     }
  805.     public function removeReceiptTax(ReceiptTax $receiptTax): self
  806.     {
  807.         if ($this->receiptTaxes->removeElement($receiptTax)) {
  808.             // set the owning side to null (unless already changed)
  809.             if ($receiptTax->getReceipt() === $this) {
  810.                 $receiptTax->setReceipt(null);
  811.             }
  812.         }
  814.         return $this;
  815.     }
  817.     /**
  818.      * @return Collection<int, ReceiptUnit>
  819.      */
  820.     public function getReceiptUnits(): Collection
  821.     {
  822.         return $this->receiptUnits;
  823.     }
  825.     public function addReceiptUnit(ReceiptUnit $receiptUnit): self
  826.     {
  827.         if (!$this->receiptUnits->contains($receiptUnit)) {
  828.             $this->receiptUnits[] = $receiptUnit;
  829.             $receiptUnit->setReceipt($this);
  830.         }
  832.         return $this;
  833.     }
  835.     public function removeReceiptUnit(ReceiptUnit $receiptUnit): self
  836.     {
  837.         if ($this->receiptUnits->removeElement($receiptUnit)) {
  838.             // set the owning side to null (unless already changed)
  839.             if ($receiptUnit->getReceipt() === $this) {
  840.                 $receiptUnit->setReceipt(null);
  841.             }
  842.         }
  844.         return $this;
  845.     }
  847.     /**
  848.      * @return Collection<int, ReceiptUser>
  849.      */
  850.     public function getReceiptUsers(): Collection
  851.     {
  852.         return $this->receiptUsers;
  853.     }
  855.     public function addReceiptUser(ReceiptUser $receiptUser): self
  856.     {
  857.         if (!$this->receiptUsers->contains($receiptUser)) {
  858.             $this->receiptUsers[] = $receiptUser;
  859.             $receiptUser->setReceipt($this);
  860.         }
  862.         return $this;
  863.     }
  865.     public function removeReceiptUser(ReceiptUser $receiptUser): self
  866.     {
  867.         if ($this->receiptUsers->removeElement($receiptUser)) {
  868.             // set the owning side to null (unless already changed)
  869.             if ($receiptUser->getReceipt() === $this) {
  870.                 $receiptUser->setReceipt(null);
  871.             }
  872.         }
  874.         return $this;
  875.     }
  877.     /**
  878.      * @return Collection<int, ReceiptEmployeeGroup>
  879.      */
  880.     public function getReceiptEmployeeGroups(): Collection
  881.     {
  882.         return $this->receiptEmployeeGroups;
  883.     }
  885.     public function addReceiptEmployeeGroup(ReceiptEmployeeGroup $receiptEmployeeGroup): self
  886.     {
  887.         if (!$this->receiptEmployeeGroups->contains($receiptEmployeeGroup)) {
  888.             $this->receiptEmployeeGroups[] = $receiptEmployeeGroup;
  889.             $receiptEmployeeGroup->setReceipt($this);
  890.         }
  892.         return $this;
  893.     }
  895.     public function removeReceiptEmployeeGroup(ReceiptEmployeeGroup $receiptEmployeeGroup): self
  896.     {
  897.         if ($this->receiptEmployeeGroups->removeElement($receiptEmployeeGroup)) {
  898.             // set the owning side to null (unless already changed)
  899.             if ($receiptEmployeeGroup->getReceipt() === $this) {
  900.                 $receiptEmployeeGroup->setReceipt(null);
  901.             }
  902.         }
  904.         return $this;
  905.     }
  907.     /**
  908.      * @return Collection<int, ReceiptCartProduct>
  909.      */
  910.     public function getReceiptCartProducts(): Collection
  911.     {
  912.         return $this->receiptCartProducts;
  913.     }
  915.     public function addReceiptCartProduct(ReceiptCartProduct $receiptCartProduct): self
  916.     {
  917.         if (!$this->receiptCartProducts->contains($receiptCartProduct)) {
  918.             $this->receiptCartProducts[] = $receiptCartProduct;
  919.             $receiptCartProduct->setReceipt($this);
  920.         }
  922.         return $this;
  923.     }
  925.     public function removeReceiptCartProduct(ReceiptCartProduct $receiptCartProduct): self
  926.     {
  927.         if ($this->receiptCartProducts->removeElement($receiptCartProduct)) {
  928.             // set the owning side to null (unless already changed)
  929.             if ($receiptCartProduct->getReceipt() === $this) {
  930.                 $receiptCartProduct->setReceipt(null);
  931.             }
  932.         }
  934.         return $this;
  935.     }
  937.     /**
  938.      * @return Collection<int, ReceiptDocument>
  939.      */
  940.     public function getReceiptDocuments(): Collection
  941.     {
  942.         return $this->receiptDocuments;
  943.     }
  945.     public function addReceiptDocument(ReceiptDocument $receiptDocument): self
  946.     {
  947.         if (!$this->receiptDocuments->contains($receiptDocument)) {
  948.             $this->receiptDocuments[] = $receiptDocument;
  949.             $receiptDocument->setReceipt($this);
  950.         }
  952.         return $this;
  953.     }
  955.     public function removeReceiptDocument(ReceiptDocument $receiptDocument): self
  956.     {
  957.         if ($this->receiptDocuments->removeElement($receiptDocument)) {
  958.             // set the owning side to null (unless already changed)
  959.             if ($receiptDocument->getReceipt() === $this) {
  960.                 $receiptDocument->setReceipt(null);
  961.             }
  962.         }
  964.         return $this;
  965.     }
  967.     /**
  968.      * @return Collection<int, FiskalyTransaction>
  969.      */
  970.     public function getFiskalyTransactions(): Collection
  971.     {
  972.         return $this->fiskalyTransactions;
  973.     }
  975.     public function addFiskalyTransaction(FiskalyTransaction $fiskalyTransaction): self
  976.     {
  977.         if (!$this->fiskalyTransactions->contains($fiskalyTransaction)) {
  978.             $this->fiskalyTransactions[] = $fiskalyTransaction;
  979.             $fiskalyTransaction->setReceipt($this);
  980.         }
  982.         return $this;
  983.     }
  985.     public function removeFiskalyTransaction(FiskalyTransaction $fiskalyTransaction): self
  986.     {
  987.         if ($this->fiskalyTransactions->removeElement($fiskalyTransaction)) {
  988.             // set the owning side to null (unless already changed)
  989.             if ($fiskalyTransaction->getReceipt() === $this) {
  990.                 $fiskalyTransaction->setReceipt(null);
  991.             }
  992.         }
  994.         return $this;
  995.     }
  997.     /**
  998.      * @return Collection<int, ReceiptTransaction>
  999.      */
  1000.     public function getReceiptTransactions(): Collection
  1001.     {
  1002.         return $this->receiptTransactions;
  1003.     }
  1005.     public function addReceiptTransaction(ReceiptTransaction $receiptTransaction): self
  1006.     {
  1007.         if (!$this->receiptTransactions->contains($receiptTransaction)) {
  1008.             $this->receiptTransactions[] = $receiptTransaction;
  1009.             $receiptTransaction->setReceipt($this);
  1010.         }
  1012.         return $this;
  1013.     }
  1015.     public function removeReceiptTransaction(ReceiptTransaction $receiptTransaction): self
  1016.     {
  1017.         if ($this->receiptTransactions->removeElement($receiptTransaction)) {
  1018.             // set the owning side to null (unless already changed)
  1019.             if ($receiptTransaction->getReceipt() === $this) {
  1020.                 $receiptTransaction->setReceipt(null);
  1021.             }
  1022.         }
  1024.         return $this;
  1025.     }
  1027.     /**
  1028.      * @return Collection<int, ReceiptContraAccount>
  1029.      */
  1030.     public function getReceiptContraAccounts(): Collection
  1031.     {
  1032.         return $this->receiptContraAccounts;
  1033.     }
  1035.     public function addReceiptContraAccount(ReceiptContraAccount $receiptContraAccount): self
  1036.     {
  1037.         if (!$this->receiptContraAccounts->contains($receiptContraAccount)) {
  1038.             $this->receiptContraAccounts[] = $receiptContraAccount;
  1039.             $receiptContraAccount->setReceipt($this);
  1040.         }
  1042.         return $this;
  1043.     }
  1045.     public function removeReceiptContraAccount(ReceiptContraAccount $receiptContraAccount): self
  1046.     {
  1047.         if ($this->receiptContraAccounts->removeElement($receiptContraAccount)) {
  1048.             // set the owning side to null (unless already changed)
  1049.             if ($receiptContraAccount->getReceipt() === $this) {
  1050.                 $receiptContraAccount->setReceipt(null);
  1051.             }
  1052.         }
  1054.         return $this;
  1055.     }
  1057.     /**
  1058.      * @return Collection<int, Reversal>
  1059.      */
  1060.     public function getReversals(): Collection
  1061.     {
  1062.         return $this->reversals;
  1063.     }
  1065.     public function addReversal(Reversal $reversal): self
  1066.     {
  1067.         if (!$this->reversals->contains($reversal)) {
  1068.             $this->reversals[] = $reversal;
  1069.             $reversal->setReceipt($this);
  1070.         }
  1072.         return $this;
  1073.     }
  1075.     public function removeReversal(Reversal $reversal): self
  1076.     {
  1077.         if ($this->reversals->removeElement($reversal)) {
  1078.             // set the owning side to null (unless already changed)
  1079.             if ($reversal->getReceipt() === $this) {
  1080.                 $reversal->setReceipt(null);
  1081.             }
  1082.         }
  1084.         return $this;
  1085.     }
  1087.     /**
  1088.      * @return Collection<int, Reversal>
  1089.      */
  1090.     public function getReversalReceiptReversals(): Collection
  1091.     {
  1092.         return $this->reversal_receipt_reversals;
  1093.     }
  1095.     public function addReversalReceiptReversal(Reversal $reversalReceiptReversal): self
  1096.     {
  1097.         if (!$this->reversal_receipt_reversals->contains($reversalReceiptReversal)) {
  1098.             $this->reversal_receipt_reversals[] = $reversalReceiptReversal;
  1099.             $reversalReceiptReversal->setReversalReceipt($this);
  1100.         }
  1102.         return $this;
  1103.     }
  1105.     public function removeReversalReceiptReversal(Reversal $reversalReceiptReversal): self
  1106.     {
  1107.         if ($this->reversal_receipt_reversals->removeElement($reversalReceiptReversal)) {
  1108.             // set the owning side to null (unless already changed)
  1109.             if ($reversalReceiptReversal->getReversalReceipt() === $this) {
  1110.                 $reversalReceiptReversal->setReversalReceipt(null);
  1111.             }
  1112.         }
  1114.         return $this;
  1115.     }
  1117.     public function getReceiptCashbox(): ?ReceiptCashbox
  1118.     {
  1119.         return $this->receiptCashbox;
  1120.     }
  1122.     public function setReceiptCashbox(?ReceiptCashbox $receiptCashbox): self
  1123.     {
  1124.         $this->receiptCashbox = $receiptCashbox;
  1126.         return $this;
  1127.     }
  1129.     public function getReceiptLocation(): ?ReceiptLocation
  1130.     {
  1131.         return $this->receiptLocation;
  1132.     }
  1134.     public function setReceiptLocation(?ReceiptLocation $receiptLocation): self
  1135.     {
  1136.         $this->receiptLocation = $receiptLocation;
  1138.         return $this;
  1139.     }
  1141.     public function getReceiptEmployee(): ?ReceiptEmployee
  1142.     {
  1143.         return $this->receiptEmployee;
  1144.     }
  1146.     public function setReceiptEmployee(?ReceiptEmployee $receiptEmployee): self
  1147.     {
  1148.         $this->receiptEmployee = $receiptEmployee;
  1150.         return $this;
  1151.     }
  1153.     public function getCustomer(): ?Customer
  1154.     {
  1155.         return $this->customer;
  1156.     }
  1158.     public function setCustomer(?Customer $customer): self
  1159.     {
  1160.         $this->customer = $customer;
  1162.         return $this;
  1163.     }
  1165.     public function getCustomerAddress(): ?CustomerAddress
  1166.     {
  1167.         return $this->customerAddress;
  1168.     }
  1170.     public function setCustomerAddress(?CustomerAddress $customerAddress): self
  1171.     {
  1172.         $this->customerAddress = $customerAddress;
  1174.         return $this;
  1175.     }
  1177.     public function getDailyFinancialStatement(): ?DailyFinancialStatement
  1178.     {
  1179.         return $this->dailyFinancialStatement;
  1180.     }
  1182.     public function setDailyFinancialStatement(?DailyFinancialStatement $dailyFinancialStatement): self
  1183.     {
  1184.         $this->dailyFinancialStatement = $dailyFinancialStatement;
  1186.         return $this;
  1187.     }
  1189.     /**
  1190.      * @return Collection<int, FiskalyReceiptType>
  1191.      */
  1192.     public function getFiskalyReceiptTypes(): Collection
  1193.     {
  1194.         return $this->fiskalyReceiptTypes;
  1195.     }
  1197.     public function addFiskalyReceiptType(FiskalyReceiptType $fiskalyReceiptType): self
  1198.     {
  1199.         if (!$this->fiskalyReceiptTypes->contains($fiskalyReceiptType)) {
  1200.             $this->fiskalyReceiptTypes[] = $fiskalyReceiptType;
  1201.             $fiskalyReceiptType->addReceipt($this);
  1202.         }
  1204.         return $this;
  1205.     }
  1207.     public function removeFiskalyReceiptType(FiskalyReceiptType $fiskalyReceiptType): self
  1208.     {
  1209.         if ($this->fiskalyReceiptTypes->removeElement($fiskalyReceiptType)) {
  1210.             $fiskalyReceiptType->removeReceipt($this);
  1211.         }
  1213.         return $this;
  1214.     }
  1215. }