src/Entity/SessionCaisse.php line 12

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\SessionCaisseRepository;
  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: SessionCaisseRepository::class)]
  12. class SessionCaisse
  13. {
  14.     #[ORM\Id]
  15.     #[ORM\GeneratedValue]
  16.     #[ORM\Column]
  17.     private ?int $id = null;
  19.     #[ORM\ManyToOne(inversedBy: 'sessions')]
  20.     #[ORM\JoinColumn(nullable: false)]
  21.     private ?Caisse $caisse = null;
  23.     #[ORM\ManyToOne(targetEntity: User::class)]
  24.     #[ORM\JoinColumn(nullable: false)]
  25.     private ?User $utilisateur = null;
  27.     #[ORM\Column(type: Types::DATETIME_MUTABLE)]
  28.     private ?\DateTimeInterface $dateOuverture = null;
  30.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  31.     private ?\DateTimeInterface $dateFermeture = null;
  33.     #[ORM\Column(type: Types::DECIMAL, precision: 15, scale: 2)]
  34.     private ?string $fondsOuverture = '0.00';
  36.     #[ORM\Column(type: Types::DECIMAL, precision: 15, scale: 2, nullable: true)]
  37.     private ?string $fondsFermeture = null;
  39.     #[ORM\Column(type: Types::DECIMAL, precision: 15, scale: 2, nullable: true)]
  40.     private ?string $fondsTheoriqueFermeture = null;
  42.     #[ORM\Column(type: Types::DECIMAL, precision: 15, scale: 2, nullable: true)]
  43.     private ?string $ecart = null;
  45.     #[ORM\Column(length: 50)]
  46.     private ?string $statut = 'ouverte'; // ouverte, fermee, validee
  48.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  49.     private ?string $noteOuverture = null;
  51.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  52.     private ?string $noteFermeture = null;
  54.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  55.     private ?string $justificationEcart = null;
  57.     #[ORM\OneToMany(mappedBy: 'session', targetEntity: MouvementCaisse::class)]
  58.     private Collection $mouvements;
  60.     #[ORM\Column]
  61.     private ?\DateTimeImmutable $createdAt = null;
  63.     #[ORM\ManyToOne(targetEntity: User::class)]
  64.     private ?User $fermePar = null;
  66.     #[ORM\ManyToOne(targetEntity: User::class)]
  67.     private ?User $validePar = null;
  69.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  70.     private ?\DateTimeInterface $dateValidation = null;
  72.     public function __construct()
  73.     {
  74.         $this->mouvements = new ArrayCollection();
  75.         $this->createdAt = new \DateTimeImmutable();
  76.         $this->dateOuverture = new \DateTime();
  77.     }
  79.     public function getId(): ?int
  80.     {
  81.         return $this->id;
  82.     }
  84.     public function getCaisse(): ?Caisse
  85.     {
  86.         return $this->caisse;
  87.     }
  89.     public function setCaisse(?Caisse $caisse): static
  90.     {
  91.         $this->caisse = $caisse;
  92.         return $this;
  93.     }
  95.     public function getUtilisateur(): ?User
  96.     {
  97.         return $this->utilisateur;
  98.     }
  100.     public function setUtilisateur(?User $utilisateur): static
  101.     {
  102.         $this->utilisateur = $utilisateur;
  103.         return $this;
  104.     }
  106.     public function getDateOuverture(): ?\DateTimeInterface
  107.     {
  108.         return $this->dateOuverture;
  109.     }
  111.     public function setDateOuverture(\DateTimeInterface $dateOuverture): static
  112.     {
  113.         $this->dateOuverture = $dateOuverture;
  114.         return $this;
  115.     }
  117.     public function getDateFermeture(): ?\DateTimeInterface
  118.     {
  119.         return $this->dateFermeture;
  120.     }
  122.     public function setDateFermeture(?\DateTimeInterface $dateFermeture): static
  123.     {
  124.         $this->dateFermeture = $dateFermeture;
  125.         return $this;
  126.     }
  128.     public function getFondsOuverture(): ?string
  129.     {
  130.         return $this->fondsOuverture;
  131.     }
  133.     public function setFondsOuverture(string $fondsOuverture): static
  134.     {
  135.         $this->fondsOuverture = $fondsOuverture;
  136.         return $this;
  137.     }
  139.     public function getFondsFermeture(): ?string
  140.     {
  141.         return $this->fondsFermeture;
  142.     }
  144.     public function setFondsFermeture(?string $fondsFermeture): static
  145.     {
  146.         $this->fondsFermeture = $fondsFermeture;
  147.         return $this;
  148.     }
  150.     public function getFondsTheoriqueFermeture(): ?string
  151.     {
  152.         return $this->fondsTheoriqueFermeture;
  153.     }
  155.     public function setFondsTheoriqueFermeture(?string $fondsTheoriqueFermeture): static
  156.     {
  157.         $this->fondsTheoriqueFermeture = $fondsTheoriqueFermeture;
  158.         return $this;
  159.     }
  161.     public function getEcart(): ?string
  162.     {
  163.         return $this->ecart;
  164.     }
  166.     public function setEcart(?string $ecart): static
  167.     {
  168.         $this->ecart = $ecart;
  169.         return $this;
  170.     }
  172.     public function getStatut(): ?string
  173.     {
  174.         return $this->statut;
  175.     }
  177.     public function setStatut(string $statut): static
  178.     {
  179.         $this->statut = $statut;
  180.         return $this;
  181.     }
  183.     public function getNoteOuverture(): ?string
  184.     {
  185.         return $this->noteOuverture;
  186.     }
  188.     public function setNoteOuverture(?string $noteOuverture): static
  189.     {
  190.         $this->noteOuverture = $noteOuverture;
  191.         return $this;
  192.     }
  194.     public function getNoteFermeture(): ?string
  195.     {
  196.         return $this->noteFermeture;
  197.     }
  199.     public function setNoteFermeture(?string $noteFermeture): static
  200.     {
  201.         $this->noteFermeture = $noteFermeture;
  202.         return $this;
  203.     }
  205.     public function getJustificationEcart(): ?string
  206.     {
  207.         return $this->justificationEcart;
  208.     }
  210.     public function setJustificationEcart(?string $justificationEcart): static
  211.     {
  212.         $this->justificationEcart = $justificationEcart;
  213.         return $this;
  214.     }
  216.     /**
  217.      * @return Collection<int, MouvementCaisse>
  218.      */
  219.     public function getMouvements(): Collection
  220.     {
  221.         return $this->mouvements;
  222.     }
  224.     public function addMouvement(MouvementCaisse $mouvement): static
  225.     {
  226.         if (!$this->mouvements->contains($mouvement)) {
  227.             $this->mouvements->add($mouvement);
  228.             $mouvement->setSession($this);
  229.         }
  230.         return $this;
  231.     }
  233.     public function removeMouvement(MouvementCaisse $mouvement): static
  234.     {
  235.         if ($this->mouvements->removeElement($mouvement)) {
  236.             if ($mouvement->getSession() === $this) {
  237.                 $mouvement->setSession(null);
  238.             }
  239.         }
  240.         return $this;
  241.     }
  243.     public function getCreatedAt(): ?\DateTimeImmutable
  244.     {
  245.         return $this->createdAt;
  246.     }
  248.     public function setCreatedAt(\DateTimeImmutable $createdAt): static
  249.     {
  250.         $this->createdAt = $createdAt;
  251.         return $this;
  252.     }
  254.     public function getFermePar(): ?User
  255.     {
  256.         return $this->fermePar;
  257.     }
  259.     public function setFermePar(?User $fermePar): static
  260.     {
  261.         $this->fermePar = $fermePar;
  262.         return $this;
  263.     }
  265.     public function getValidePar(): ?User
  266.     {
  267.         return $this->validePar;
  268.     }
  270.     public function setValidePar(?User $validePar): static
  271.     {
  272.         $this->validePar = $validePar;
  273.         return $this;
  274.     }
  276.     public function getDateValidation(): ?\DateTimeInterface
  277.     {
  278.         return $this->dateValidation;
  279.     }
  281.     public function setDateValidation(?\DateTimeInterface $dateValidation): static
  282.     {
  283.         $this->dateValidation = $dateValidation;
  284.         return $this;
  285.     }
  287.     public function calculerFondsTheorique(): void
  288.     {
  289.         $totalEntrees = 0;
  290.         $totalSorties = 0;
  292.         foreach ($this->mouvements as $mouvement) {
  293.             if ($mouvement->getTypeMouvement() === 'entree') {
  294.                 $totalEntrees += floatval($mouvement->getMontant());
  295.             } else {
  296.                 $totalSorties += floatval($mouvement->getMontant());
  297.             }
  298.         }
  300.         $fondsTheorique = floatval($this->fondsOuverture) + $totalEntrees - $totalSorties;
  301.         $this->fondsTheoriqueFermeture = number_format($fondsTheorique, 2, '.', '');
  302.     }
  304.     public function calculerEcart(): void
  305.     {
  306.         if ($this->fondsFermeture !== null && $this->fondsTheoriqueFermeture !== null) {
  307.             $ecart = floatval($this->fondsFermeture) - floatval($this->fondsTheoriqueFermeture);
  308.             $this->ecart = number_format($ecart, 2, '.', '');
  309.         }
  310.     }
  312.     public function getDuree(): ?int
  313.     {
  314.         if (!$this->dateOuverture) {
  315.             return null;
  316.         }
  317.         
  318.         $dateFin = $this->dateFermeture ?? new \DateTime();
  319.         return $this->dateOuverture->diff($dateFin)->h;
  320.     }
  322.     public function getTotalEntrees(): float
  323.     {
  324.         $total = 0;
  325.         foreach ($this->mouvements as $mouvement) {
  326.             if ($mouvement->getTypeMouvement() === 'entree') {
  327.                 $total += floatval($mouvement->getMontant());
  328.             }
  329.         }
  330.         return $total;
  331.     }
  333.     public function getTotalSorties(): float
  334.     {
  335.         $total = 0;
  336.         foreach ($this->mouvements as $mouvement) {
  337.             if ($mouvement->getTypeMouvement() === 'sortie') {
  338.                 $total += floatval($mouvement->getMontant());
  339.             }
  340.         }
  341.         return $total;
  342.     }
  344.     public function __toString(): string
  345.     {
  346.         return 'Session ' . ($this->dateOuverture ? $this->dateOuverture->format('d/m/Y H:i') : '');
  347.     }
  348. }