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';
  31. public const TRANSACTION_HIGHLIGHT = 'highlight';
  32. public const TRANSACTION_BONUS_STATUS = 'bonus_status';
  33. public const TRANSACTION_BONUS_BOOSTER = 'bonus_booster';
  34. public const TRANSACTION_RESET = 'reset';
  35. /** Solde des commandes */
  36. private int $orderSolde = 0;
  37. /** Solde des points de fidélités */
  38. private int $fidelitySolde = 0;
  39. /**
  40. * Identifiant unique auto-incrémenté
  41. *
  42. * @ORM\Id
  43. * @ORM\GeneratedValue
  44. * @ORM\Column(type="integer")
  45. *
  46. * @Expose
  47. * @Serializer\Groups({"point_transaction:id"})
  48. */
  49. 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;
  60. /**
  61. * Commande liée à la transaction
  62. *
  63. * @ORM\ManyToOne(targetEntity=SaleOrder::class, inversedBy="pointTransactions")
  64. */
  65. private ?SaleOrder $saleOrder = null;
  66. /**
  67. * Valeur de la transaction
  68. *
  69. * @ORM\Column(type="float")
  70. *
  71. * @Expose
  72. * @Serializer\Groups({"point_transaction:value"})
  73. */
  74. 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;
  86. /**
  87. * Référence du paiement par carte
  88. *
  89. * @ORM\Column(type="string", length=255, nullable=true)
  90. *
  91. * @Expose
  92. * @Serializer\Groups({"point_transaction:paymentReference"})
  93. */
  94. private ?string $paymentReference = null;
  95. /**
  96. * Future valeur de la transaction lors d'un paiement par carte
  97. * Ce montant sera attribué à la valeur réelle après le retour IPN de la banque
  98. *
  99. * @ORM\Column(type="float", nullable=true)
  100. *
  101. * @Expose
  102. * @Serializer\Groups({"point_transaction:value"})
  103. */
  104. private ?float $paymentValue = null;
  105. /**
  106. * Informations reçues lors du retour IPN de la banque
  107. *
  108. * @ORM\Column(type="json", nullable=true)
  109. *
  110. * @Expose
  111. * @Serializer\Groups({"point_transaction:paymentInformations"})
  112. */
  113. private ?array $paymentInformations = [];
  114. /**
  115. * Date d'expiration de la transaction
  116. *
  117. * @ORM\Column(type="datetime", nullable=true)
  118. */
  119. private ?DateTime $expiredAt = null;
  120. /**
  121. * Transaction liée à une autre transaction
  122. *
  123. * @ORM\ManyToOne(
  124. * targetEntity=PointTransaction::class,
  125. * inversedBy="childrenPointTransactions",
  126. * cascade={"persist", "remove"}
  127. * )
  128. */
  129. private ?PointTransaction $linkedPointTransaction = null;
  130. /**
  131. * Liste des transactions enfants liées à la transaction
  132. *
  133. * @ORM\OneToMany(targetEntity=PointTransaction::class, mappedBy="linkedPointTransaction", orphanRemoval=true)
  134. */
  135. private ?Collection $childrenPointTransactions = null;
  136. /**
  137. * Type de transaction
  138. *
  139. * @ORM\ManyToOne(targetEntity=PointTransactionType::class, inversedBy="pointTransactions")
  140. * @ORM\JoinColumn(nullable=false)
  141. */
  142. private ?PointTransactionType $transactionType = null;
  143. /**
  144. * Déclaration d'achat liée à la transaction
  145. *
  146. * @ORM\ManyToOne(targetEntity=Purchase::class, inversedBy="pointTransactions")
  147. */
  148. private ?Purchase $purchase = null;
  149. /**
  150. * Historique d'import lié à la transaction
  151. *
  152. * @ORM\ManyToOne(
  153. * targetEntity=PointTransactionImportHistory::class,
  154. * inversedBy="pointTransactions",
  155. * cascade={"persist"}
  156. * )
  157. */
  158. private ?PointTransactionImportHistory $importHistory = null;
  159. /**
  160. * Date d'effet de la transaction
  161. *
  162. * @ORM\Column(type="datetime", nullable=true)
  163. */
  164. private ?DateTimeInterface $effectiveAt = null;
  165. /**
  166. * Méthode d'import de la transaction
  167. *
  168. * @ORM\Column(type="string", length=32, nullable=true)
  169. */
  170. private ?string $importMethod = null;
  171. /**
  172. * Commande de produit personnalisé liée à la transaction
  173. *
  174. * @ORM\ManyToOne(targetEntity=CustomProductOrder::class)
  175. */
  176. private ?CustomProductOrder $customProductOrder = null;
  177. /**
  178. * Résultat d'activité lié à la transaction
  179. *
  180. * @ORM\OneToOne(
  181. * targetEntity=UserBusinessResult::class,
  182. * inversedBy="pointTransaction",
  183. * cascade={"persist", "remove"}
  184. * )
  185. */
  186. private ?UserBusinessResult $businessResult = null;
  187. /**
  188. * Catégorie de la transaction
  189. *
  190. * @ORM\Column(type="string", length=64, nullable=true)
  191. */
  192. private ?string $category = null;
  193. /**
  194. * On lie un SaleOrderItem a une transaction seulement à l'annulation, pour pouvoir lier un remboursement a un produit
  195. *
  196. * @ORM\ManyToOne(targetEntity=SaleOrderItem::class, inversedBy="pointTransactions", cascade={"persist"})
  197. */
  198. private ?SaleOrderItem $saleOrderItem = null;
  199. /**
  200. * Panier lié à la transaction quand elle est validée (retour de l'utilisateur depuis l'interface de la banque)
  201. * même si elle n'est pas encore confirmée par la banque (retour automatique IPN)
  202. * quand elle est confirmée, on lui attribue le montant correspondant, sinon il reste à 0
  203. *
  204. * @ORM\ManyToOne(targetEntity=Cart::class,inversedBy="paidPointTransactions")
  205. * @ORM\JoinColumn(nullable=true, onDelete="SET NULL")
  206. */
  207. private ?Cart $paidCart = null;
  208. /**
  209. * Panier lié à la transaction, dans le cadre d'un paiement par carte avant que la transaction ne soit validée
  210. *
  211. * @ORM\ManyToOne(targetEntity=Cart::class,inversedBy="pointTransactions")
  212. * @ORM\JoinColumn(nullable=true, onDelete="SET NULL")
  213. */
  214. private ?Cart $cart = null;
  215. /**
  216. * @ORM\ManyToMany(targetEntity=Invoice::class, mappedBy="transactionPoints")
  217. */
  218. private Collection $invoices;
  219. /**
  220. * Type de frais de la transaction
  221. *
  222. * @ORM\Column(type="string", length=64, nullable=true)
  223. */
  224. private ?string $subtype = null;
  225. /**
  226. * @ORM\Column(type="string", length=255, nullable=true)
  227. */
  228. private $eventKey;
  230. public function __construct()
  231. {
  232. $this->childrenPointTransactions = new ArrayCollection();
  233. $this->invoices = new ArrayCollection();
  234. }
  236. public function __toString()
  237. {
  238. return $this->getValue() . ' - ' . $this->getLabel();
  239. }
  241. // MÉTHODES NÉCESSAIRES POUR LE CALCUL DE POINT : NE PAS EFFACER
  242. public function setOrderSolde($orderSolde): PointTransaction
  243. {
  244. $this->orderSolde += $orderSolde;
  246. return $this;
  247. }
  249. public function getOrderSolde(): int
  250. {
  251. return $this->orderSolde;
  252. }
  254. public function setFidelitySolde($fidelitySolde): PointTransaction
  255. {
  256. $this->fidelitySolde += $fidelitySolde;
  258. return $this;
  259. }
  261. public function getFidelitySolde(): int
  262. {
  263. return $this->fidelitySolde;
  264. }
  266. // END METHODES
  268. public function getId(): ?int
  269. {
  270. return $this->id;
  271. }
  273. public function getValue(): ?float
  274. {
  275. return $this->value;
  276. }
  278. public function setValue(float $value): self
  279. {
  280. $this->value = $value;
  282. return $this;
  283. }
  285. public function getLabel(): ?string
  286. {
  287. $label = $this->label;
  289. if ($this->getTransactionType(true) === PointTransactionType::PAYMENT) {
  290. $label .= ' (' . $this->getPaymentReference() . ')';
  291. }
  293. return $label;
  294. }
  296. public function setLabel(string $label): self
  297. {
  298. $this->label = $label;
  300. return $this;
  301. }
  303. public function getExpiredAt(): ?DateTimeInterface
  304. {
  305. return $this->expiredAt;
  306. }
  308. public function setExpiredAt(?DateTime $expiredAt): self
  309. {
  310. $this->expiredAt = $expiredAt;
  312. return $this;
  313. }
  315. public function getEffectiveAt(): ?DateTimeInterface
  316. {
  317. return $this->effectiveAt;
  318. }
  320. public function setEffectiveAt(?DateTimeInterface $effectiveAt): self
  321. {
  322. $this->effectiveAt = $effectiveAt;
  324. return $this;
  325. }
  327. public function getImportMethod(): ?string
  328. {
  329. return $this->importMethod;
  330. }
  332. public function setImportMethod(?string $importMethod): self
  333. {
  334. $this->importMethod = $importMethod;
  336. return $this;
  337. }
  339. public function getCategory(): ?string
  340. {
  341. return $this->category;
  342. }
  344. public function setCategory(?string $category): self
  345. {
  346. $this->category = $category;
  348. return $this;
  349. }
  351. public function getUser(): ?User
  352. {
  353. return $this->user;
  354. }
  356. public function setUser(?User $user): self
  357. {
  358. $this->user = $user;
  360. return $this;
  361. }
  363. public function getSaleOrder(): ?SaleOrder
  364. {
  365. return $this->saleOrder;
  366. }
  368. public function setSaleOrder(?SaleOrder $saleOrder): self
  369. {
  370. if ($this->saleOrder === $saleOrder) {
  371. return $this;
  372. }
  374. if ($this->saleOrder !== null) {
  375. $this->saleOrder->removePointTransaction($this);
  376. }
  378. $this->saleOrder = $saleOrder;
  380. if ($saleOrder !== null && !$saleOrder->getPointTransactions()
  381. ->contains($this)) {
  382. $saleOrder->addPointTransaction($this);
  383. }
  385. return $this;
  386. }
  388. public function getLinkedPointTransaction(): ?self
  389. {
  390. return $this->linkedPointTransaction;
  391. }
  393. public function setLinkedPointTransaction(?self $linkedPointTransaction): self
  394. {
  395. $this->linkedPointTransaction = $linkedPointTransaction;
  397. return $this;
  398. }
  400. /**
  401. * @return Collection<int, PointTransaction>
  402. */
  403. public function getChildrenPointTransactions(): Collection
  404. {
  405. return $this->childrenPointTransactions;
  406. }
  408. public function addChildrenPointTransaction(PointTransaction $childrenPointTransaction): self
  409. {
  410. if (!$this->childrenPointTransactions->contains($childrenPointTransaction)) {
  411. $this->childrenPointTransactions[] = $childrenPointTransaction;
  412. $childrenPointTransaction->setLinkedPointTransaction($this);
  413. }
  415. return $this;
  416. }
  418. public function removeChildrenPointTransaction(PointTransaction $childrenPointTransaction): self
  419. {
  420. if ($this->childrenPointTransactions->removeElement($childrenPointTransaction)) {
  421. // set the owning side to null (unless already changed)
  422. if ($childrenPointTransaction->getLinkedPointTransaction() === $this) {
  423. $childrenPointTransaction->setLinkedPointTransaction(null);
  424. }
  425. }
  427. return $this;
  428. }
  430. /**
  431. * @param bool $getSlug
  432. * @return PointTransactionType|null|string
  433. */
  434. public function getTransactionType(bool $getSlug = false)
  435. {
  436. if (!$getSlug || !$this->transactionType) {
  437. return $this->transactionType;
  438. }
  440. return $this->transactionType->getSlug();
  441. }
  443. public function setTransactionType(?PointTransactionType $transactionType): self
  444. {
  445. $this->transactionType = $transactionType;
  447. return $this;
  448. }
  450. public function getPurchase(): ?Purchase
  451. {
  452. return $this->purchase;
  453. }
  455. public function setPurchase(?Purchase $purchase): self
  456. {
  457. $this->purchase = $purchase;
  459. return $this;
  460. }
  462. public function getImportHistory(): ?PointTransactionImportHistory
  463. {
  464. return $this->importHistory;
  465. }
  467. public function setImportHistory(?PointTransactionImportHistory $importHistory): self
  468. {
  469. $this->importHistory = $importHistory;
  471. return $this;
  472. }
  474. public function getCustomProductOrder(): ?CustomProductOrder
  475. {
  476. return $this->customProductOrder;
  477. }
  479. public function setCustomProductOrder(?CustomProductOrder $customProductOrder): self
  480. {
  481. $this->customProductOrder = $customProductOrder;
  483. return $this;
  484. }
  486. public function getBusinessResult(): ?UserBusinessResult
  487. {
  488. return $this->businessResult;
  489. }
  491. public function setBusinessResult(?UserBusinessResult $businessResult): self
  492. {
  493. $this->businessResult = $businessResult;
  495. return $this;
  496. }
  498. public function getSaleOrderItem(): ?SaleOrderItem
  499. {
  500. return $this->saleOrderItem;
  501. }
  503. public function setSaleOrderItem(?SaleOrderItem $saleOrderItem): self
  504. {
  505. if ($this->saleOrderItem === $saleOrderItem) {
  506. return $this;
  507. }
  509. if ($this->saleOrderItem !== null) {
  510. $this->saleOrderItem->removePointTransaction($this);
  511. }
  513. $this->saleOrderItem = $saleOrderItem;
  515. if ($saleOrderItem !== null && !$saleOrderItem->getPointTransactions()->contains($this)) {
  516. $saleOrderItem->addPointTransaction($this);
  517. }
  519. return $this;
  520. }
  522. /**
  523. * @return string|null
  524. */
  525. public function getPaymentReference(): ?string
  526. {
  527. return $this->paymentReference;
  528. }
  530. /**
  531. * @param string|null $paymentReference
  532. *
  533. * @return PointTransaction
  534. */
  535. public function setPaymentReference(?string $paymentReference): PointTransaction
  536. {
  537. $this->paymentReference = $paymentReference;
  538. return $this;
  539. }
  541. /**
  542. * @return array
  543. */
  544. public function getPaymentInformations(): array
  545. {
  546. if ($this->paymentInformations === null) {
  547. $this->paymentInformations = [];
  548. }
  549. return $this->paymentInformations;
  550. }
  552. /**
  553. * @param array|null $paymentInformations
  554. *
  555. * @return PointTransaction
  556. */
  557. public function setPaymentInformations(?array $paymentInformations = []): PointTransaction
  558. {
  559. if ($paymentInformations === null) {
  560. $paymentInformations = [];
  561. }
  563. $this->paymentInformations = $paymentInformations;
  564. return $this;
  565. }
  567. /**
  568. * @param string $key
  569. * @param $value
  570. *
  571. * @return $this
  572. */
  573. public function addPaymentInformation(string $key, $value): PointTransaction
  574. {
  575. $this->paymentInformations[$key] = $value;
  576. return $this;
  577. }
  579. /**
  580. * @param string $key
  581. *
  582. * @return $this
  583. */
  584. public function removePaymentInformation(string $key): PointTransaction
  585. {
  586. unset($this->paymentInformations[$key]);
  587. return $this;
  588. }
  590. /**
  591. * @return float|null
  592. */
  593. public function getPaymentValue(): ?float
  594. {
  595. return $this->paymentValue;
  596. }
  598. /**
  599. * @param float|null $paymentValue
  600. *
  601. * @return PointTransaction
  602. */
  603. public function setPaymentValue(?float $paymentValue): PointTransaction
  604. {
  605. $this->paymentValue = $paymentValue;
  606. return $this;
  607. }
  609. /**
  610. * @return Cart|null
  611. */
  612. public function getPaidCart(): ?Cart
  613. {
  614. return $this->paidCart;
  615. }
  617. /**
  618. * @param Cart|null $paidCart
  619. *
  620. * @return PointTransaction
  621. */
  622. public function setPaidCart(?Cart $paidCart = null): self
  623. {
  624. if ($this->paidCart === $paidCart) {
  625. return $this;
  626. }
  628. if ($this->paidCart !== null) {
  629. $this->paidCart->removePaidPointTransaction($this);
  630. }
  632. $this->paidCart = $paidCart;
  634. if ($paidCart !== null && !$paidCart->getPaidPointTransactions()
  635. ->contains($this)) {
  636. $paidCart->addPaidPointTransaction($this);
  637. }
  639. return $this;
  640. }
  642. /**
  643. * @return Cart|null
  644. */
  645. public function getCart(): ?Cart
  646. {
  647. return $this->cart;
  648. }
  650. /**
  651. * @param Cart|null $cart
  652. *
  653. * @return PointTransaction
  654. */
  655. public function setCart(?Cart $cart = null): self
  656. {
  657. if ($this->cart === $cart) {
  658. return $this;
  659. }
  661. if ($this->cart !== null) {
  662. $this->cart->removePointTransaction($this);
  663. }
  665. $this->cart = $cart;
  667. if ($cart !== null && !$cart->getPointTransactions()->contains($this)) {
  668. $cart->addPointTransaction($this);
  669. }
  671. return $this;
  672. }
  674. public function getSubtype(): ?string
  675. {
  676. return $this->subtype;
  677. }
  679. public function setSubtype(?string $subtype): self
  680. {
  681. $this->subtype = $subtype;
  683. return $this;
  684. }
  686. /**
  687. * @return Collection<int, Invoice>
  688. */
  689. public function getInvoices(): Collection
  690. {
  691. return $this->invoices;
  692. }
  694. public function addInvoice(Invoice $invoice): self
  695. {
  696. if (!$this->invoices->contains($invoice)) {
  697. $this->invoices[] = $invoice;
  698. $invoice->addPointTransaction($this);
  699. }
  701. return $this;
  702. }
  704. public function removeInvoice(Invoice $invoice): self
  705. {
  706. if ($this->invoices->removeElement($invoice)) {
  707. $invoice->removePointTransaction($this);
  708. }
  710. return $this;
  711. }
  713. public function getEventKey(): ?string
  714. {
  715. return $this->eventKey;
  716. }
  718. public function setEventKey(?string $eventKey): self
  719. {
  720. $this->eventKey = $eventKey;
  722. return $this;
  723. }
  724. }