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;
  72.     #[ORM\Column]
  73.     private ?int $idAddSecure = null;
  76.     const TYPEVEHICULES = array(0=>'Inconnu',1=>'Tracteur',2=>'Voiture');
  78.     public function __construct()
  79.     {
  80.         $this->consommationCamions = new ArrayCollection();
  81.         $this->camionUsers = new ArrayCollection();
  82.         $this->cartePaiements = new ArrayCollection();
  83.         $this->cartePaiementCamions = new ArrayCollection();
  84.         $this->maintenances = new ArrayCollection();
  85.         $this->factures = new ArrayCollection();
  86.         $this->planningVoitures = new ArrayCollection();
  87.         $this->pneuVehicules = new ArrayCollection();
  88.     }
  90.     public function getId(): ?int
  91.     {
  92.         return $this->id;
  93.     }
  95.     public function getNom(): ?string
  96.     {
  97.         return $this->nom;
  98.     }
  100.     public function setNom(string $nom): self
  101.     {
  102.         $this->nom = $nom;
  104.         return $this;
  105.     }
  107.     /**
  108.      * @return Collection<int, ConsommationCamion>
  109.      */
  110.     public function getConsommationCamions(): Collection
  111.     {
  112.         return $this->consommationCamions;
  113.     }
  115.     public function addConsommationCamion(ConsommationCamion $consommationCamion): self
  116.     {
  117.         if (!$this->consommationCamions->contains($consommationCamion)) {
  118.             $this->consommationCamions->add($consommationCamion);
  119.             $consommationCamion->setCamion($this);
  120.         }
  122.         return $this;
  123.     }
  125.     public function removeConsommationCamion(ConsommationCamion $consommationCamion): self
  126.     {
  127.         if ($this->consommationCamions->removeElement($consommationCamion)) {
  128.             // set the owning side to null (unless already changed)
  129.             if ($consommationCamion->getCamion() === $this) {
  130.                 $consommationCamion->setCamion(null);
  131.             }
  132.         }
  134.         return $this;
  135.     }
  139.     public function getActif(): ?int
  140.     {
  141.         return $this->actif;
  142.     }
  144.     public function setActif(int $actif): self
  145.     {
  146.         $this->actif = $actif;
  148.         return $this;
  149.     }
  152.     public function getTypeVehicule(): ?int
  153.     {
  154.         return $this->typeVehicule;
  155.     }
  157.     public function getIconeTypeVehicule()
  158.     {
  159.         if($this->typeVehicule == 1)
  160.         {
  161.             echo "<i class=\"fa-solid fa-truck-moving\"></i>";
  162.         }
  163.         else if($this->typeVehicule == 2)
  164.         {
  165.             echo"<i class=\"fa-solid fa-car-side\"></i>";
  166.         }
  167.         else
  168.         {
  169.             echo "<i class=\"fa-solid fa-question\"></i>";
  170.         }
  171.     }
  173.     public function setTypeVehicule(int $typeVehicule): self
  174.     {
  175.         $this->typeVehicule = $typeVehicule;
  177.         return $this;
  178.     }
  182.     public function getUserByDate($date): ?User
  183.     {
  184.         if(!empty($this->getCamionUsers()))
  185.         {
  187.         }
  188.         return $this->user;
  189.     }
  191.     /**
  192.      * @return Collection<int, ConsommationCamion>
  193.      */
  194.     public function getCamionUsers(): Collection
  195.     {
  196.         return $this->camionUsers;
  197.     }
  199.     public function __toString()
  200.     {
  201.         return $this->getNom();
  202.     }
  204.     /**
  205.      * @return Collection<int, CartePaiement>
  206.      */
  207.     public function getCartePaiements(): Collection
  208.     {
  209.         return $this->cartePaiements;
  210.     }
  212.     public function addCartePaiement(CartePaiement $cartePaiement): self
  213.     {
  214.         if (!$this->cartePaiements->contains($cartePaiement)) {
  215.             $this->cartePaiements->add($cartePaiement);
  216.             $cartePaiement->setCamion($this);
  217.         }
  219.         return $this;
  220.     }
  222.     public function removeCartePaiement(CartePaiement $cartePaiement): self
  223.     {
  224.         if ($this->cartePaiements->removeElement($cartePaiement)) {
  225.             // set the owning side to null (unless already changed)
  226.             if ($cartePaiement->getCamion() === $this) {
  227.                 $cartePaiement->setCamion(null);
  228.             }
  229.         }
  231.         return $this;
  232.     }
  234.     /**
  235.      * @return Collection<int, CartePaiementCamion>
  236.      */
  237.     public function getCartePaiementCamions(): Collection
  238.     {
  239.         return $this->cartePaiementCamions;
  240.     }
  242.     public function addCartePaiementCamion(CartePaiementCamion $cartePaiementCamion): self
  243.     {
  244.         if (!$this->cartePaiementCamions->contains($cartePaiementCamion)) {
  245.             $this->cartePaiementCamions->add($cartePaiementCamion);
  246.             $cartePaiementCamion->setCamion($this);
  247.         }
  249.         return $this;
  250.     }
  252.     public function removeCartePaiementCamion(CartePaiementCamion $cartePaiementCamion): self
  253.     {
  254.         if ($this->cartePaiementCamions->removeElement($cartePaiementCamion)) {
  255.             // set the owning side to null (unless already changed)
  256.             if ($cartePaiementCamion->getCamion() === $this) {
  257.                 $cartePaiementCamion->setCamion(null);
  258.             }
  259.         }
  261.         return $this;
  262.     }
  264.     /**
  265.      * @return Collection<int, CartePaiementCamion>
  266.      */
  267.     public function getCartePaiementByDate($date): Collection
  268.     {
  270.         return $this->cartePaiementCamions;
  271.     }
  273.     /**
  274.      * @return Collection<int, Maintenance>
  275.      */
  276.     public function getMaintenances(): Collection
  277.     {
  278.         return $this->maintenances;
  279.     }
  281.     public function addMaintenance(Maintenance $maintenance): self
  282.     {
  283.         if (!$this->maintenances->contains($maintenance)) {
  284.             $this->maintenances->add($maintenance);
  285.             $maintenance->setCamion($this);
  286.         }
  288.         return $this;
  289.     }
  291.     public function removeMaintenance(Maintenance $maintenance): self
  292.     {
  293.         if ($this->maintenances->removeElement($maintenance)) {
  294.             // set the owning side to null (unless already changed)
  295.             if ($maintenance->getCamion() === $this) {
  296.                 $maintenance->setCamion(null);
  297.             }
  298.         }
  300.         return $this;
  301.     }
  303.     /**
  304.      * @return Collection<int, Facture>
  305.      */
  306.     public function getFactures(): Collection
  307.     {
  308.         return $this->factures;
  309.     }
  311.     public function addFacture(Facture $facture): self
  312.     {
  313.         if (!$this->factures->contains($facture)) {
  314.             $this->factures->add($facture);
  315.             $facture->setCamion($this);
  316.         }
  318.         return $this;
  319.     }
  321.     public function removeFacture(Facture $facture): self
  322.     {
  323.         if ($this->factures->removeElement($facture)) {
  324.             // set the owning side to null (unless already changed)
  325.             if ($facture->getCamion() === $this) {
  326.                 $facture->setCamion(null);
  327.             }
  328.         }
  330.         return $this;
  331.     }
  333.     public function getSystemeClient(): ?SystemeClient
  334.     {
  335.         return $this->systemeClient;
  336.     }
  338.     public function setSystemeClient(?SystemeClient $systemeClient): self
  339.     {
  340.         $this->systemeClient = $systemeClient;
  342.         return $this;
  343.     }
  345.     public function getDateImmat(): ?\DateTimeInterface
  346.     {
  347.         return $this->dateImmat;
  348.     }
  350.     public function setDateImmat(\DateTimeInterface $dateImmat): self
  351.     {
  352.         $this->dateImmat = $dateImmat;
  354.         return $this;
  355.     }
  357.     /**
  358.      * @return Collection<int, PlanningVoiture>
  359.      */
  360.     public function getPlanningVoitures(): Collection
  361.     {
  362.         return $this->planningVoitures;
  363.     }
  365.     public function addPlanningVoiture(PlanningVoiture $planningVoiture): self
  366.     {
  367.         if (!$this->planningVoitures->contains($planningVoiture)) {
  368.             $this->planningVoitures->add($planningVoiture);
  369.             $planningVoiture->setVoiture($this);
  370.         }
  372.         return $this;
  373.     }
  375.     public function removePlanningVoiture(PlanningVoiture $planningVoiture): self
  376.     {
  377.         if ($this->planningVoitures->removeElement($planningVoiture)) {
  378.             // set the owning side to null (unless already changed)
  379.             if ($planningVoiture->getVoiture() === $this) {
  380.                 $planningVoiture->setVoiture(null);
  381.             }
  382.         }
  384.         return $this;
  385.     }
  387.     public function getIdSamsara(): ?string
  388.     {
  389.         return $this->idSamsara;
  390.     }
  392.     public function setIdSamsara(string $idSamsara): static
  393.     {
  394.         $this->idSamsara = $idSamsara;
  396.         return $this;
  397.     }
  399.     public function getNbrEssieux(): ?int
  400.     {
  401.         return $this->nbrEssieux;
  402.     }
  404.     public function setNbrEssieux(int $nbrEssieux): static
  405.     {
  406.         $this->nbrEssieux = $nbrEssieux;
  408.         return $this;
  409.     }
  411.     /**
  412.      * @return Collection<int, PneuVehicule>
  413.      */
  414.     public function getPneuVehicules(): Collection
  415.     {
  416.         return $this->pneuVehicules;
  417.     }
  419.     public function addPneuVehicule(PneuVehicule $pneuVehicule): static
  420.     {
  421.         if (!$this->pneuVehicules->contains($pneuVehicule)) {
  422.             $this->pneuVehicules->add($pneuVehicule);
  423.             $pneuVehicule->setCamion($this);
  424.         }
  426.         return $this;
  427.     }
  429.     public function removePneuVehicule(PneuVehicule $pneuVehicule): static
  430.     {
  431.         if ($this->pneuVehicules->removeElement($pneuVehicule)) {
  432.             // set the owning side to null (unless already changed)
  433.             if ($pneuVehicule->getCamion() === $this) {
  434.                 $pneuVehicule->setCamion(null);
  435.             }
  436.         }
  438.         return $this;
  439.     }
  441.     public function getConstructeur(): ?Constructeur
  442.     {
  443.         return $this->constructeur;
  444.     }
  446.     public function setConstructeur(?Constructeur $constructeur): static
  447.     {
  448.         $this->constructeur = $constructeur;
  450.         return $this;
  451.     }
  453.     public function getFinContratConstructeur(): ?\DateTimeInterface
  454.     {
  455.         return $this->finContratConstructeur;
  456.     }
  458.     public function setFinContratConstructeur(?\DateTimeInterface $finContratConstructeur): static
  459.     {
  460.         $this->finContratConstructeur = $finContratConstructeur;
  462.         return $this;
  463.     }
  465.     public function getIdAddSecure(): ?int
  466.     {
  467.         return $this->idAddSecure;
  468.     }
  470.     public function setIdAddSecure(int $idAddSecure): static
  471.     {
  472.         $this->idAddSecure = $idAddSecure;
  474.         return $this;
  475.     }
  476. }