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.         /** Solde des commandes */
  26.         private int $orderSolde = 0;
  28.         /** Solde des points de fidélités */
  29.         private int $fidelitySolde = 0;
  31.         /**
  32.          * Identifiant unique auto-incrémenté
  33.          *
  34.          * @ORM\Id
  35.          * @ORM\GeneratedValue
  36.          * @ORM\Column(type="integer")
  37.          *
  38.          * @Expose
  39.          * @Serializer\Groups({"point_transaction:id"})
  40.          */
  41.         private ?int $id = NULL;
  43.         /**
  44.          * Utilisateur lié à la transaction
  45.          *
  46.          * @ORM\ManyToOne(targetEntity=User::class, inversedBy="pointTransactions")
  47.          * @ORM\JoinColumn(nullable=false)
  48.          *
  49.          * @Expose
  50.          * @Serializer\Groups({"point_transaction:user"})
  51.          */
  52.         private ?User $user = NULL;
  54.         /**
  55.          * Commande liée à la transaction
  56.          *
  57.          * @ORM\ManyToOne(targetEntity=SaleOrder::class, inversedBy="pointTransactions")
  58.          */
  59.         private ?SaleOrder $saleOrder = NULL;
  61.         /**
  62.          * Valeur de la transaction
  63.          *
  64.          * @ORM\Column(type="float")
  65.          *
  66.          * @Expose
  67.          * @Serializer\Groups({"point_transaction:value"})
  68.          */
  69.         private ?float $value = NULL;
  71.         /**
  72.          * Label de la transaction
  73.          *
  74.          * @ORM\Column(type="string", length=255)
  75.          *
  76.          * @Assert\NotBlank
  77.          *
  78.          * @Expose
  79.          * @Serializer\Groups({"point_transaction:label"})
  80.          */
  81.         private ?string $label = NULL;
  83.         /**
  84.          * Date d'expiration de la transaction
  85.          *
  86.          * @ORM\Column(type="datetime", nullable=true)
  87.          */
  88.         private ?DateTime $expiredAt = NULL;
  90.         /**
  91.          * Transaction liée à la transaction
  92.          *
  93.          * @ORM\ManyToOne(
  94.          *     targetEntity=PointTransaction::class,
  95.          *     inversedBy="childrenPointTransactions",
  96.          *     cascade={"persist", "remove"}
  97.          * )
  98.          */
  99.         private ?PointTransaction $linkedPointTransaction = NULL;
  101.         /**
  102.          * Liste des transactions enfants liées à la transaction
  103.          *
  104.          * @ORM\OneToMany(targetEntity=PointTransaction::class, mappedBy="linkedPointTransaction", orphanRemoval=true)
  105.          */
  106.         private ?Collection $childrenPointTransactions;
  108.         /**
  109.          * Type de transaction
  110.          *
  111.          * @ORM\ManyToOne(targetEntity=PointTransactionType::class, inversedBy="pointTransactions")
  112.          * @ORM\JoinColumn(nullable=false)
  113.          */
  114.         private ?PointTransactionType $transactionType = NULL;
  116.         /**
  117.          * Déclaration d'achat liée à la transaction
  118.          *
  119.          * @ORM\ManyToOne(targetEntity=Purchase::class, inversedBy="pointTransactions")
  120.          */
  121.         private ?Purchase $purchase = NULL;
  123.         /**
  124.          * Historique d'import lié à la transaction
  125.          *
  126.          * @ORM\ManyToOne(
  127.          *     targetEntity=PointTransactionImportHistory::class,
  128.          *     inversedBy="pointTransactions",
  129.          *     cascade={"persist"}
  130.          * )
  131.          */
  132.         private ?PointTransactionImportHistory $importHistory = NULL;
  134.         /**
  135.          * Date d'effet de la transaction
  136.          *
  137.          * @ORM\Column(type="datetime", nullable=true)
  138.          */
  139.         private ?DateTimeInterface $effectiveAt = NULL;
  141.         /**
  142.          * Méthode d'import de la transaction
  143.          *
  144.          * @ORM\Column(type="string", length=32, nullable=true)
  145.          */
  146.         private ?string $importMethod = NULL;
  148.         /**
  149.          * Commande de produit personnalisé liée à la transaction
  150.          *
  151.          * @ORM\ManyToOne(targetEntity=CustomProductOrder::class)
  152.          */
  153.         private ?CustomProductOrder $customProductOrder = NULL;
  155.         /**
  156.          * Résultat d'activité lié à la transaction
  157.          *
  158.          * @ORM\OneToOne(
  159.          *     targetEntity=UserBusinessResult::class,
  160.          *     inversedBy="pointTransaction",
  161.          *     cascade={"persist", "remove"}
  162.          * )
  163.          */
  164.         private ?UserBusinessResult $businessResult = NULL;
  166.         /**
  167.          * Catégorie de la transaction
  168.          *
  169.          * @ORM\Column(type="string", length=64, nullable=true)
  170.          */
  171.         private ?string $category = NULL;
  174.         public function __construct()
  175.         {
  176.             $this->childrenPointTransactions = new ArrayCollection();
  177.         }
  180.         public function __toString()
  181.         {
  182.             return $this->getValue() . ' - ' . $this->getLabel();
  183.         }
  186.         // MÉTHODES NÉCESSAIRES POUR LE CALCUL DE POINT : NE PAS EFFACER
  187.         public function setOrderSolde( $orderSolde ): PointTransaction
  188.         {
  189.             $this->orderSolde += $orderSolde;
  191.             return $this;
  192.         }
  195.         public function getOrderSolde(): int
  196.         {
  197.             return $this->orderSolde;
  198.         }
  201.         public function setFidelitySolde( $fidelitySolde ): PointTransaction
  202.         {
  203.             $this->fidelitySolde += $fidelitySolde;
  205.             return $this;
  206.         }
  209.         public function getFidelitySolde(): int
  210.         {
  211.             return $this->fidelitySolde;
  212.         }
  215.         // END METHODES
  217.         public function getId(): ?int
  218.         {
  219.             return $this->id;
  220.         }
  223.         public function getValue(): ?float
  224.         {
  225.             return $this->value;
  226.         }
  229.         public function setValue( float $value ): self
  230.         {
  231.             $this->value = $value;
  233.             return $this;
  234.         }
  237.         public function getLabel(): ?string
  238.         {
  239.             return $this->label;
  240.         }
  243.         public function setLabel( string $label ): self
  244.         {
  245.             $this->label = $label;
  247.             return $this;
  248.         }
  251.         public function getExpiredAt(): ?DateTimeInterface
  252.         {
  253.             return $this->expiredAt;
  254.         }
  257.         public function setExpiredAt( ?DateTimeInterface $expiredAt ): self
  258.         {
  259.             $this->expiredAt = $expiredAt;
  261.             return $this;
  262.         }
  265.         public function getEffectiveAt(): ?DateTimeInterface
  266.         {
  267.             return $this->effectiveAt;
  268.         }
  271.         public function setEffectiveAt( ?DateTimeInterface $effectiveAt ): self
  272.         {
  273.             $this->effectiveAt = $effectiveAt;
  275.             return $this;
  276.         }
  279.         public function getImportMethod(): ?string
  280.         {
  281.             return $this->importMethod;
  282.         }
  285.         public function setImportMethod( ?string $importMethod ): self
  286.         {
  287.             $this->importMethod = $importMethod;
  289.             return $this;
  290.         }
  293.         public function getCategory(): ?string
  294.         {
  295.             return $this->category;
  296.         }
  299.         public function setCategory( ?string $category ): self
  300.         {
  301.             $this->category = $category;
  303.             return $this;
  304.         }
  307.         public function getUser(): ?User
  308.         {
  309.             return $this->user;
  310.         }
  313.         public function setUser( ?User $user ): self
  314.         {
  315.             $this->user = $user;
  317.             return $this;
  318.         }
  321.         public function getSaleOrder(): ?SaleOrder
  322.         {
  323.             return $this->saleOrder;
  324.         }
  327.         public function setSaleOrder( ?SaleOrder $saleOrder ): self
  328.         {
  329.             $this->saleOrder = $saleOrder;
  331.             return $this;
  332.         }
  335.         public function getLinkedPointTransaction(): ?self
  336.         {
  337.             return $this->linkedPointTransaction;
  338.         }
  341.         public function setLinkedPointTransaction( ?self $linkedPointTransaction ): self
  342.         {
  343.             $this->linkedPointTransaction = $linkedPointTransaction;
  345.             return $this;
  346.         }
  349.         /**
  350.          * @return Collection<int, PointTransaction>
  351.          */
  352.         public function getChildrenPointTransactions(): Collection
  353.         {
  354.             return $this->childrenPointTransactions;
  355.         }
  358.         public function addChildrenPointTransaction( PointTransaction $childrenPointTransaction ): self
  359.         {
  360.             if ( !$this->childrenPointTransactions->contains( $childrenPointTransaction ) ) {
  361.                 $this->childrenPointTransactions[] = $childrenPointTransaction;
  362.                 $childrenPointTransaction->setLinkedPointTransaction( $this );
  363.             }
  365.             return $this;
  366.         }
  369.         public function removeChildrenPointTransaction( PointTransaction $childrenPointTransaction ): self
  370.         {
  371.             if ( $this->childrenPointTransactions->removeElement( $childrenPointTransaction ) ) {
  372.                 // set the owning side to null (unless already changed)
  373.                 if ( $childrenPointTransaction->getLinkedPointTransaction() === $this ) {
  374.                     $childrenPointTransaction->setLinkedPointTransaction( NULL );
  375.                 }
  376.             }
  378.             return $this;
  379.         }
  382.         public function getTransactionType(): ?PointTransactionType
  383.         {
  384.             return $this->transactionType;
  385.         }
  388.         public function setTransactionType( ?PointTransactionType $transactionType ): self
  389.         {
  390.             $this->transactionType = $transactionType;
  392.             return $this;
  393.         }
  396.         public function getPurchase(): ?Purchase
  397.         {
  398.             return $this->purchase;
  399.         }
  402.         public function setPurchase( ?Purchase $purchase ): self
  403.         {
  404.             $this->purchase = $purchase;
  406.             return $this;
  407.         }
  410.         public function getImportHistory(): ?PointTransactionImportHistory
  411.         {
  412.             return $this->importHistory;
  413.         }
  416.         public function setImportHistory( ?PointTransactionImportHistory $importHistory ): self
  417.         {
  418.             $this->importHistory = $importHistory;
  420.             return $this;
  421.         }
  424.         public function getCustomProductOrder(): ?CustomProductOrder
  425.         {
  426.             return $this->customProductOrder;
  427.         }
  430.         public function setCustomProductOrder( ?CustomProductOrder $customProductOrder ): self
  431.         {
  432.             $this->customProductOrder = $customProductOrder;
  434.             return $this;
  435.         }
  438.         public function getBusinessResult(): ?UserBusinessResult
  439.         {
  440.             return $this->businessResult;
  441.         }
  444.         public function setBusinessResult( ?UserBusinessResult $businessResult ): self
  445.         {
  446.             $this->businessResult = $businessResult;
  448.             return $this;
  449.         }
  450.     }