src/Entity/Camion.php line 13

  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\CamionRepository;
  6. use App\Repository\CamionUserRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\DBAL\Types\Types;
  10. use Doctrine\ORM\Mapping as ORM;
  12. #[ORM\Entity(repositoryClass: CamionRepository::class)]
  13. class Camion
  14. {
  15.     #[ORM\Id]
  16.     #[ORM\GeneratedValue]
  17.     #[ORM\Column]
  18.     private ?int $id = null;
  20.     #[ORM\Column(length: 50)]
  21.     private ?string $nom = null;
  23.     #[ORM\Column]
  24.     private ?int $actif;
  26.     #[ORM\Column]
  27.     private ?int $typeVehicule;
  29.     #[ORM\OneToMany(mappedBy: 'camion', targetEntity: ConsommationCamion::class)]
  30.     private Collection $consommationCamions;
  33.     #[ORM\OneToMany(mappedBy: 'camion', targetEntity: CamionUser::class)]
  34.     private Collection $camionUsers;
  36.     #[ORM\OneToMany(mappedBy: 'camion', targetEntity: CartePaiement::class)]
  37.     private Collection $cartePaiements;
  39.     #[ORM\OneToMany(mappedBy: 'camion', targetEntity: CartePaiementCamion::class)]
  40.     private Collection $cartePaiementCamions;
  42.     #[ORM\OneToMany(mappedBy: 'Camion', targetEntity: Maintenance::class)]
  43.     private Collection $maintenances;
  45.     #[ORM\OneToMany(mappedBy: 'camion', targetEntity: Facture::class)]
  46.     private Collection $factures;
  48.     #[ORM\ManyToOne(inversedBy: 'camions')]
  49.     private ?SystemeClient $systemeClient = null;
  51.     #[ORM\Column(type: Types::DATE_MUTABLE)]
  52.     private ?\DateTimeInterface $dateImmat = null;
  54.     #[ORM\OneToMany(mappedBy: 'voiture', targetEntity: PlanningVoiture::class)]
  55.     private Collection $planningVoitures;
  57.     #[ORM\Column(length: 255)]
  58.     private ?string $idSamsara = null;
  60.     #[ORM\Column]
  61.     private ?int $nbrEssieux = null;
  63.     #[ORM\OneToMany(mappedBy: 'camion', targetEntity: PneuVehicule::class)]
  64.     private Collection $pneuVehicules;
  66.     #[ORM\ManyToOne(inversedBy: 'constructeur')]
  67.     private ?Constructeur $constructeur = null;
  69.     #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
  70.     private ?\DateTimeInterface $finContratConstructeur = null;
  73.     const TYPEVEHICULES = array(0=>'Inconnu',1=>'Tracteur',2=>'Voiture');
  75.     public function __construct()
  76.     {
  77.         $this->consommationCamions = new ArrayCollection();
  78.         $this->camionUsers = new ArrayCollection();
  79.         $this->cartePaiements = new ArrayCollection();
  80.         $this->cartePaiementCamions = new ArrayCollection();
  81.         $this->maintenances = new ArrayCollection();
  82.         $this->factures = new ArrayCollection();
  83.         $this->planningVoitures = new ArrayCollection();
  84.         $this->pneuVehicules = new ArrayCollection();
  85.     }
  87.     public function getId(): ?int
  88.     {
  89.         return $this->id;
  90.     }
  92.     public function getNom(): ?string
  93.     {
  94.         return $this->nom;
  95.     }
  97.     public function setNom(string $nom): self
  98.     {
  99.         $this->nom = $nom;
  101.         return $this;
  102.     }
  104.     /**
  105.      * @return Collection<int, ConsommationCamion>
  106.      */
  107.     public function getConsommationCamions(): Collection
  108.     {
  109.         return $this->consommationCamions;
  110.     }
  112.     public function addConsommationCamion(ConsommationCamion $consommationCamion): self
  113.     {
  114.         if (!$this->consommationCamions->contains($consommationCamion)) {
  115.             $this->consommationCamions->add($consommationCamion);
  116.             $consommationCamion->setCamion($this);
  117.         }
  119.         return $this;
  120.     }
  122.     public function removeConsommationCamion(ConsommationCamion $consommationCamion): self
  123.     {
  124.         if ($this->consommationCamions->removeElement($consommationCamion)) {
  125.             // set the owning side to null (unless already changed)
  126.             if ($consommationCamion->getCamion() === $this) {
  127.                 $consommationCamion->setCamion(null);
  128.             }
  129.         }
  131.         return $this;
  132.     }
  136.     public function getActif(): ?int
  137.     {
  138.         return $this->actif;
  139.     }
  141.     public function setActif(int $actif): self
  142.     {
  143.         $this->actif = $actif;
  145.         return $this;
  146.     }
  149.     public function getTypeVehicule(): ?int
  150.     {
  151.         return $this->typeVehicule;
  152.     }
  154.     public function getIconeTypeVehicule()
  155.     {
  156.         if($this->typeVehicule == 1)
  157.         {
  158.             echo "<i class=\"fa-solid fa-truck-moving\"></i>";
  159.         }
  160.         else if($this->typeVehicule == 2)
  161.         {
  162.             echo"<i class=\"fa-solid fa-car-side\"></i>";
  163.         }
  164.         else
  165.         {
  166.             echo "<i class=\"fa-solid fa-question\"></i>";
  167.         }
  168.     }
  170.     public function setTypeVehicule(int $typeVehicule): self
  171.     {
  172.         $this->typeVehicule = $typeVehicule;
  174.         return $this;
  175.     }
  179.     public function getUserByDate($date): ?User
  180.     {
  181.         if(!empty($this->getCamionUsers()))
  182.         {
  184.         }
  185.         return $this->user;
  186.     }
  188.     /**
  189.      * @return Collection<int, ConsommationCamion>
  190.      */
  191.     public function getCamionUsers(): Collection
  192.     {
  193.         return $this->camionUsers;
  194.     }
  196.     public function __toString()
  197.     {
  198.         return $this->getNom();
  199.     }
  201.     /**
  202.      * @return Collection<int, CartePaiement>
  203.      */
  204.     public function getCartePaiements(): Collection
  205.     {
  206.         return $this->cartePaiements;
  207.     }
  209.     public function addCartePaiement(CartePaiement $cartePaiement): self
  210.     {
  211.         if (!$this->cartePaiements->contains($cartePaiement)) {
  212.             $this->cartePaiements->add($cartePaiement);
  213.             $cartePaiement->setCamion($this);
  214.         }
  216.         return $this;
  217.     }
  219.     public function removeCartePaiement(CartePaiement $cartePaiement): self
  220.     {
  221.         if ($this->cartePaiements->removeElement($cartePaiement)) {
  222.             // set the owning side to null (unless already changed)
  223.             if ($cartePaiement->getCamion() === $this) {
  224.                 $cartePaiement->setCamion(null);
  225.             }
  226.         }
  228.         return $this;
  229.     }
  231.     /**
  232.      * @return Collection<int, CartePaiementCamion>
  233.      */
  234.     public function getCartePaiementCamions(): Collection
  235.     {
  236.         return $this->cartePaiementCamions;
  237.     }
  239.     public function addCartePaiementCamion(CartePaiementCamion $cartePaiementCamion): self
  240.     {
  241.         if (!$this->cartePaiementCamions->contains($cartePaiementCamion)) {
  242.             $this->cartePaiementCamions->add($cartePaiementCamion);
  243.             $cartePaiementCamion->setCamion($this);
  244.         }
  246.         return $this;
  247.     }
  249.     public function removeCartePaiementCamion(CartePaiementCamion $cartePaiementCamion): self
  250.     {
  251.         if ($this->cartePaiementCamions->removeElement($cartePaiementCamion)) {
  252.             // set the owning side to null (unless already changed)
  253.             if ($cartePaiementCamion->getCamion() === $this) {
  254.                 $cartePaiementCamion->setCamion(null);
  255.             }
  256.         }
  258.         return $this;
  259.     }
  261.     /**
  262.      * @return Collection<int, CartePaiementCamion>
  263.      */
  264.     public function getCartePaiementByDate($date): Collection
  265.     {
  267.         return $this->cartePaiementCamions;
  268.     }
  270.     /**
  271.      * @return Collection<int, Maintenance>
  272.      */
  273.     public function getMaintenances(): Collection
  274.     {
  275.         return $this->maintenances;
  276.     }
  278.     public function addMaintenance(Maintenance $maintenance): self
  279.     {
  280.         if (!$this->maintenances->contains($maintenance)) {
  281.             $this->maintenances->add($maintenance);
  282.             $maintenance->setCamion($this);
  283.         }
  285.         return $this;
  286.     }
  288.     public function removeMaintenance(Maintenance $maintenance): self
  289.     {
  290.         if ($this->maintenances->removeElement($maintenance)) {
  291.             // set the owning side to null (unless already changed)
  292.             if ($maintenance->getCamion() === $this) {
  293.                 $maintenance->setCamion(null);
  294.             }
  295.         }
  297.         return $this;
  298.     }
  300.     /**
  301.      * @return Collection<int, Facture>
  302.      */
  303.     public function getFactures(): Collection
  304.     {
  305.         return $this->factures;
  306.     }
  308.     public function addFacture(Facture $facture): self
  309.     {
  310.         if (!$this->factures->contains($facture)) {
  311.             $this->factures->add($facture);
  312.             $facture->setCamion($this);
  313.         }
  315.         return $this;
  316.     }
  318.     public function removeFacture(Facture $facture): self
  319.     {
  320.         if ($this->factures->removeElement($facture)) {
  321.             // set the owning side to null (unless already changed)
  322.             if ($facture->getCamion() === $this) {
  323.                 $facture->setCamion(null);
  324.             }
  325.         }
  327.         return $this;
  328.     }
  330.     public function getSystemeClient(): ?SystemeClient
  331.     {
  332.         return $this->systemeClient;
  333.     }
  335.     public function setSystemeClient(?SystemeClient $systemeClient): self
  336.     {
  337.         $this->systemeClient = $systemeClient;
  339.         return $this;
  340.     }
  342.     public function getDateImmat(): ?\DateTimeInterface
  343.     {
  344.         return $this->dateImmat;
  345.     }
  347.     public function setDateImmat(\DateTimeInterface $dateImmat): self
  348.     {
  349.         $this->dateImmat = $dateImmat;
  351.         return $this;
  352.     }
  354.     /**
  355.      * @return Collection<int, PlanningVoiture>
  356.      */
  357.     public function getPlanningVoitures(): Collection
  358.     {
  359.         return $this->planningVoitures;
  360.     }
  362.     public function addPlanningVoiture(PlanningVoiture $planningVoiture): self
  363.     {
  364.         if (!$this->planningVoitures->contains($planningVoiture)) {
  365.             $this->planningVoitures->add($planningVoiture);
  366.             $planningVoiture->setVoiture($this);
  367.         }
  369.         return $this;
  370.     }
  372.     public function removePlanningVoiture(PlanningVoiture $planningVoiture): self
  373.     {
  374.         if ($this->planningVoitures->removeElement($planningVoiture)) {
  375.             // set the owning side to null (unless already changed)
  376.             if ($planningVoiture->getVoiture() === $this) {
  377.                 $planningVoiture->setVoiture(null);
  378.             }
  379.         }
  381.         return $this;
  382.     }
  384.     public function getIdSamsara(): ?string
  385.     {
  386.         return $this->idSamsara;
  387.     }
  389.     public function setIdSamsara(string $idSamsara): static
  390.     {
  391.         $this->idSamsara = $idSamsara;
  393.         return $this;
  394.     }
  396.     public function getNbrEssieux(): ?int
  397.     {
  398.         return $this->nbrEssieux;
  399.     }
  401.     public function setNbrEssieux(int $nbrEssieux): static
  402.     {
  403.         $this->nbrEssieux = $nbrEssieux;
  405.         return $this;
  406.     }
  408.     /**
  409.      * @return Collection<int, PneuVehicule>
  410.      */
  411.     public function getPneuVehicules(): Collection
  412.     {
  413.         return $this->pneuVehicules;
  414.     }
  416.     public function addPneuVehicule(PneuVehicule $pneuVehicule): static
  417.     {
  418.         if (!$this->pneuVehicules->contains($pneuVehicule)) {
  419.             $this->pneuVehicules->add($pneuVehicule);
  420.             $pneuVehicule->setCamion($this);
  421.         }
  423.         return $this;
  424.     }
  426.     public function removePneuVehicule(PneuVehicule $pneuVehicule): static
  427.     {
  428.         if ($this->pneuVehicules->removeElement($pneuVehicule)) {
  429.             // set the owning side to null (unless already changed)
  430.             if ($pneuVehicule->getCamion() === $this) {
  431.                 $pneuVehicule->setCamion(null);
  432.             }
  433.         }
  435.         return $this;
  436.     }
  438.     public function getConstructeur(): ?Constructeur
  439.     {
  440.         return $this->constructeur;
  441.     }
  443.     public function setConstructeur(?Constructeur $constructeur): static
  444.     {
  445.         $this->constructeur = $constructeur;
  447.         return $this;
  448.     }
  450.     public function getFinContratConstructeur(): ?\DateTimeInterface
  451.     {
  452.         return $this->finContratConstructeur;
  453.     }
  455.     public function setFinContratConstructeur(?\DateTimeInterface $finContratConstructeur): static
  456.     {
  457.         $this->finContratConstructeur = $finContratConstructeur;
  459.         return $this;
  460.     }
  461. }