vendor/bluue/sales-bundle/src/Entity/Payment.php line 44

Open in your IDE?
  1. <?php
  3. /**
  4.  * @author Quentin CHATELAIN (contact@scaledev.fr)
  5.  * @copyright 2021 - ScaleDEV SAS, 12 RUE CHARLES MORET, 10120 ST ANDRE LES VERGERS
  6.  * @license commercial
  7.  */
  9. declare(strict_types=1);
  11. namespace Bluue\SalesBundle\Entity;
  13. use App\Entity\Context;
  14. use App\Entity\Currency;
  15. use App\Entity\Establishment;
  16. use App\Entity\Traits\EntityManagerServiceEntity;
  17. use App\Services\SoftdeleteFilter;
  18. use DateTimeInterface;
  19. use Doctrine\Common\Collections\ArrayCollection;
  20. use Doctrine\Common\Collections\Collection;
  21. use Bluue\CustomersBundle\Entity\Customer;
  22. use Doctrine\ORM\Mapping as ORM;
  23. use Doctrine\ORM\NonUniqueResultException;
  24. use Symfony\Component\Uid\Uuid;
  25. use Symfony\Bridge\Doctrine\IdGenerator\UuidGenerator;
  26. use Gedmo\Mapping\Annotation as Gedmo;
  27. use Bluue\SalesBundle\Repository\PaymentRepository;
  28. use App\DoctrineExtensions\Timestampable\Traits\UserTimestampableEntity;
  29. use App\DoctrineExtensions\SoftDeleteable\Traits\UserSoftDeleteableEntity;
  31. /**
  32.  * @ORM\Entity(repositoryClass=PaymentRepository::class)
  33.  * @ORM\Table(name="sales_bundle__payment", indexes={
  34.  *  @ORM\Index(name="payment_date", columns={"payment_date"}),
  35.  *  @ORM\Index(name="reference", columns={"reference"}),
  36.  *  @ORM\Index(name="receipt", columns={"receipt"}),
  37.  *  @ORM\Index(name="refund", columns={"refund"}),
  38.  *  @ORM\Index(name="deleted_at", columns={"deleted_at"}),
  39.  *  @ORM\Index(name="created_at", columns={"created_at"}),
  40.  *  @ORM\Index(name="updated_at", columns={"updated_at"})
  41.  * })
  42.  * @Gedmo\SoftDeleteable(fieldName="deletedAt", timeAware=false, hardDelete=false)
  43.  */
  44. class Payment
  45. {
  46.     use UserTimestampableEntity;
  47.     use UserSoftDeleteableEntity;
  48.     use EntityManagerServiceEntity;
  50.     /**
  51.      * @ORM\Id
  52.      * @ORM\Column(type="uuid")
  53.      * @ORM\GeneratedValue(strategy="CUSTOM")
  54.      * @ORM\CustomIdGenerator(class=UuidGenerator::class)
  55.      */
  56.     private ?Uuid $id = null;
  58.     /**
  59.      * @ORM\ManyToOne(targetEntity=Context::class)
  60.      */
  61.     private ?Context $context = null;
  63.     /**
  64.      * @ORM\ManyToOne(targetEntity=Establishment::class)
  65.      */
  66.     private ?Establishment $establishment = null;
  68.     /**
  69.      * @ORM\ManyToOne(targetEntity=Customer::class)
  70.      * @ORM\JoinColumn(nullable=false)
  71.      */
  72.     private ?Customer $customer = null;
  74.     /**
  75.      * @ORM\ManyToOne(targetEntity=CreditNote::class)
  76.      */
  77.     private ?CreditNote $credit_note = null;
  79.     /**
  80.      * @ORM\ManyToOne(targetEntity=Invoice::class)
  81.      */
  82.     private ?Invoice $invoice = null;
  84.     /**
  85.      * @ORM\ManyToOne(targetEntity=PaymentMethod::class)
  86.      * @ORM\JoinColumn(nullable=false)
  87.      */
  88.     private ?PaymentMethod $payment_method = null;
  90.     /**
  91.      * @ORM\ManyToOne(targetEntity=Bank::class)
  92.      */
  93.     private ?Bank $bank = null;
  95.     /**
  96.      * @ORM\ManyToOne(targetEntity=Currency::class)
  97.      * @ORM\JoinColumn(nullable=false)
  98.      */
  99.     private ?Currency $currency = null;
  101.     /**
  102.      * @ORM\Column(type="decimal", precision=20, scale=12)
  103.      */
  104.     private ?string $currency_change_rate = null;
  106.     /**
  107.      * @ORM\Column(type="string", length=128, nullable="true")
  108.      */
  109.     private ?string $reference = null;
  111.     /**
  112.      * @ORM\Column(type="decimal", precision=20, scale=6, nullable="true")
  113.      */
  114.     private ?string $receipt = null;
  116.     /**
  117.      * @ORM\Column(type="decimal", precision=20, scale=6, nullable="true")
  118.      */
  119.     private ?string $refund = null;
  121.     /**
  122.      * @ORM\Column(type="decimal", precision=20, scale=6, nullable="true")
  123.      */
  124.     private ?string $residual = null;
  126.     /**
  127.      * @ORM\Column(type="datetime")
  128.      */
  129.     private ?DateTimeInterface $payment_date = null;
  131.     /**
  132.      * @ORM\OneToMany(targetEntity=DocumentPayment::class, mappedBy="payment", fetch="EXTRA_LAZY")
  133.      */
  134.     private Collection $document_payments;
  136.     public function __construct()
  137.     {
  138.         $this->document_payments = new ArrayCollection();
  139.     }
  141.     /**
  142.      * @return Uuid|null
  143.      */
  144.     public function getId(): ?Uuid
  145.     {
  146.         return $this->id;
  147.     }
  149.     /**
  150.      * @return Context|null
  151.      */
  152.     public function getContext(): ?Context
  153.     {
  154.         return $this->context;
  155.     }
  157.     /**
  158.      * @param Context|null $context
  159.      * @return Payment
  160.      */
  161.     public function setContext(?Context $context): self
  162.     {
  163.         $this->context = $context;
  164.         return $this;
  165.     }
  167.     /**
  168.      * @return Establishment|null
  169.      */
  170.     public function getEstablishment(): ?Establishment
  171.     {
  172.         return $this->establishment;
  173.     }
  175.     /**
  176.      * @param Establishment|null $establishment
  177.      * @return Payment
  178.      */
  179.     public function setEstablishment(?Establishment $establishment): Payment
  180.     {
  181.         $this->establishment = $establishment;
  182.         return $this;
  183.     }
  185.     /**
  186.      * @return Customer|null
  187.      * @throws NonUniqueResultException
  188.      */
  189.     public function getCustomer(): ?Customer
  190.     {
  191.         if ($this->em && $this->customer) {
  192.             SoftdeleteFilter::disable($this->em, [Customer::class]);
  193.             $customer = $this->em->getRepository(Customer::class)
  194.                 ->createQueryBuilder('c')
  195.                 ->where('c.id = :customer')
  196.                 ->setParameter('customer', $this->customer->getId()->toBinary())
  197.                 ->getQuery()
  198.                 ->getOneOrNullResult();
  199.             SoftdeleteFilter::enable($this->em, [Customer::class]);
  200.             return $customer;
  201.         }
  202.         return $this->customer;
  203.     }
  205.     /**
  206.      * @param Customer $customer
  207.      * @return $this
  208.      */
  209.     public function setCustomer(Customer $customer): self
  210.     {
  211.         $this->customer = $customer;
  212.         return $this;
  213.     }
  215.     /**
  216.      * @return CreditNote|null
  217.      */
  218.     public function getCreditNote(): ?CreditNote
  219.     {
  220.         return $this->credit_note;
  221.     }
  223.     /**
  224.      * @param CreditNote|null $credit_note
  225.      * @return Payment
  226.      * @throws NonUniqueResultException
  227.      */
  228.     public function setCreditNote(?CreditNote $credit_note): self
  229.     {
  230.         $this->credit_note = $credit_note;
  232.         $this->setCurrency($credit_note->getCurrency());
  233.         $this->setCurrencyChangeRate($credit_note->getCurrencyChangeRate());
  234.         $this->setReference($credit_note->getReference());
  236.         return $this->setCustomer($credit_note->getCustomer());
  237.     }
  239.     /**
  240.      * @return Invoice|null
  241.      * @throws NonUniqueResultException
  242.      */
  243.     public function getInvoice(): ?Invoice
  244.     {
  245.         if ($this->em && $this->invoice) {
  246.             SoftdeleteFilter::disable($this->em, [Invoice::class]);
  247.             $invoice = $this->em->getRepository(Invoice::class)
  248.                 ->createQueryBuilder('i')
  249.                 ->where('i.id = :invoiceId')
  250.                 ->setParameter('invoiceId', $this->invoice->getId()->toBinary())
  251.                 ->getQuery()
  252.                 ->getOneOrNullResult();
  253.             SoftdeleteFilter::enable($this->em, [Invoice::class]);
  254.             return $invoice;
  255.         }
  256.         return $this->invoice;
  257.     }
  259.     /**
  260.      * @param Invoice|null $invoice
  261.      * @return Payment
  262.      * @throws NonUniqueResultException
  263.      */
  264.     public function setInvoice(?Invoice $invoice): self
  265.     {
  266.         $this->invoice = $invoice;
  268.         $this->setCurrency($invoice->getCurrency());
  269.         $this->setCurrencyChangeRate($invoice->getCurrencyChangeRate());
  270.         $this->setReference($invoice->getReference());
  272.         return $this->setCustomer($invoice->getCustomer());
  273.     }
  275.     /**
  276.      * @return PaymentMethod|null
  277.      * @throws NonUniqueResultException
  278.      */
  279.     public function getPaymentMethod(): ?PaymentMethod
  280.     {
  281.         if ($this->em && $this->payment_method) {
  282.             SoftdeleteFilter::disable($this->em, [PaymentMethod::class]);
  283.             $payment_method = $this->em->getRepository(PaymentMethod::class)
  284.                 ->createQueryBuilder('pm')
  285.                 ->where('pm.id = :paymentMethodId')
  286.                 ->setParameter('paymentMethodId', $this->payment_method->getId()->toBinary())
  287.                 ->getQuery()
  288.                 ->getOneOrNullResult();
  289.             SoftdeleteFilter::enable($this->em, [PaymentMethod::class]);
  290.             return $payment_method;
  291.         }
  292.         return $this->payment_method;
  293.     }
  295.     /**
  296.      * @param PaymentMethod $payment_method
  297.      * @return $this
  298.      */
  299.     public function setPaymentMethod(PaymentMethod $payment_method): self
  300.     {
  301.         $this->payment_method = $payment_method;
  302.         return $this;
  303.     }
  305.     /**
  306.      * @return Bank|null
  307.      * @throws NonUniqueResultException
  308.      */
  309.     public function getBank(): ?Bank
  310.     {
  311.         if (!$this->bank) {
  312.             return null;
  313.         } elseif ($this->getId()) {
  314.             SoftdeleteFilter::disable($this->em, [Bank::class]);
  315.             $bank = $this->em->getRepository(Bank::class)
  316.                 ->createQueryBuilder('b')
  317.                 ->where('b.id = :bankId')
  318.                 ->setParameter('bankId', $this->bank->getId()->toBinary())
  319.                 ->getQuery()
  320.                 ->getOneOrNullResult();
  321.             SoftdeleteFilter::enable($this->em, [Bank::class]);
  322.             return $bank;
  323.         }
  324.         return null;
  325.     }
  327.     /**
  328.      * @param Bank|null $bank
  329.      */
  330.     public function setBank(?Bank $bank): void
  331.     {
  332.         $this->bank = $bank;
  333.     }
  335.     /**
  336.      * @return Currency|null
  337.      */
  338.     public function getCurrency(): ?Currency
  339.     {
  340.         return $this->currency;
  341.     }
  343.     /**
  344.      * @param Currency $currency
  345.      * @return $this
  346.      */
  347.     public function setCurrency(Currency $currency): self
  348.     {
  349.         $this->currency = $currency;
  351.         return $this->setCurrencyChangeRate($currency->getChangeRate());
  352.     }
  354.     /**
  355.      * @return string|null
  356.      */
  357.     public function getCurrencyChangeRate(): ?string
  358.     {
  359.         return $this->currency_change_rate;
  360.     }
  362.     /**
  363.      * @param string $currency_change_rate
  364.      * @return $this
  365.      */
  366.     public function setCurrencyChangeRate(string $currency_change_rate): self
  367.     {
  368.         $this->currency_change_rate = $currency_change_rate;
  369.         return $this;
  370.     }
  372.     /**
  373.      * @return string|null
  374.      */
  375.     public function getReference(): ?string
  376.     {
  377.         return $this->reference;
  378.     }
  380.     /**
  381.      * @param string|null $reference
  382.      * @return $this
  383.      */
  384.     public function setReference(?string $reference): self
  385.     {
  386.         $this->reference = $reference;
  387.         return $this;
  388.     }
  390.     /**
  391.      * @return string|null
  392.      */
  393.     public function getReceipt(): ?string
  394.     {
  395.         return $this->receipt;
  396.     }
  398.     /**
  399.      * @param string|null $receipt
  400.      * @return $this
  401.      */
  402.     public function setReceipt(?string $receipt): self
  403.     {
  404.         $this->receipt = $receipt;
  406.         return $receipt ? $this->setResidual($receipt) : $this;
  407.     }
  409.     /**
  410.      * @return string|null
  411.      */
  412.     public function getRefund(): ?string
  413.     {
  414.         return $this->refund;
  415.     }
  417.     /**
  418.      * @param string|null $refund
  419.      * @return $this
  420.      */
  421.     public function setRefund(?string $refund): self
  422.     {
  423.         $this->refund = $refund;
  425.         return $refund ? $this->setResidual($refund) : $this;
  426.     }
  428.     /**
  429.      * @return string|null
  430.      */
  431.     public function getResidual(): ?string
  432.     {
  433.         return $this->residual;
  434.     }
  436.     /**
  437.      * @param string|null $residual
  438.      * @return Payment
  439.      */
  440.     public function setResidual(?string $residual): self
  441.     {
  442.         $this->residual = $residual;
  443.         return $this;
  444.     }
  446.     /**
  447.      * @return DateTimeInterface|null
  448.      */
  449.     public function getPaymentDate(): ?DateTimeInterface
  450.     {
  451.         return $this->payment_date;
  452.     }
  454.     /**
  455.      * @param $payment_date
  456.      * @return $this
  457.      */
  458.     public function setPaymentDate($payment_date): self
  459.     {
  460.         if ($payment_date instanceof DateTimeInterface) {
  461.             $this->payment_date = $payment_date;
  462.         } elseif ($payment_date) {
  463.             $this->payment_date = new \DateTime($payment_date);
  464.         } else {
  465.             $this->payment_date = null;
  466.         }
  467.         return $this;
  468.     }
  470.     /**
  471.      * @return Collection|DocumentPayment[]
  472.      */
  473.     public function getDocumentPayments(): Collection
  474.     {
  475.         return $this->document_payments;
  476.     }
  478.     /**
  479.      * @return Invoice|CreditNote|null
  480.      * @throws NonUniqueResultException
  481.      */
  482.     public function getDocumentOrigin()
  483.     {
  484.         return $this->getInvoice() ?? $this->getCreditNote();
  485.     }
  487.     /**
  488.      * @return string|null
  489.      */
  490.     public function getAmount(): ?string
  491.     {
  492.         return $this->getReceipt() ?? $this->getRefund();
  493.     }
  494. }