src/Entity/Commande.php line 12

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\CommandeRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  11. #[ORM\Entity(repositoryClass: CommandeRepository::class)]
  12. class Commande
  13. {
  14.     const COMMANDE_STATUS_NOT_DEFINED = 'non défini';
  15.     const COMMANDE_STATUS_SAISIE = 'saisie';
  16.     const COMMANDE_STATUS_DESACTIVER = 'desactiver';
  17.     const COMMANDE_STATUS_ATTRIBUER = 'attribuer';
  18.     const COMMANDE_STATUS_EDITER = 'editer';
  19.     const COMMANDE_STATUS_LIVRER = 'livrer';
  21.     #[ORM\Id]
  22.     #[ORM\GeneratedValue]
  23.     #[ORM\Column]
  24.     private ?int $id = null;
  26.     #[ORM\ManyToOne]
  27.     private ?Events $event = null;
  29.     #[ORM\ManyToOne]
  30.     #[ORM\JoinColumn(nullable: false)]
  31.     private ?Session $session = null;
  33.     #[ORM\ManyToOne]
  34.     private ?Cour $cour = null;
  36.     #[ORM\ManyToOne]
  37.     private ?Category $category = null;
  39.     #[ORM\Column(nullable: true)]
  40.     private ?int $nbr = null;
  42.     #[ORM\Column(length: 255, nullable: true)]
  43.     private ?string $groupement = null;
  45.     #[ORM\Column(length: 255, nullable: true)]
  46.     private ?string $statut = null;
  48.     #[ORM\Column(nullable: true)]
  49.     private ?float $prix_unitaire = null;
  51.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  52.     private ?string $note = null;
  54.     #[ORM\Column(nullable: true)]
  55.     private ?bool $option_commande = null;
  57.     #[ORM\ManyToOne(cascade: ['persist'], inversedBy: 'commandes')]
  58.     #[ORM\JoinColumn(nullable: false)]
  59.     private ?Client $client = null;
  61.     #[ORM\OneToMany(mappedBy: 'commande', targetEntity: Attribution::class, orphanRemoval: true)]
  62.     private $attributions;
  64.     #[ORM\OneToMany(mappedBy: 'commande', targetEntity: Spectateur::class, orphanRemoval: true)]
  65.     private Collection $spectateurs;
  67.     #[ORM\OneToMany(mappedBy: 'commande', targetEntity: CommandeActions::class, orphanRemoval: true)]
  68.     private Collection $commandeActions;
  70.     #[ORM\Column(nullable: true)]
  71.     private ?bool $isPapier = null;
  73.     #[ORM\Column(length: 255, nullable: true)]
  74.     private ?string $contactEmail = null;
  76.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  77.     private ?string $noteCommande = null;
  79.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  80.     private ?string $noteClient = null;
  82.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  83.     private ?string $noteSpectateur = null;
  85.     public function __construct()
  86.     {
  87.         $this->statut = self::COMMANDE_STATUS_SAISIE;
  88.         $this->attributions = new ArrayCollection();
  89.         $this->spectateurs = new ArrayCollection();
  90.         $this->commandeActions = new ArrayCollection();
  91.     }
  93.     public function getId(): ?int
  94.     {
  95.         return $this->id;
  96.     }
  98.     public function getEvent(): ?Events
  99.     {
  100.         return $this->event;
  101.     }
  103.     public function setEvent(?Events $event): self
  104.     {
  105.         $this->event = $event;
  107.         return $this;
  108.     }
  110.     public function getSession(): ?Session
  111.     {
  112.         return $this->session;
  113.     }
  115.     public function setSession(?Session $session): self
  116.     {
  117.         $this->session = $session;
  119.         return $this;
  120.     }
  122.     public function getCour(): ?Cour
  123.     {
  124.         return $this->cour;
  125.     }
  127.     public function setCour(?Cour $cour): self
  128.     {
  129.         $this->cour = $cour;
  131.         return $this;
  132.     }
  134.     public function getCategory(): ?Category
  135.     {
  136.         return $this->category;
  137.     }
  139.     public function setCategory(?Category $category): self
  140.     {
  141.         $this->category = $category;
  143.         return $this;
  144.     }
  146.     public function getNbr(): ?int
  147.     {
  148.         return $this->nbr;
  149.     }
  151.     public function setNbr(?int $nbr): self
  152.     {
  153.         $this->nbr = $nbr;
  155.         return $this;
  156.     }
  158.     public function getGroupement(): ?string
  159.     {
  160.         return $this->groupement;
  161.     }
  163.     public function setGroupement(?string $groupement): self
  164.     {
  165.         $this->groupement = $groupement;
  167.         return $this;
  168.     }
  170.     public function getStatut(): ?string
  171.     {
  172.         return $this->statut;
  173.     }
  175.     public function setStatut(?string $statut): self
  176.     {
  177.         $this->statut = $statut;
  179.         return $this;
  180.     }
  182.     public function getPrixUnitaire(): ?float
  183.     {
  184.         return $this->prix_unitaire;
  185.     }
  187.     public function setPrixUnitaire(?float $prix_unitaire): self
  188.     {
  189.         $this->prix_unitaire = $prix_unitaire;
  191.         return $this;
  192.     }
  194.     public function getNote(): ?string
  195.     {
  196.         return $this->note;
  197.     }
  199.     public function setNote(?string $note): self
  200.     {
  201.         $this->note = $note;
  203.         return $this;
  204.     }
  206.     public function isOptionCommande(): ?bool
  207.     {
  208.         return $this->option_commande;
  209.     }
  211.     public function setOptionCommande(?bool $option_commande): self
  212.     {
  213.         $this->option_commande = $option_commande;
  215.         return $this;
  216.     }
  218.     public function getClient(): ?Client
  219.     {
  220.         return $this->client;
  221.     }
  223.     public function setClient(?Client $client): self
  224.     {
  225.         $this->client = $client;
  227.         return $this;
  228.     }
  230.     public function getTotal(): float
  231.     {
  232.         return $this->prix_unitaire * $this->nbr;
  233.     }
  235.     public function __toString(): string
  236.     {
  237.         // TODO: Implement __toString() method.
  238.         return $this->getSession()->getCodeSession();
  239.     }
  241.     /**
  242.      * @return Collection|Attribution[]
  243.      */
  244.     public function getAttributions(): Collection
  245.     {
  246.         return $this->attributions;
  247.     }
  249.     public function addAttribution(Attribution $attribution): self
  250.     {
  251.         if (!$this->attributions->contains($attribution)) {
  252.             $this->attributions[] = $attribution;
  253.             $attribution->setCommande($this);
  254.         }
  256.         return $this;
  257.     }
  259.     public function removeAttribution(Attribution $attribution): self
  260.     {
  261.         if ($this->attributions->contains($attribution)) {
  262.             $this->attributions->removeElement($attribution);
  263.             // set the owning side to null (unless already changed)
  264.             if ($attribution->getCommande() === $this) {
  265.                 $attribution->setCommande(null);
  266.             }
  267.         }
  269.         return $this;
  270.     }
  272.     /**
  273.      * @return Collection<int, Spectateur>
  274.      */
  275.     public function getSpectateurs(): Collection
  276.     {
  277.         return $this->spectateurs;
  278.     }
  280.     public function addSpectateur(Spectateur $spectateur): self
  281.     {
  282.         if (!$this->spectateurs->contains($spectateur)) {
  283.             $this->spectateurs->add($spectateur);
  284.             $spectateur->setCommande($this);
  285.         }
  287.         return $this;
  288.     }
  290.     public function removeSpectateur(Spectateur $spectateur): self
  291.     {
  292.         if ($this->spectateurs->removeElement($spectateur)) {
  293.             // set the owning side to null (unless already changed)
  294.             if ($spectateur->getCommande() === $this) {
  295.                 $spectateur->setCommande(null);
  296.             }
  297.         }
  299.         return $this;
  300.     }
  302.     /**
  303.      * @return Collection<int, CommandeActions>
  304.      */
  305.     public function getCommandeActions(): array
  306.     {
  307.         return array_reverse($this->commandeActions->toArray());
  308.     }
  310.     public function addCommandeAction(CommandeActions $commandeAction): self
  311.     {
  312.         if (!$this->commandeActions->contains($commandeAction)) {
  313.             $this->commandeActions->add($commandeAction);
  314.             $commandeAction->setCommande($this);
  315.         }
  317.         return $this;
  318.     }
  320.     public function removeCommandeAction(CommandeActions $commandeAction): self
  321.     {
  322.         if ($this->commandeActions->removeElement($commandeAction)) {
  323.             // set the owning side to null (unless already changed)
  324.             if ($commandeAction->getCommande() === $this) {
  325.                 $commandeAction->setCommande(null);
  326.             }
  327.         }
  329.         return $this;
  330.     }
  332.     public function isIsPapier(): ?bool
  333.     {
  334.         return $this->isPapier;
  335.     }
  337.     public function setIsPapier(?bool $isPapier): self
  338.     {
  339.         $this->isPapier = $isPapier;
  341.         return $this;
  342.     }
  344.     public function getContactEmail(): ?string
  345.     {
  346.         return $this->contactEmail;
  347.     }
  349.     public function setContactEmail(?string $contactEmail): self
  350.     {
  351.         $this->contactEmail = $contactEmail;
  353.         return $this;
  354.     }
  356.     public function getNoteCommande(): ?string
  357.     {
  358.         return $this->noteCommande;
  359.     }
  361.     public function setNoteCommande(?string $noteCommande): self
  362.     {
  363.         $this->noteCommande = $noteCommande;
  365.         return $this;
  366.     }
  368.     public function getNoteClient(): ?string
  369.     {
  370.         return $this->noteClient;
  371.     }
  373.     public function setNoteClient(?string $noteClient): self
  374.     {
  375.         $this->noteClient = $noteClient;
  377.         return $this;
  378.     }
  380.     public function getNoteSpectateur(): ?string
  381.     {
  382.         return $this->noteSpectateur;
  383.     }
  385.     public function setNoteSpectateur(?string $noteSpectateur): self
  386.     {
  387.         $this->noteSpectateur = $noteSpectateur;
  389.         return $this;
  390.     }
  392.     public function getFormSpectateurs(): array
  393.     {
  394.         $spectateurs = array_values(
  395.             array_filter(
  396.                 array_map(
  397.                     function ($spectateur) {
  398.                         if ($spectateur->isIsActive())
  399.                             return [
  400.                                 'nom' => $spectateur->getNom()
  401.                             ];
  402.                         return null;
  403.                     },
  404.                     $this->getSpectateurs()->toArray()
  405.                 ),
  406.                 function ($value) {
  407.                     return $value !== null;
  408.                 }
  409.             )
  410.         );
  411.         $result = [];
  413.         for ($i = 1; $i <= $this->nbr; $i++) {
  414.             if (count($spectateurs) >= $i) $result[] = $spectateurs[($i - 1)]['nom'];
  415.             else $result[$i] = '';
  416.         }
  418.         return $result;
  419.     }
  421.     public function getHistoriqueSpectateur(): array
  422.     {
  423.         return array_values(
  424.             array_filter(
  425.                 array_map(
  426.                     function ($spectateur) {
  427.                         return [
  428.                             'id' => $spectateur->getId(),
  429.                             'nom' => $spectateur->getNom(),
  430.                             'date' => $spectateur->getLocalizedDate()
  431.                         ];
  432.                     },
  433.                     $this->getSpectateurs()->toArray()
  434.                 ),
  435.                 function ($value) {
  436.                     return $value !== null;
  437.                 }
  438.             )
  439.         );
  440.     }
  442.     public function getAllSpectateurToEmail(): ?string
  443.     {
  444.         $result = '<ul>';
  445.         /** @var Spectateur $spectateur */
  446.         foreach ($this->getAttributions() as $attribution) {
  447.             $spectateur = $attribution->getSpectateur();
  448.             $result .= '<li>' . $spectateur->getNom() . '</li>';
  449.         }
  450.         $result .= '</ul>';
  452.         return $result;
  453.     }
  455.     public function getGroupedSpectateur(): array
  456.     {
  457.         $resultat = [];
  458.         $nbrs = explode(',', $this->groupement);
  459.         $attributions = $this->getAttributions()->toArray();
  460.         $i = 0;
  461.         $limit = 0;
  462.         foreach ($nbrs as $index => $nbr) {
  463.             $limit += $nbr;
  464.             while ($i < $limit) {
  465.                 if(isset($attributions[$i])) {
  466.                     $resultat['groupe_' . $index][] = $attributions[$i];
  467.                 }
  468.                 $i++;
  469.             }
  470.         }
  471.         return $resultat;
  472.     }
  474.     public function getToAttribute(): ?Attribution
  475.     {
  476.         foreach ($this->getAttributions() as $attribution) {
  477.             if(is_null($attribution->getBillet())) return $attribution;
  478.         }
  480.         return null;
  481.     }
  483.     public function getNbNoms(): string
  484.     {
  485.         $saisie = 0;
  486.         $spectateurs = 0;
  487.         /** @var Spectateur $spectateur */
  488.         foreach ($this->getAttributions() as $attribution) {
  489.             $spectateur = $attribution->getSpectateur();
  490.             $spectateurs++;
  491.             if($spectateur->getNom() !== ' ' && $spectateur->getNom() !== '' && !is_null($spectateur->getNom())) $saisie ++;
  492.         }
  493.         return $saisie.' / '.$spectateurs;
  494.     }
  496.     public function getNbrBilletSameStatus(): int
  497.     {
  498.         $count = 0;
  499.         /** @var Attribution $attribution */
  500.         foreach ($this->attributions as $attribution) {
  501.             if($attribution->getStatut() == $this->statut) $count++;
  502.         }
  503.         return $count;
  504.     }
  506.     public function getNoms(): string
  507.     {
  508.         $spectateurs = $this->getSpectateurs();
  509.         $nb = 0;
  510.         foreach ($spectateurs as $spectateur) {
  511.             if($spectateur->getNom() != " " && $spectateur->getNom() != "") $nb++;
  512.         }
  513.         return $nb.' / '.count($spectateurs);
  514.     }
  516.     public function getStock(): string
  517.     {
  518.         $stock = 0;
  519.         foreach ($this->attributions as $attribution) {
  520.             if(is_null($attribution->getBillet())) $stock++;
  521.         }
  522.         return $stock.' / '.count($this->attributions);
  523.     }
  524. }