src/Entity/SystemeClient.php line 11

  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\SystemeClientRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  10. #[ORM\Entity(repositoryClass: SystemeClientRepository::class)]
  11. class SystemeClient
  12. {
  13.     #[ORM\Id]
  14.     #[ORM\GeneratedValue]
  15.     #[ORM\Column]
  16.     private ?int $id = null;
  18.     #[ORM\Column(length: 255)]
  19.     private ?string $nom = null;
  21.     #[ORM\OneToMany(mappedBy: 'systemeClient', targetEntity: User::class)]
  22.     private Collection $users;
  24.     #[ORM\OneToMany(mappedBy: 'systemeClient', targetEntity: Remorque::class)]
  25.     private Collection $remorques;
  27.     #[ORM\OneToMany(mappedBy: 'systemeClient', targetEntity: Camion::class)]
  28.     private Collection $camions;
  30.     #[ORM\OneToMany(mappedBy: 'systemeClient', targetEntity: Maintenance::class)]
  31.     private Collection $maintenances;
  33.     #[ORM\OneToMany(mappedBy: 'systemeClient', targetEntity: TourneeTheorique::class)]
  34.     private Collection $tourneeTheoriques;
  36.     #[ORM\OneToMany(mappedBy: 'systemeClient', targetEntity: Client::class)]
  37.     private Collection $clients;
  39.     #[ORM\OneToMany(mappedBy: 'systemeClient', targetEntity: Pneu::class)]
  40.     private Collection $pneus;
  42.     #[ORM\OneToMany(mappedBy: 'SystemeClient', targetEntity: MaintenanceType::class)]
  43.     private Collection $maintenanceTypes;
  45.     public function __construct()
  46.     {
  47.         $this->users = new ArrayCollection();
  48.         $this->remorques = new ArrayCollection();
  49.         $this->camions = new ArrayCollection();
  50.         $this->maintenances = new ArrayCollection();
  51.         $this->tourneeTheoriques = new ArrayCollection();
  52.         $this->clients = new ArrayCollection();
  53.         $this->maintenanceTypes = new ArrayCollection();
  54.     }
  56.     public function getId(): ?int
  57.     {
  58.         return $this->id;
  59.     }
  61.     public function getNom(): ?string
  62.     {
  63.         return $this->nom;
  64.     }
  66.     public function setNom(string $nom): self
  67.     {
  68.         $this->nom = $nom;
  70.         return $this;
  71.     }
  73.     /**
  74.      * @return Collection<int, User>
  75.      */
  76.     public function getUsers(): Collection
  77.     {
  78.         return $this->users;
  79.     }
  81.     public function addUser(User $user): self
  82.     {
  83.         if (!$this->users->contains($user)) {
  84.             $this->users->add($user);
  85.             $user->setSystemeClient($this);
  86.         }
  88.         return $this;
  89.     }
  91.     public function removeUser(User $user): self
  92.     {
  93.         if ($this->users->removeElement($user)) {
  94.             // set the owning side to null (unless already changed)
  95.             if ($user->getSystemeClient() === $this) {
  96.                 $user->setSystemeClient(null);
  97.             }
  98.         }
  100.         return $this;
  101.     }
  103.     /**
  104.      * @return Collection<int, Remorque>
  105.      */
  106.     public function getRemorques(): Collection
  107.     {
  108.         return $this->remorques;
  109.     }
  111.     public function addRemorque(Remorque $remorque): self
  112.     {
  113.         if (!$this->remorques->contains($remorque)) {
  114.             $this->remorques->add($remorque);
  115.             $remorque->setSystemeClient($this);
  116.         }
  118.         return $this;
  119.     }
  121.     public function removeRemorque(Remorque $remorque): self
  122.     {
  123.         if ($this->remorques->removeElement($remorque)) {
  124.             // set the owning side to null (unless already changed)
  125.             if ($remorque->getSystemeClient() === $this) {
  126.                 $remorque->setSystemeClient(null);
  127.             }
  128.         }
  130.         return $this;
  131.     }
  133.     /**
  134.      * @return Collection<int, Camion>
  135.      */
  136.     public function getCamions(): Collection
  137.     {
  138.         return $this->camions;
  139.     }
  141.     public function addCamion(Camion $camion): self
  142.     {
  143.         if (!$this->camions->contains($camion)) {
  144.             $this->camions->add($camion);
  145.             $camion->setSystemeClient($this);
  146.         }
  148.         return $this;
  149.     }
  151.     public function removeCamion(Camion $camion): self
  152.     {
  153.         if ($this->camions->removeElement($camion)) {
  154.             // set the owning side to null (unless already changed)
  155.             if ($camion->getSystemeClient() === $this) {
  156.                 $camion->setSystemeClient(null);
  157.             }
  158.         }
  160.         return $this;
  161.     }
  163.     /**
  164.      * @return Collection<int, Maintenance>
  165.      */
  166.     public function getMaintenances(): Collection
  167.     {
  168.         return $this->maintenances;
  169.     }
  171.     public function addMaintenance(Maintenance $maintenance): self
  172.     {
  173.         if (!$this->maintenances->contains($maintenance)) {
  174.             $this->maintenances->add($maintenance);
  175.             $maintenance->setSystemeClient($this);
  176.         }
  178.         return $this;
  179.     }
  181.     public function removeMaintenance(Maintenance $maintenance): self
  182.     {
  183.         if ($this->maintenances->removeElement($maintenance)) {
  184.             // set the owning side to null (unless already changed)
  185.             if ($maintenance->getSystemeClient() === $this) {
  186.                 $maintenance->setSystemeClient(null);
  187.             }
  188.         }
  190.         return $this;
  191.     }
  193.     /**
  194.      * @return Collection<int, TourneeTheorique>
  195.      */
  196.     public function getTourneeTheoriques(): Collection
  197.     {
  198.         return $this->tourneeTheoriques;
  199.     }
  201.     public function addTourneeTheorique(TourneeTheorique $tourneeTheorique): self
  202.     {
  203.         if (!$this->tourneeTheoriques->contains($tourneeTheorique)) {
  204.             $this->tourneeTheoriques->add($tourneeTheorique);
  205.             $tourneeTheorique->setSystemeClient($this);
  206.         }
  208.         return $this;
  209.     }
  211.     public function removeTourneeTheorique(TourneeTheorique $tourneeTheorique): self
  212.     {
  213.         if ($this->tourneeTheoriques->removeElement($tourneeTheorique)) {
  214.             // set the owning side to null (unless already changed)
  215.             if ($tourneeTheorique->getSystemeClient() === $this) {
  216.                 $tourneeTheorique->setSystemeClient(null);
  217.             }
  218.         }
  220.         return $this;
  221.     }
  223.     public function __toString()
  224.     {
  225.         return $this->getNom();
  226.     }
  228.     /**
  229.      * @return Collection<int, Client>
  230.      */
  231.     public function getClients(): Collection
  232.     {
  233.         return $this->clients;
  234.     }
  236.     public function addClient(Client $client): self
  237.     {
  238.         if (!$this->clients->contains($client)) {
  239.             $this->clients->add($client);
  240.             $client->setSystemeClient($this);
  241.         }
  243.         return $this;
  244.     }
  246.     public function removeClient(Client $client): self
  247.     {
  248.         if ($this->clients->removeElement($client)) {
  249.             // set the owning side to null (unless already changed)
  250.             if ($client->getSystemeClient() === $this) {
  251.                 $client->setSystemeClient(null);
  252.             }
  253.         }
  255.         return $this;
  256.     }
  258.     /**
  259.      * @return Collection<int, Pneu>
  260.      */
  261.     public function getPneus(): Collection
  262.     {
  263.         return $this->pneus;
  264.     }
  266.     public function addPneu(Pneu $pneu): static
  267.     {
  268.         if (!$this->pneus->contains($pneu)) {
  269.             $this->pneus->add($pneu);
  270.             $pneu->setSystemeClient($this);
  271.         }
  273.         return $this;
  274.     }
  276.     public function removePneu(Pneu $pneu): static
  277.     {
  278.         if ($this->pneus->removeElement($pneu)) {
  279.             // set the owning side to null (unless already changed)
  280.             if ($pneu->getSystemeClient() === $this) {
  281.                 $pneu->setSystemeClient(null);
  282.             }
  283.         }
  285.         return $this;
  286.     }
  288.     /**
  289.      * @return Collection<int, MaintenanceType>
  290.      */
  291.     public function getMaintenanceTypes(): Collection
  292.     {
  293.         return $this->maintenanceTypes;
  294.     }
  296.     public function addMaintenanceType(MaintenanceType $maintenanceType): static
  297.     {
  298.         if (!$this->maintenanceTypes->contains($maintenanceType)) {
  299.             $this->maintenanceTypes->add($maintenanceType);
  300.             $maintenanceType->setSystemeClient($this);
  301.         }
  303.         return $this;
  304.     }
  306.     public function removeMaintenanceType(MaintenanceType $maintenanceType): static
  307.     {
  308.         if ($this->maintenanceTypes->removeElement($maintenanceType)) {
  309.             // set the owning side to null (unless already changed)
  310.             if ($maintenanceType->getSystemeClient() === $this) {
  311.                 $maintenanceType->setSystemeClient(null);
  312.             }
  313.         }
  315.         return $this;
  316.     }
  317. }