src/Entity/Transaction.php line 23

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Enum\TransactionStatus;
  6. use App\Entity\Traits\Identifiable;
  7. use App\Entity\Traits\Timestampable;
  8. use App\Form\Admin\Payment\TransactionCashType;
  9. use App\Form\Admin\Payment\TransactionCheckCouponType;
  10. use App\Form\Admin\Payment\TransactionCheckType;
  11. use App\Form\Admin\Payment\TransactionRefundType;
  12. use App\Form\Admin\Payment\TransactionWireType;
  13. use App\Repository\TransactionRepository;
  14. use Doctrine\Common\Collections\ArrayCollection;
  15. use Doctrine\Common\Collections\Collection;
  16. use Doctrine\ORM\Mapping as ORM;
  17. use InvalidArgumentException;
  19. #[ORM\Entity(repositoryClass: TransactionRepository::class)]
  20. #[ORM\InheritanceType('SINGLE_TABLE')]
  21. #[ORM\DiscriminatorColumn('type', 'string')]
  22. #[ORM\DiscriminatorMap(self::TYPE_CLASSES)]
  23. class Transaction implements CancellableInterface
  24. {
  25.     use Identifiable;
  26.     use Timestampable;
  28.     public const TYPE_DEFAULT                = 'default';
  29.     public const TYPE_CARD                   = 'card';
  30.     public const TYPE_CARD_SINGLE            = 'card_single';
  31.     public const TYPE_CARD_MULTI             = 'card_multi';
  32.     public const TYPE_CHECK                  = 'check';
  33.     public const TYPE_CHECK_COUPON           = 'check_coupon';
  34.     public const TYPE_CASH                   = 'cash';
  35.     public const TYPE_WIRE                   = 'wire';
  36.     public const TYPE_DEPOSIT_CHECK          = 'deposit_check';
  37.     public const TYPE_RENTAL_DEPOSIT_CHECK   = 'rental_deposit_check';
  38.     public const TYPE_DISCOUNT_DEPOSIT_CHECK = 'discount_deposit_check';
  39.     public const TYPE_DISCOUNT_RECEIPT       = 'discount_receipt';
  40.     public const TYPE_TERMINAL               = 'terminal';
  41.     public const TYPE_REFUND                 = 'refund';
  43.     public const TYPE_CLASSES = [
  44.         self::TYPE_DEFAULT                => Transaction::class,
  45.         self::TYPE_CARD                   => TransactionCard::class,
  46.         self::TYPE_CARD_SINGLE            => TransactionCardSingle::class,
  47.         self::TYPE_CARD_MULTI             => TransactionCardMulti::class,
  48.         self::TYPE_CHECK                  => TransactionCheck::class,
  49.         self::TYPE_CHECK_COUPON           => TransactionCheckCoupon::class,
  50.         self::TYPE_CASH                   => TransactionCash::class,
  51.         self::TYPE_WIRE                   => TransactionWire::class,
  52.         self::TYPE_DEPOSIT_CHECK          => TransactionDepositCheck::class,
  53.         self::TYPE_RENTAL_DEPOSIT_CHECK   => TransactionRentalDepositCheck::class,
  54.         self::TYPE_DISCOUNT_DEPOSIT_CHECK => TransactionDiscountDepositCheck::class,
  55.         self::TYPE_DISCOUNT_RECEIPT       => TransactionDiscountReceipt::class,
  56.         self::TYPE_TERMINAL               => TransactionTerminal::class,
  57.         self::TYPE_REFUND                 => TransactionRefund::class,
  58.     ];
  60.     public const TYPE_NAMES = [
  61.         self::TYPE_DEFAULT                => 'Paiement',
  62.         self::TYPE_CARD_SINGLE            => 'Par carte',
  63.         self::TYPE_CARD_MULTI             => 'Par carte en 3x',
  64.         self::TYPE_CHECK                  => 'Par chèques',
  65.         self::TYPE_CHECK_COUPON           => 'Par chèques vacances ou coupons sport ANCV',
  66.         self::TYPE_CASH                   => 'En espèces',
  67.         self::TYPE_WIRE                   => 'Par virement',
  68.         self::TYPE_DEPOSIT_CHECK          => 'Chèque de caution',
  69.         self::TYPE_RENTAL_DEPOSIT_CHECK   => 'Chèque de caution (location)',
  70.         self::TYPE_DISCOUNT_DEPOSIT_CHECK => 'Chèque de caution (aides à la pratique du sport)',
  71.         self::TYPE_DISCOUNT_RECEIPT       => 'Justificatif (aides à la pratique du sport)',
  72.         self::TYPE_TERMINAL               => 'TPE',
  73.         self::TYPE_REFUND                 => 'Remboursement',
  74.     ];
  76.     public const PUBLIC_TYPES = [
  77.         self::TYPE_CARD_SINGLE,
  78.         self::TYPE_CARD_MULTI,
  79.         self::TYPE_CHECK,
  80.         self::TYPE_CHECK_COUPON,
  81.         self::TYPE_CASH,
  82.         self::TYPE_WIRE,
  83.     ];
  85.     public const MANUAL_TYPES = [
  86.         self::TYPE_CASH,
  87.         self::TYPE_TERMINAL,
  88.         self::TYPE_WIRE,
  89.         self::TYPE_CHECK,
  90.         self::TYPE_CHECK_COUPON,
  91.         self::TYPE_DEPOSIT_CHECK,
  92.         self::TYPE_RENTAL_DEPOSIT_CHECK,
  93.         self::TYPE_DISCOUNT_DEPOSIT_CHECK,
  94.         self::TYPE_REFUND,
  95.     ];
  97.     public const FORM_CLASSES = [
  98.         self::TYPE_CHECK                  => TransactionCheckType::class,
  99.         self::TYPE_CHECK_COUPON           => TransactionCheckCouponType::class,
  100.         self::TYPE_CASH                   => TransactionCashType::class,
  101.         self::TYPE_TERMINAL               => TransactionCashType::class,
  102.         self::TYPE_WIRE                   => TransactionWireType::class,
  103.         self::TYPE_DEPOSIT_CHECK          => TransactionCheckType::class,
  104.         self::TYPE_RENTAL_DEPOSIT_CHECK   => TransactionCheckType::class,
  105.         self::TYPE_DISCOUNT_DEPOSIT_CHECK => TransactionCheckType::class,
  106.         self::TYPE_REFUND                 => TransactionRefundType::class,
  107.     ];
  109.     #[ORM\Column(type: 'float')]
  110.     private $amount;
  112.     #[ORM\Column(type: 'float')]
  113.     private $amountPayed = 0;
  115.     #[ORM\Column(type: 'string', length: 20, enumType: TransactionStatus::class)]
  116.     private $status = TransactionStatus::Created;
  118.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  119.     private $comment;
  121.     #[ORM\ManyToOne(targetEntity: Order::class, inversedBy: 'transactions')]
  122.     #[ORM\JoinColumn(nullable: false)]
  123.     private $order;
  125.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'children')]
  126.     private $parent;
  128.     #[ORM\OneToMany(mappedBy: 'parent', targetEntity: self::class)]
  129.     private $children;
  131.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  132.     private $cancelReason;
  134.     public function __construct()
  135.     {
  136.         $this->children = new ArrayCollection();
  137.     }
  139.     public function getAmount(): ?float
  140.     {
  141.         return $this->amount;
  142.     }
  144.     public function setAmount(float $amount): self
  145.     {
  146.         $this->amount = $amount;
  148.         return $this;
  149.     }
  151.     public function getAmountPayed(bool $checkMultiCardWaiting = false): ?float
  152.     {
  153.         if ($checkMultiCardWaiting &&
  154.             $this instanceof TransactionCardMulti &&
  155.             $this->getStatus() === TransactionStatus::Waiting &&
  156.             $this->getCycle() > 1) {
  157.             return $this->amount;
  158.         }
  160.         return $this->amountPayed;
  161.     }
  163.     public function setAmountPayed(float $amountPayed): self
  164.     {
  165.         $this->amountPayed = $amountPayed;
  167.         return $this;
  168.     }
  170.     public function getStatus(): ?TransactionStatus
  171.     {
  172.         return $this->status;
  173.     }
  175.     public function setStatus(TransactionStatus $status): self
  176.     {
  177.         $this->status = $status;
  179.         return $this;
  180.     }
  182.     public function getComment(): ?string
  183.     {
  184.         return $this->comment;
  185.     }
  187.     public function setComment(?string $comment): self
  188.     {
  189.         $this->comment = $comment;
  191.         return $this;
  192.     }
  194.     public function getOrder(): ?Order
  195.     {
  196.         return $this->order;
  197.     }
  199.     public function setOrder(?Order $order): self
  200.     {
  201.         $this->order = $order;
  203.         return $this;
  204.     }
  206.     public static function createFromType(string $type): self
  207.     {
  208.         if (!array_key_exists($type, self::TYPE_CLASSES)) {
  209.             throw new InvalidArgumentException(
  210.                 sprintf('type must be one of "%s"', implode(', ', array_keys(self::TYPE_CLASSES)))
  211.             );
  212.         }
  214.         return new (self::TYPE_CLASSES[$type]);
  215.     }
  217.     public function getType(?bool $slug = false): string
  218.     {
  219.         if ($slug) {
  220.             return array_search(get_class($this), self::TYPE_CLASSES);
  221.         }
  223.         return self::TYPE_NAMES[array_search(get_class($this), self::TYPE_CLASSES)];
  224.     }
  226.     public function getParent(): ?self
  227.     {
  228.         return $this->parent;
  229.     }
  231.     public function setParent(?self $parent): self
  232.     {
  233.         $this->parent = $parent;
  235.         return $this;
  236.     }
  238.     /**
  239.      * @return Collection<int, self>
  240.      */
  241.     public function getChildren(): Collection
  242.     {
  243.         return $this->children;
  244.     }
  246.     public function addChild(self $child): self
  247.     {
  248.         if (!$this->children->contains($child)) {
  249.             $this->children[] = $child;
  250.             $child->setParent($this);
  251.         }
  253.         return $this;
  254.     }
  256.     public function removeChild(self $child): self
  257.     {
  258.         if ($this->children->removeElement($child)) {
  259.             // set the owning side to null (unless already changed)
  260.             if ($child->getParent() === $this) {
  261.                 $child->setParent(null);
  262.             }
  263.         }
  265.         return $this;
  266.     }
  268.     public function getName(): string
  269.     {
  270.         return self::getNameByClass(static::class) ?? '';
  271.     }
  273.     public static function getNameByClass($class): ?string
  274.     {
  275.         $key = array_search($class, self::TYPE_CLASSES, true);
  276.         if ($key && (self::TYPE_NAMES[$key] ?? null)) {
  277.             return self::TYPE_NAMES[$key];
  278.         }
  280.         return null;
  281.     }
  283.     public function getCancelReason(): ?string
  284.     {
  285.         return $this->cancelReason;
  286.     }
  288.     public function setCancelReason(?string $cancelReason): self
  289.     {
  290.         $this->cancelReason = $cancelReason;
  292.         return $this;
  293.     }
  295.     public static function getPublicClasses(): array
  296.     {
  297.         $publicTypes = self::PUBLIC_TYPES;
  299.         return array_filter(self::TYPE_CLASSES, static fn($key) => in_array($key, $publicTypes), ARRAY_FILTER_USE_KEY);
  300.     }
  301. }