src/Entity/PointTransaction.php line 21

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\PointTransactionRepository;
  6. use App\Traits\DateTrait;
  7. use DateTime;
  8. use DateTimeInterface;
  9. use Doctrine\Common\Collections\ArrayCollection;
  10. use Doctrine\Common\Collections\Collection;
  11. use Doctrine\ORM\Mapping as ORM;
  12. use JMS\Serializer\Annotation as Serializer;
  13. use JMS\Serializer\Annotation\Expose;
  14. use Symfony\Component\Validator\Constraints as Assert;
  16. /**
  17. * @ORM\Entity(repositoryClass=PointTransactionRepository::class)
  18. *
  19. * @Serializer\ExclusionPolicy("ALL")
  20. */
  21. class PointTransaction
  22. {
  23. use DateTrait;
  25. public CONST TRANSACTION_FEES_TYPE_FEES = 'fees';
  26. public CONST TRANSACTION_FEES_TYPE_SHIPPING_PRICE = 'shipping_price';
  27. public CONST USER_VALIDATION_TRANSACTION_TYPE = 'user_validation';
  28. public CONST TRANSACTION_GOD_CHILD = 'god_child';
  29. public CONST TRANSACTION_GOD_FATHER = 'god_father';
  30. public CONST TRANSACTION_ANIMATION = 'animation';
  32. /** Solde des commandes */
  33. private int $orderSolde = 0;
  35. /** Solde des points de fidélités */
  36. private int $fidelitySolde = 0;
  38. /**
  39. * Identifiant unique auto-incrémenté
  40. *
  41. * @ORM\Id
  42. * @ORM\GeneratedValue
  43. * @ORM\Column(type="integer")
  44. *
  45. * @Expose
  46. * @Serializer\Groups({"point_transaction:id"})
  47. */
  48. private ?int $id = NULL;
  50. /**
  51. * Utilisateur lié à la transaction
  52. *
  53. * @ORM\ManyToOne(targetEntity=User::class, inversedBy="pointTransactions")
  54. * @ORM\JoinColumn(nullable=false)
  55. *
  56. * @Expose
  57. * @Serializer\Groups({"point_transaction:user"})
  58. */
  59. private ?User $user = NULL;
  61. /**
  62. * Commande liée à la transaction
  63. *
  64. * @ORM\ManyToOne(targetEntity=SaleOrder::class, inversedBy="pointTransactions")
  65. */
  66. private ?SaleOrder $saleOrder = NULL;
  68. /**
  69. * Valeur de la transaction
  70. *
  71. * @ORM\Column(type="float")
  72. *
  73. * @Expose
  74. * @Serializer\Groups({"point_transaction:value"})
  75. */
  76. private ?float $value = NULL;
  78. /**
  79. * Label de la transaction
  80. *
  81. * @ORM\Column(type="string", length=255)
  82. *
  83. * @Assert\NotBlank
  84. *
  85. * @Expose
  86. * @Serializer\Groups({"point_transaction:label"})
  87. */
  88. private ?string $label = NULL;
  90. /**
  91. * Référence du paiement par carte
  92. *
  93. * @ORM\Column(type="string", length=255, nullable=true)
  94. *
  95. * @Expose
  96. * @Serializer\Groups({"point_transaction:paymentReference"})
  97. */
  98. private ?string $paymentReference = NULL;
  100. /**
  101. * Future valeur de la transaction lors d'un paiement par carte
  102. * Ce montant sera attribué à la valeur réelle après le retour IPN de la banque
  103. *
  104. * @ORM\Column(type="float", nullable=true)
  105. *
  106. * @Expose
  107. * @Serializer\Groups({"point_transaction:value"})
  108. */
  109. private ?float $paymentValue = NULL;
  111. /**
  112. * Informations reçues lors du retour IPN de la banque
  113. *
  114. * @ORM\Column(type="json", nullable=true)
  115. *
  116. * @Expose
  117. * @Serializer\Groups({"point_transaction:paymentInformations"})
  118. */
  119. private ?array $paymentInformations = [];
  121. /**
  122. * Date d'expiration de la transaction
  123. *
  124. * @ORM\Column(type="datetime", nullable=true)
  125. */
  126. private ?DateTime $expiredAt = NULL;
  128. /**
  129. * Transaction liée à une autre transaction
  130. *
  131. * @ORM\ManyToOne(
  132. * targetEntity=PointTransaction::class,
  133. * inversedBy="childrenPointTransactions",
  134. * cascade={"persist", "remove"}
  135. * )
  136. */
  137. private ?PointTransaction $linkedPointTransaction = NULL;
  139. /**
  140. * Liste des transactions enfants liées à la transaction
  141. *
  142. * @ORM\OneToMany(targetEntity=PointTransaction::class, mappedBy="linkedPointTransaction", orphanRemoval=true)
  143. */
  144. private ?Collection $childrenPointTransactions = null;
  146. /**
  147. * Type de transaction
  148. *
  149. * @ORM\ManyToOne(targetEntity=PointTransactionType::class, inversedBy="pointTransactions")
  150. * @ORM\JoinColumn(nullable=false)
  151. */
  152. private ?PointTransactionType $transactionType = NULL;
  154. /**
  155. * Déclaration d'achat liée à la transaction
  156. *
  157. * @ORM\ManyToOne(targetEntity=Purchase::class, inversedBy="pointTransactions")
  158. */
  159. private ?Purchase $purchase = NULL;
  161. /**
  162. * Historique d'import lié à la transaction
  163. *
  164. * @ORM\ManyToOne(
  165. * targetEntity=PointTransactionImportHistory::class,
  166. * inversedBy="pointTransactions",
  167. * cascade={"persist"}
  168. * )
  169. */
  170. private ?PointTransactionImportHistory $importHistory = NULL;
  172. /**
  173. * Date d'effet de la transaction
  174. *
  175. * @ORM\Column(type="datetime", nullable=true)
  176. */
  177. private ?DateTimeInterface $effectiveAt = NULL;
  179. /**
  180. * Méthode d'import de la transaction
  181. *
  182. * @ORM\Column(type="string", length=32, nullable=true)
  183. */
  184. private ?string $importMethod = NULL;
  186. /**
  187. * Commande de produit personnalisé liée à la transaction
  188. *
  189. * @ORM\ManyToOne(targetEntity=CustomProductOrder::class)
  190. */
  191. private ?CustomProductOrder $customProductOrder = NULL;
  193. /**
  194. * Résultat d'activité lié à la transaction
  195. *
  196. * @ORM\OneToOne(
  197. * targetEntity=UserBusinessResult::class,
  198. * inversedBy="pointTransaction",
  199. * cascade={"persist", "remove"}
  200. * )
  201. */
  202. private ?UserBusinessResult $businessResult = NULL;
  204. /**
  205. * Catégorie de la transaction
  206. *
  207. * @ORM\Column(type="string", length=64, nullable=true)
  208. */
  209. private ?string $category = NULL;
  211. /**
  212. * On lie un SaleOrderItem a une transaction seulement à l'annulation, pour pouvoir lier un remboursement a un produit
  213. *
  214. * @ORM\ManyToOne(targetEntity=SaleOrderItem::class, inversedBy="pointTransactions", cascade={"persist"})
  215. */
  216. private ?SaleOrderItem $saleOrderItem = null;
  218. /**
  219. * Panier lié à la transaction quand elle est validée (retour de l'utilisateur depuis l'interface de la banque)
  220. * même si elle n'est pas encore confirmée par la banque (retour automatique IPN)
  221. * quand elle est confirmée, on lui attribue le montant correspondant, sinon il reste à 0
  222. *
  223. * @ORM\ManyToOne(targetEntity=Cart::class,inversedBy="paidPointTransactions")
  224. * @ORM\JoinColumn(nullable=true, onDelete="SET NULL")
  225. */
  226. private ?Cart $paidCart = NULL;
  228. /**
  229. * Panier lié à la transaction, dans le cadre d'un paiement par carte avant que la transaction ne soit validée
  230. *
  231. * @ORM\ManyToOne(targetEntity=Cart::class,inversedBy="pointTransactions")
  232. * @ORM\JoinColumn(nullable=true, onDelete="SET NULL")
  233. */
  234. private ?Cart $cart = NULL;
  236. /**
  237. * @ORM\ManyToMany(targetEntity=Invoice::class, mappedBy="transactionPoints")
  238. */
  239. private Collection $invoices;
  242. /**
  243. * Type de frais de la transaction
  244. *
  245. * @ORM\Column(type="string", length=64, nullable=true)
  246. */
  247. private ?string $subtype = NULL;
  249. /**
  250. * @ORM\Column(type="string", length=255, nullable=true)
  251. */
  252. private $eventKey;
  255. public function __construct()
  256. {
  257. $this->childrenPointTransactions = new ArrayCollection();
  258. $this->invoices = new ArrayCollection();
  259. }
  262. public function __toString()
  263. {
  264. return $this->getValue() . ' - ' . $this->getLabel();
  265. }
  268. // MÉTHODES NÉCESSAIRES POUR LE CALCUL DE POINT : NE PAS EFFACER
  269. public function setOrderSolde($orderSolde): PointTransaction
  270. {
  271. $this->orderSolde += $orderSolde;
  273. return $this;
  274. }
  277. public function getOrderSolde(): int
  278. {
  279. return $this->orderSolde;
  280. }
  283. public function setFidelitySolde($fidelitySolde): PointTransaction
  284. {
  285. $this->fidelitySolde += $fidelitySolde;
  287. return $this;
  288. }
  291. public function getFidelitySolde(): int
  292. {
  293. return $this->fidelitySolde;
  294. }
  297. // END METHODES
  299. public function getId(): ?int
  300. {
  301. return $this->id;
  302. }
  305. public function getValue(): ?float
  306. {
  307. return $this->value;
  308. }
  311. public function setValue(float $value): self
  312. {
  313. $this->value = $value;
  315. return $this;
  316. }
  319. public function getLabel(): ?string
  320. {
  321. $label = $this->label;
  323. if($this->getTransactionType(true) === PointTransactionType::PAYMENT) $label .= ' ('.$this->getPaymentReference().')';
  325. return $label;
  326. }
  329. public function setLabel(string $label): self
  330. {
  331. $this->label = $label;
  333. return $this;
  334. }
  337. public function getExpiredAt(): ?DateTimeInterface
  338. {
  339. return $this->expiredAt;
  340. }
  343. public function setExpiredAt(?DateTime $expiredAt): self
  344. {
  345. $this->expiredAt = $expiredAt;
  347. return $this;
  348. }
  351. public function getEffectiveAt(): ?DateTimeInterface
  352. {
  353. return $this->effectiveAt;
  354. }
  357. public function setEffectiveAt(?DateTimeInterface $effectiveAt): self
  358. {
  359. $this->effectiveAt = $effectiveAt;
  361. return $this;
  362. }
  365. public function getImportMethod(): ?string
  366. {
  367. return $this->importMethod;
  368. }
  371. public function setImportMethod(?string $importMethod): self
  372. {
  373. $this->importMethod = $importMethod;
  375. return $this;
  376. }
  379. public function getCategory(): ?string
  380. {
  381. return $this->category;
  382. }
  385. public function setCategory(?string $category): self
  386. {
  387. $this->category = $category;
  389. return $this;
  390. }
  393. public function getUser(): ?User
  394. {
  395. return $this->user;
  396. }
  399. public function setUser(?User $user): self
  400. {
  401. $this->user = $user;
  403. return $this;
  404. }
  407. public function getSaleOrder(): ?SaleOrder
  408. {
  409. return $this->saleOrder;
  410. }
  413. public function setSaleOrder(?SaleOrder $saleOrder): self
  414. {
  415. if($this->saleOrder === $saleOrder) return $this;
  417. if($this->saleOrder !== null) $this->saleOrder->removePointTransaction($this);
  419. $this->saleOrder = $saleOrder;
  421. if($saleOrder !== null && !$saleOrder->getPointTransactions()->contains($this)) $saleOrder->addPointTransaction($this);
  423. return $this;
  424. }
  427. public function getLinkedPointTransaction(): ?self
  428. {
  429. return $this->linkedPointTransaction;
  430. }
  433. public function setLinkedPointTransaction(?self $linkedPointTransaction): self
  434. {
  435. $this->linkedPointTransaction = $linkedPointTransaction;
  437. return $this;
  438. }
  441. /**
  442. * @return Collection<int, PointTransaction>
  443. */
  444. public function getChildrenPointTransactions(): Collection
  445. {
  446. return $this->childrenPointTransactions;
  447. }
  450. public function addChildrenPointTransaction(PointTransaction $childrenPointTransaction): self
  451. {
  452. if (!$this->childrenPointTransactions->contains($childrenPointTransaction)) {
  453. $this->childrenPointTransactions[] = $childrenPointTransaction;
  454. $childrenPointTransaction->setLinkedPointTransaction($this);
  455. }
  457. return $this;
  458. }
  461. public function removeChildrenPointTransaction(PointTransaction $childrenPointTransaction): self
  462. {
  463. if ($this->childrenPointTransactions->removeElement($childrenPointTransaction)) {
  464. // set the owning side to null (unless already changed)
  465. if ($childrenPointTransaction->getLinkedPointTransaction() === $this) {
  466. $childrenPointTransaction->setLinkedPointTransaction(NULL);
  467. }
  468. }
  470. return $this;
  471. }
  473. /**
  474. * @param bool $getSlug
  475. * @return PointTransactionType|null|string
  476. */
  477. public function getTransactionType(bool $getSlug = false)
  478. {
  479. if(!$getSlug || !$this->transactionType) return $this->transactionType;
  481. return $this->transactionType->getSlug();
  482. }
  485. public function setTransactionType(?PointTransactionType $transactionType): self
  486. {
  487. $this->transactionType = $transactionType;
  489. return $this;
  490. }
  493. public function getPurchase(): ?Purchase
  494. {
  495. return $this->purchase;
  496. }
  499. public function setPurchase(?Purchase $purchase): self
  500. {
  501. $this->purchase = $purchase;
  503. return $this;
  504. }
  507. public function getImportHistory(): ?PointTransactionImportHistory
  508. {
  509. return $this->importHistory;
  510. }
  513. public function setImportHistory(?PointTransactionImportHistory $importHistory): self
  514. {
  515. $this->importHistory = $importHistory;
  517. return $this;
  518. }
  521. public function getCustomProductOrder(): ?CustomProductOrder
  522. {
  523. return $this->customProductOrder;
  524. }
  527. public function setCustomProductOrder(?CustomProductOrder $customProductOrder): self
  528. {
  529. $this->customProductOrder = $customProductOrder;
  531. return $this;
  532. }
  535. public function getBusinessResult(): ?UserBusinessResult
  536. {
  537. return $this->businessResult;
  538. }
  541. public function setBusinessResult(?UserBusinessResult $businessResult): self
  542. {
  543. $this->businessResult = $businessResult;
  545. return $this;
  546. }
  548. public function getSaleOrderItem(): ?SaleOrderItem
  549. {
  550. return $this->saleOrderItem;
  551. }
  553. public function setSaleOrderItem(?SaleOrderItem $saleOrderItem): self
  554. {
  555. if ($this->saleOrderItem === $saleOrderItem) {
  556. return $this;
  557. }
  559. if ($this->saleOrderItem !== null) {
  560. $this->saleOrderItem->removePointTransaction($this);
  561. }
  563. $this->saleOrderItem = $saleOrderItem;
  565. if ($saleOrderItem !== null && !$saleOrderItem->getPointTransactions()->contains($this)) {
  566. $saleOrderItem->addPointTransaction($this);
  567. }
  569. return $this;
  570. }
  572. /**
  573. * @return string|null
  574. */
  575. public function getPaymentReference(): ?string
  576. {
  577. return $this->paymentReference;
  578. }
  581. /**
  582. * @param string|null $paymentReference
  583. *
  584. * @return PointTransaction
  585. */
  586. public function setPaymentReference(?string $paymentReference): PointTransaction
  587. {
  588. $this->paymentReference = $paymentReference;
  589. return $this;
  590. }
  593. /**
  594. * @return array
  595. */
  596. public function getPaymentInformations(): array
  597. {
  598. if($this->paymentInformations === null) $this->paymentInformations = [];
  599. return $this->paymentInformations;
  600. }
  603. /**
  604. * @param array|null $paymentInformations
  605. *
  606. * @return PointTransaction
  607. */
  608. public function setPaymentInformations(?array $paymentInformations = []): PointTransaction
  609. {
  610. if($paymentInformations === null) $paymentInformations = [];
  612. $this->paymentInformations = $paymentInformations;
  613. return $this;
  614. }
  617. /**
  618. * @param string $key
  619. * @param $value
  620. *
  621. * @return $this
  622. */
  623. public function addPaymentInformation(string $key, $value): PointTransaction
  624. {
  625. $this->paymentInformations[$key] = $value;
  626. return $this;
  627. }
  630. /**
  631. * @param string $key
  632. *
  633. * @return $this
  634. */
  635. public function removePaymentInformation(string $key): PointTransaction
  636. {
  637. unset($this->paymentInformations[$key]);
  638. return $this;
  639. }
  642. /**
  643. * @return float|null
  644. */
  645. public function getPaymentValue(): ?float
  646. {
  647. return $this->paymentValue;
  648. }
  651. /**
  652. * @param float|null $paymentValue
  653. *
  654. * @return PointTransaction
  655. */
  656. public function setPaymentValue(?float $paymentValue): PointTransaction
  657. {
  658. $this->paymentValue = $paymentValue;
  659. return $this;
  660. }
  663. /**
  664. * @return Cart|null
  665. */
  666. public function getPaidCart(): ?Cart
  667. {
  668. return $this->paidCart;
  669. }
  672. /**
  673. * @param Cart|null $paidCart
  674. *
  675. * @return PointTransaction
  676. */
  677. public function setPaidCart(?Cart $paidCart = null): self
  678. {
  679. if($this->paidCart === $paidCart) return $this;
  681. if($this->paidCart !== null) $this->paidCart->removePaidPointTransaction($this);
  683. $this->paidCart = $paidCart;
  685. if($paidCart !== null && !$paidCart->getPaidPointTransactions()->contains($this)) $paidCart->addPaidPointTransaction($this);
  687. return $this;
  688. }
  691. /**
  692. * @return Cart|null
  693. */
  694. public function getCart(): ?Cart
  695. {
  696. return $this->cart;
  697. }
  700. /**
  701. * @param Cart|null $cart
  702. *
  703. * @return PointTransaction
  704. */
  705. public function setCart(?Cart $cart = null): self
  706. {
  707. if($this->cart === $cart) return $this;
  709. if($this->cart !== null) $this->cart->removePointTransaction($this);
  711. $this->cart = $cart;
  713. if($cart !== null && !$cart->getPointTransactions()->contains($this)) $cart->addPointTransaction($this);
  715. return $this;
  716. }
  719. public function getSubtype(): ?string
  720. {
  721. return $this->subtype;
  722. }
  725. public function setSubtype(?string $subtype): self
  726. {
  727. $this->subtype = $subtype;
  729. return $this;
  730. }
  732. /**
  733. * @return Collection<int, Invoice>
  734. */
  735. public function getInvoices(): Collection
  736. {
  737. return $this->invoices;
  738. }
  740. public function addInvoice(Invoice $invoice): self
  741. {
  742. if (!$this->invoices->contains($invoice)) {
  743. $this->invoices[] = $invoice;
  744. $invoice->addPointTransaction($this);
  745. }
  747. return $this;
  748. }
  750. public function removeInvoice(Invoice $invoice): self
  751. {
  752. if ($this->invoices->removeElement($invoice)) {
  753. $invoice->removePointTransaction($this);
  754. }
  756. return $this;
  757. }
  759. public function getEventKey(): ?string
  760. {
  761. return $this->eventKey;
  762. }
  764. public function setEventKey(?string $eventKey): self
  765. {
  766. $this->eventKey = $eventKey;
  768. return $this;
  769. }
  770. }