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';
  29. /** Solde des commandes */
  30. private int $orderSolde = 0;
  32. /** Solde des points de fidélités */
  33. private int $fidelitySolde = 0;
  35. /**
  36. * Identifiant unique auto-incrémenté
  37. *
  38. * @ORM\Id
  39. * @ORM\GeneratedValue
  40. * @ORM\Column(type="integer")
  41. *
  42. * @Expose
  43. * @Serializer\Groups({"point_transaction:id"})
  44. */
  45. private ?int $id = NULL;
  47. /**
  48. * Utilisateur lié à la transaction
  49. *
  50. * @ORM\ManyToOne(targetEntity=User::class, inversedBy="pointTransactions")
  51. * @ORM\JoinColumn(nullable=false)
  52. *
  53. * @Expose
  54. * @Serializer\Groups({"point_transaction:user"})
  55. */
  56. private ?User $user = NULL;
  58. /**
  59. * Commande liée à la transaction
  60. *
  61. * @ORM\ManyToOne(targetEntity=SaleOrder::class, inversedBy="pointTransactions")
  62. */
  63. private ?SaleOrder $saleOrder = NULL;
  65. /**
  66. * Valeur de la transaction
  67. *
  68. * @ORM\Column(type="float")
  69. *
  70. * @Expose
  71. * @Serializer\Groups({"point_transaction:value"})
  72. */
  73. private ?float $value = NULL;
  75. /**
  76. * Label de la transaction
  77. *
  78. * @ORM\Column(type="string", length=255)
  79. *
  80. * @Assert\NotBlank
  81. *
  82. * @Expose
  83. * @Serializer\Groups({"point_transaction:label"})
  84. */
  85. private ?string $label = NULL;
  87. /**
  88. * Référence du paiement par carte
  89. *
  90. * @ORM\Column(type="string", length=255, nullable=true)
  91. *
  92. * @Expose
  93. * @Serializer\Groups({"point_transaction:paymentReference"})
  94. */
  95. private ?string $paymentReference = NULL;
  97. /**
  98. * Future valeur de la transaction lors d'un paiement par carte
  99. * Ce montant sera attribué à la valeur réelle après le retour IPN de la banque
  100. *
  101. * @ORM\Column(type="float", nullable=true)
  102. *
  103. * @Expose
  104. * @Serializer\Groups({"point_transaction:value"})
  105. */
  106. private ?float $paymentValue = NULL;
  108. /**
  109. * Informations reçues lors du retour IPN de la banque
  110. *
  111. * @ORM\Column(type="json", nullable=true)
  112. *
  113. * @Expose
  114. * @Serializer\Groups({"point_transaction:paymentInformations"})
  115. */
  116. private ?array $paymentInformations = [];
  118. /**
  119. * Date d'expiration de la transaction
  120. *
  121. * @ORM\Column(type="datetime", nullable=true)
  122. */
  123. private ?DateTime $expiredAt = NULL;
  125. /**
  126. * Transaction liée à une autre transaction
  127. *
  128. * @ORM\ManyToOne(
  129. * targetEntity=PointTransaction::class,
  130. * inversedBy="childrenPointTransactions",
  131. * cascade={"persist", "remove"}
  132. * )
  133. */
  134. private ?PointTransaction $linkedPointTransaction = NULL;
  136. /**
  137. * Liste des transactions enfants liées à la transaction
  138. *
  139. * @ORM\OneToMany(targetEntity=PointTransaction::class, mappedBy="linkedPointTransaction", orphanRemoval=true)
  140. */
  141. private ?Collection $childrenPointTransactions;
  143. /**
  144. * Type de transaction
  145. *
  146. * @ORM\ManyToOne(targetEntity=PointTransactionType::class, inversedBy="pointTransactions")
  147. * @ORM\JoinColumn(nullable=false)
  148. */
  149. private ?PointTransactionType $transactionType = NULL;
  151. /**
  152. * Déclaration d'achat liée à la transaction
  153. *
  154. * @ORM\ManyToOne(targetEntity=Purchase::class, inversedBy="pointTransactions")
  155. */
  156. private ?Purchase $purchase = NULL;
  158. /**
  159. * Historique d'import lié à la transaction
  160. *
  161. * @ORM\ManyToOne(
  162. * targetEntity=PointTransactionImportHistory::class,
  163. * inversedBy="pointTransactions",
  164. * cascade={"persist"}
  165. * )
  166. */
  167. private ?PointTransactionImportHistory $importHistory = NULL;
  169. /**
  170. * Date d'effet de la transaction
  171. *
  172. * @ORM\Column(type="datetime", nullable=true)
  173. */
  174. private ?DateTimeInterface $effectiveAt = NULL;
  176. /**
  177. * Méthode d'import de la transaction
  178. *
  179. * @ORM\Column(type="string", length=32, nullable=true)
  180. */
  181. private ?string $importMethod = NULL;
  183. /**
  184. * Commande de produit personnalisé liée à la transaction
  185. *
  186. * @ORM\ManyToOne(targetEntity=CustomProductOrder::class)
  187. */
  188. private ?CustomProductOrder $customProductOrder = NULL;
  190. /**
  191. * Résultat d'activité lié à la transaction
  192. *
  193. * @ORM\OneToOne(
  194. * targetEntity=UserBusinessResult::class,
  195. * inversedBy="pointTransaction",
  196. * cascade={"persist", "remove"}
  197. * )
  198. */
  199. private ?UserBusinessResult $businessResult = NULL;
  201. /**
  202. * Catégorie de la transaction
  203. *
  204. * @ORM\Column(type="string", length=64, nullable=true)
  205. */
  206. private ?string $category = NULL;
  208. /**
  209. * On lie un SaleOrderItem a une transaction seulement à l'annulation, pour pouvoir lier un remboursement a un produit
  210. *
  211. * @ORM\ManyToOne(targetEntity=SaleOrderItem::class, inversedBy="pointTransaction", cascade={"persist"})
  212. */
  213. private ?SaleOrderItem $saleOrderItem = null;
  215. /**
  216. * Panier lié à la transaction quand elle est validée (retour de l'utilisateur depuis l'interface de la banque)
  217. * même si elle n'est pas encore confirmée par la banque (retour automatique IPN)
  218. * quand elle est confirmée, on lui attribue le montant correspondant, sinon il reste à 0
  219. *
  220. * @ORM\ManyToOne(targetEntity=Cart::class,inversedBy="paidPointTransactions")
  221. * @ORM\JoinColumn(nullable=true, onDelete="SET NULL")
  222. */
  223. private ?Cart $paidCart = NULL;
  225. /**
  226. * Panier lié à la transaction, dans le cadre d'un paiement par carte avant que la transaction ne soit validée
  227. *
  228. * @ORM\ManyToOne(targetEntity=Cart::class,inversedBy="pointTransactions")
  229. * @ORM\JoinColumn(nullable=true, onDelete="SET NULL")
  230. */
  231. private ?Cart $cart = NULL;
  233. /**
  234. * @ORM\ManyToMany(targetEntity=Invoice::class, mappedBy="transactionPoints")
  235. */
  236. private Collection $invoices;
  239. /**
  240. * Type de frais de la transaction
  241. *
  242. * @ORM\Column(type="string", length=64, nullable=true)
  243. */
  244. private ?string $subtype = NULL;
  246. /**
  247. * @ORM\Column(type="string", length=255, nullable=true)
  248. */
  249. private $eventKey;
  252. public function __construct()
  253. {
  254. $this->childrenPointTransactions = new ArrayCollection();
  255. $this->invoices = new ArrayCollection();
  256. }
  259. public function __toString()
  260. {
  261. return $this->getValue() . ' - ' . $this->getLabel();
  262. }
  265. // MÉTHODES NÉCESSAIRES POUR LE CALCUL DE POINT : NE PAS EFFACER
  266. public function setOrderSolde($orderSolde): PointTransaction
  267. {
  268. $this->orderSolde += $orderSolde;
  270. return $this;
  271. }
  274. public function getOrderSolde(): int
  275. {
  276. return $this->orderSolde;
  277. }
  280. public function setFidelitySolde($fidelitySolde): PointTransaction
  281. {
  282. $this->fidelitySolde += $fidelitySolde;
  284. return $this;
  285. }
  288. public function getFidelitySolde(): int
  289. {
  290. return $this->fidelitySolde;
  291. }
  294. // END METHODES
  296. public function getId(): ?int
  297. {
  298. return $this->id;
  299. }
  302. public function getValue(): ?float
  303. {
  304. return $this->value;
  305. }
  308. public function setValue(float $value): self
  309. {
  310. $this->value = $value;
  312. return $this;
  313. }
  316. public function getLabel(): ?string
  317. {
  318. $label = $this->label;
  320. if($this->getTransactionType(true) === PointTransactionType::PAYMENT) $label .= ' ('.$this->getPaymentReference().')';
  322. return $label;
  323. }
  326. public function setLabel(string $label): self
  327. {
  328. $this->label = $label;
  330. return $this;
  331. }
  334. public function getExpiredAt(): ?DateTimeInterface
  335. {
  336. return $this->expiredAt;
  337. }
  340. public function setExpiredAt(?DateTime $expiredAt): self
  341. {
  342. $this->expiredAt = $expiredAt;
  344. return $this;
  345. }
  348. public function getEffectiveAt(): ?DateTimeInterface
  349. {
  350. return $this->effectiveAt;
  351. }
  354. public function setEffectiveAt(?DateTimeInterface $effectiveAt): self
  355. {
  356. $this->effectiveAt = $effectiveAt;
  358. return $this;
  359. }
  362. public function getImportMethod(): ?string
  363. {
  364. return $this->importMethod;
  365. }
  368. public function setImportMethod(?string $importMethod): self
  369. {
  370. $this->importMethod = $importMethod;
  372. return $this;
  373. }
  376. public function getCategory(): ?string
  377. {
  378. return $this->category;
  379. }
  382. public function setCategory(?string $category): self
  383. {
  384. $this->category = $category;
  386. return $this;
  387. }
  390. public function getUser(): ?User
  391. {
  392. return $this->user;
  393. }
  396. public function setUser(?User $user): self
  397. {
  398. $this->user = $user;
  400. return $this;
  401. }
  404. public function getSaleOrder(): ?SaleOrder
  405. {
  406. return $this->saleOrder;
  407. }
  410. public function setSaleOrder(?SaleOrder $saleOrder): self
  411. {
  412. if($this->saleOrder === $saleOrder) return $this;
  414. if($this->saleOrder !== null) $this->saleOrder->removePointTransaction($this);
  416. $this->saleOrder = $saleOrder;
  418. if($saleOrder !== null && !$saleOrder->getPointTransactions()->contains($this)) $saleOrder->addPointTransaction($this);
  420. return $this;
  421. }
  424. public function getLinkedPointTransaction(): ?self
  425. {
  426. return $this->linkedPointTransaction;
  427. }
  430. public function setLinkedPointTransaction(?self $linkedPointTransaction): self
  431. {
  432. $this->linkedPointTransaction = $linkedPointTransaction;
  434. return $this;
  435. }
  438. /**
  439. * @return Collection<int, PointTransaction>
  440. */
  441. public function getChildrenPointTransactions(): Collection
  442. {
  443. return $this->childrenPointTransactions;
  444. }
  447. public function addChildrenPointTransaction(PointTransaction $childrenPointTransaction): self
  448. {
  449. if (!$this->childrenPointTransactions->contains($childrenPointTransaction)) {
  450. $this->childrenPointTransactions[] = $childrenPointTransaction;
  451. $childrenPointTransaction->setLinkedPointTransaction($this);
  452. }
  454. return $this;
  455. }
  458. public function removeChildrenPointTransaction(PointTransaction $childrenPointTransaction): self
  459. {
  460. if ($this->childrenPointTransactions->removeElement($childrenPointTransaction)) {
  461. // set the owning side to null (unless already changed)
  462. if ($childrenPointTransaction->getLinkedPointTransaction() === $this) {
  463. $childrenPointTransaction->setLinkedPointTransaction(NULL);
  464. }
  465. }
  467. return $this;
  468. }
  470. /**
  471. * @param bool $getSlug
  472. * @return PointTransactionType|null|string
  473. */
  474. public function getTransactionType(bool $getSlug = false)
  475. {
  476. if(!$getSlug || !$this->transactionType) return $this->transactionType;
  478. return $this->transactionType->getSlug();
  479. }
  482. public function setTransactionType(?PointTransactionType $transactionType): self
  483. {
  484. $this->transactionType = $transactionType;
  486. return $this;
  487. }
  490. public function getPurchase(): ?Purchase
  491. {
  492. return $this->purchase;
  493. }
  496. public function setPurchase(?Purchase $purchase): self
  497. {
  498. $this->purchase = $purchase;
  500. return $this;
  501. }
  504. public function getImportHistory(): ?PointTransactionImportHistory
  505. {
  506. return $this->importHistory;
  507. }
  510. public function setImportHistory(?PointTransactionImportHistory $importHistory): self
  511. {
  512. $this->importHistory = $importHistory;
  514. return $this;
  515. }
  518. public function getCustomProductOrder(): ?CustomProductOrder
  519. {
  520. return $this->customProductOrder;
  521. }
  524. public function setCustomProductOrder(?CustomProductOrder $customProductOrder): self
  525. {
  526. $this->customProductOrder = $customProductOrder;
  528. return $this;
  529. }
  532. public function getBusinessResult(): ?UserBusinessResult
  533. {
  534. return $this->businessResult;
  535. }
  538. public function setBusinessResult(?UserBusinessResult $businessResult): self
  539. {
  540. $this->businessResult = $businessResult;
  542. return $this;
  543. }
  545. public function getSaleOrderItem(): ?SaleOrderItem
  546. {
  547. return $this->saleOrderItem;
  548. }
  550. public function setSaleOrderItem(?SaleOrderItem $saleOrderItem): self
  551. {
  552. $this->saleOrderItem = $saleOrderItem;
  554. return $this;
  555. }
  557. /**
  558. * @return string|null
  559. */
  560. public function getPaymentReference(): ?string
  561. {
  562. return $this->paymentReference;
  563. }
  566. /**
  567. * @param string|null $paymentReference
  568. *
  569. * @return PointTransaction
  570. */
  571. public function setPaymentReference(?string $paymentReference): PointTransaction
  572. {
  573. $this->paymentReference = $paymentReference;
  574. return $this;
  575. }
  578. /**
  579. * @return array
  580. */
  581. public function getPaymentInformations(): array
  582. {
  583. if($this->paymentInformations === null) $this->paymentInformations = [];
  584. return $this->paymentInformations;
  585. }
  588. /**
  589. * @param array|null $paymentInformations
  590. *
  591. * @return PointTransaction
  592. */
  593. public function setPaymentInformations(?array $paymentInformations = []): PointTransaction
  594. {
  595. if($paymentInformations === null) $paymentInformations = [];
  597. $this->paymentInformations = $paymentInformations;
  598. return $this;
  599. }
  602. /**
  603. * @param string $key
  604. * @param $value
  605. *
  606. * @return $this
  607. */
  608. public function addPaymentInformation(string $key, $value): PointTransaction
  609. {
  610. $this->paymentInformations[$key] = $value;
  611. return $this;
  612. }
  615. /**
  616. * @param string $key
  617. *
  618. * @return $this
  619. */
  620. public function removePaymentInformation(string $key): PointTransaction
  621. {
  622. unset($this->paymentInformations[$key]);
  623. return $this;
  624. }
  627. /**
  628. * @return float|null
  629. */
  630. public function getPaymentValue(): ?float
  631. {
  632. return $this->paymentValue;
  633. }
  636. /**
  637. * @param float|null $paymentValue
  638. *
  639. * @return PointTransaction
  640. */
  641. public function setPaymentValue(?float $paymentValue): PointTransaction
  642. {
  643. $this->paymentValue = $paymentValue;
  644. return $this;
  645. }
  648. /**
  649. * @return Cart|null
  650. */
  651. public function getPaidCart(): ?Cart
  652. {
  653. return $this->paidCart;
  654. }
  657. /**
  658. * @param Cart|null $paidCart
  659. *
  660. * @return PointTransaction
  661. */
  662. public function setPaidCart(?Cart $paidCart = null): self
  663. {
  664. if($this->paidCart === $paidCart) return $this;
  666. if($this->paidCart !== null) $this->paidCart->removePaidPointTransaction($this);
  668. $this->paidCart = $paidCart;
  670. if($paidCart !== null && !$paidCart->getPaidPointTransactions()->contains($this)) $paidCart->addPaidPointTransaction($this);
  672. return $this;
  673. }
  676. /**
  677. * @return Cart|null
  678. */
  679. public function getCart(): ?Cart
  680. {
  681. return $this->cart;
  682. }
  685. /**
  686. * @param Cart|null $cart
  687. *
  688. * @return PointTransaction
  689. */
  690. public function setCart(?Cart $cart = null): self
  691. {
  692. if($this->cart === $cart) return $this;
  694. if($this->cart !== null) $this->cart->removePointTransaction($this);
  696. $this->cart = $cart;
  698. if($cart !== null && !$cart->getPointTransactions()->contains($this)) $cart->addPointTransaction($this);
  700. return $this;
  701. }
  704. public function getSubtype(): ?string
  705. {
  706. return $this->subtype;
  707. }
  710. public function setSubtype(?string $subtype): self
  711. {
  712. $this->subtype = $subtype;
  714. return $this;
  715. }
  717. /**
  718. * @return Collection<int, Invoice>
  719. */
  720. public function getInvoices(): Collection
  721. {
  722. return $this->invoices;
  723. }
  725. public function addInvoice(Invoice $invoice): self
  726. {
  727. if (!$this->invoices->contains($invoice)) {
  728. $this->invoices[] = $invoice;
  729. $invoice->addPointTransaction($this);
  730. }
  732. return $this;
  733. }
  735. public function removeInvoice(Invoice $invoice): self
  736. {
  737. if ($this->invoices->removeElement($invoice)) {
  738. $invoice->removePointTransaction($this);
  739. }
  741. return $this;
  742. }
  744. public function getEventKey(): ?string
  745. {
  746. return $this->eventKey;
  747. }
  749. public function setEventKey(?string $eventKey): self
  750. {
  751. $this->eventKey = $eventKey;
  753. return $this;
  754. }
  755. }