src/Entity/Gestionmachines.php line 11

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\GestionmachinesRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  10. #[ORM\Entity(repositoryClass: GestionmachinesRepository::class)]
  11. class Gestionmachines
  12. {
  13.     #[ORM\Id]
  14.     #[ORM\GeneratedValue]
  15.     #[ORM\Column]
  16.     private ?int $id = null;
  18.     #[ORM\Column(length: 255, nullable: true)]
  19.     private ?string $nom = null;
  21.     #[ORM\Column(length: 255, nullable: true)]
  22.     private ?string $numserie = null;
  24.     #[ORM\Column(length: 255, nullable: true)]
  25.     private ?string $nbchute = null;
  27.     #[ORM\ManyToMany(targetEntity: Aiguilles::class, inversedBy: 'gestionmachines')]
  28.     private Collection $aiguilles;
  30.     #[ORM\ManyToMany(targetEntity: Courroie::class, inversedBy: 'gestionmachines')]
  31.     private Collection $courroie;
  33.     #[ORM\ManyToMany(targetEntity: Platines::class, inversedBy: 'gestionmachines')]
  34.     private Collection $platines;
  36.     #[ORM\ManyToOne(inversedBy: 'gestionmachines')]
  37.     private ?Machine $machine = null;
  39.     #[ORM\ManyToOne(inversedBy: 'gestionmachines')]
  40.     private ?ModeleMachine $modeleMachine = null;
  42.     #[ORM\ManyToOne(inversedBy: 'gestionmachines')]
  43.     private ?JaugeMachine $jaugeMachine = null;
  45.     #[ORM\ManyToOne(inversedBy: 'gestionmachines')]
  46.     private ?DiametreMachine $diametreMachine = null;
  48.     #[ORM\ManyToOne(inversedBy: 'gestionmachines')]
  49.     private ?Nbchute $nbchutee = null;
  51.     #[ORM\ManyToOne(inversedBy: 'gestionmachines')]
  52.     private ?MarqueMachine $marqueMachine = null;
  54.     #[ORM\ManyToOne(inversedBy: 'gestionmachines')]
  55.     private ?Client $client = null;
  57.     #[ORM\ManyToMany(targetEntity: Famillesdarticles::class, inversedBy: 'gestionmachines')]
  58.     private Collection $famillesdarticles;
  60.     #[ORM\ManyToOne(inversedBy: 'gestionmachines')]
  61.     private ?Structure $structure = null;
  63.     #[ORM\OneToMany(mappedBy: 'nummachine', targetEntity: Intervention::class, cascade: ["remove"])]
  64.     private Collection $interventions;
  66.     #[ORM\OneToMany(mappedBy: 'nummachine', targetEntity: Historiqueintervention::class, cascade: ["remove"])]
  67.     private Collection $historiqueinterventions;
  69.     #[ORM\Column(length: 255, nullable: true)]
  70.     private ?string $num = null;
  72.     #[ORM\OneToMany(mappedBy: 'machine', targetEntity: MachineIntervention::class)]
  73.     private Collection $machineInterventions;
  81.     public function __construct()
  82.     {
  83.         $this->aiguilles = new ArrayCollection();
  84.         $this->courroie = new ArrayCollection();
  85.         $this->platines = new ArrayCollection();
  86.         $this->famillesdarticles = new ArrayCollection();
  87.         $this->interventions = new ArrayCollection();
  88.         $this->historiqueinterventions = new ArrayCollection();
  89.         $this->machineInterventions = new ArrayCollection();
  93.     }
  95.     public function getId(): ?int
  96.     {
  97.         return $this->id;
  98.     }
  100.     public function getNom(): ?string
  101.     {
  102.         return $this->nom;
  103.     }
  105.     public function setNom(?string $nom): self
  106.     {
  107.         $this->nom = $nom;
  109.         return $this;
  110.     }
  112.     public function getNumserie(): ?string
  113.     {
  114.         return $this->numserie;
  115.     }
  117.     public function setNumserie(?string $numserie): self
  118.     {
  119.         $this->numserie = $numserie;
  121.         return $this;
  122.     }
  124.     public function getNbchute(): ?string
  125.     {
  126.         return $this->nbchute;
  127.     }
  129.     public function setNbchute(?string $nbchute): self
  130.     {
  131.         $this->nbchute = $nbchute;
  133.         return $this;
  134.     }
  136.     /**
  137.      * @return Collection<int, Aiguilles>
  138.      */
  139.     public function getAiguilles(): Collection
  140.     {
  141.         return $this->aiguilles;
  142.     }
  144.     public function addAiguille(Aiguilles $aiguille): self
  145.     {
  146.         if (!$this->aiguilles->contains($aiguille)) {
  147.             $this->aiguilles->add($aiguille);
  148.         }
  150.         return $this;
  151.     }
  153.     public function removeAiguille(Aiguilles $aiguille): self
  154.     {
  155.         $this->aiguilles->removeElement($aiguille);
  157.         return $this;
  158.     }
  160.     /**
  161.      * @return Collection<int, Courroie>
  162.      */
  163.     public function getCourroie(): Collection
  164.     {
  165.         return $this->courroie;
  166.     }
  168.     public function addCourroie(Courroie $courroie): self
  169.     {
  170.         if (!$this->courroie->contains($courroie)) {
  171.             $this->courroie->add($courroie);
  172.         }
  174.         return $this;
  175.     }
  177.     public function removeCourroie(Courroie $courroie): self
  178.     {
  179.         $this->courroie->removeElement($courroie);
  181.         return $this;
  182.     }
  184.     /**
  185.      * @return Collection<int, Platines>
  186.      */
  187.     public function getPlatines(): Collection
  188.     {
  189.         return $this->platines;
  190.     }
  192.     public function addPlatine(Platines $platine): self
  193.     {
  194.         if (!$this->platines->contains($platine)) {
  195.             $this->platines->add($platine);
  196.         }
  198.         return $this;
  199.     }
  201.     public function removePlatine(Platines $platine): self
  202.     {
  203.         $this->platines->removeElement($platine);
  205.         return $this;
  206.     }
  208.     public function getMachine(): ?Machine
  209.     {
  210.         return $this->machine;
  211.     }
  213.     public function setMachine(?Machine $machine): self
  214.     {
  215.         $this->machine = $machine;
  217.         return $this;
  218.     }
  220.     public function getModeleMachine(): ?ModeleMachine
  221.     {
  222.         return $this->modeleMachine;
  223.     }
  225.     public function setModeleMachine(?ModeleMachine $modeleMachine): self
  226.     {
  227.         $this->modeleMachine = $modeleMachine;
  229.         return $this;
  230.     }
  232.     public function getJaugeMachine(): ?JaugeMachine
  233.     {
  234.         return $this->jaugeMachine;
  235.     }
  237.     public function setJaugeMachine(?JaugeMachine $jaugeMachine): self
  238.     {
  239.         $this->jaugeMachine = $jaugeMachine;
  241.         return $this;
  242.     }
  244.     public function getDiametreMachine(): ?DiametreMachine
  245.     {
  246.         return $this->diametreMachine;
  247.     }
  249.     public function setDiametreMachine(?DiametreMachine $diametreMachine): self
  250.     {
  251.         $this->diametreMachine = $diametreMachine;
  253.         return $this;
  254.     }
  256.     public function getNbchutee(): ?Nbchute
  257.     {
  258.         return $this->nbchutee;
  259.     }
  261.     public function setNbchutee(?Nbchute $nbchutee): self
  262.     {
  263.         $this->nbchutee = $nbchutee;
  265.         return $this;
  266.     }
  268.     public function getMarqueMachine(): ?MarqueMachine
  269.     {
  270.         return $this->marqueMachine;
  271.     }
  273.     public function setMarqueMachine(?MarqueMachine $marqueMachine): self
  274.     {
  275.         $this->marqueMachine = $marqueMachine;
  277.         return $this;
  278.     }
  280.     public function getClient(): ?Client
  281.     {
  282.         return $this->client;
  283.     }
  285.     public function setClient(?Client $client): self
  286.     {
  287.         $this->client = $client;
  289.         return $this;
  290.     }
  292.     /**
  293.      * @return Collection<int, Famillesdarticles>
  294.      */
  295.     public function getFamillesdarticles(): Collection
  296.     {
  297.         return $this->famillesdarticles;
  298.     }
  300.     public function addFamillesdarticle(Famillesdarticles $famillesdarticle): self
  301.     {
  302.         if (!$this->famillesdarticles->contains($famillesdarticle)) {
  303.             $this->famillesdarticles->add($famillesdarticle);
  304.         }
  306.         return $this;
  307.     }
  309.     public function removeFamillesdarticle(Famillesdarticles $famillesdarticle): self
  310.     {
  311.         $this->famillesdarticles->removeElement($famillesdarticle);
  313.         return $this;
  314.     }
  316.     /**
  317.      * @return Collection<int, Structure>
  318.      */
  320.     public function getStructure(): ?Structure
  321.     {
  322.         return $this->structure;
  323.     }
  325.     public function setStructure(?Structure $structure): self
  326.     {
  327.         $this->structure = $structure;
  329.         return $this;
  330.     }
  332.     /**
  333.      * @return Collection<int, Intervention>
  334.      */
  335.     public function getInterventions(): Collection
  336.     {
  337.         return $this->interventions;
  338.     }
  340.     public function addIntervention(Intervention $intervention): static
  341.     {
  342.         if (!$this->interventions->contains($intervention)) {
  343.             $this->interventions->add($intervention);
  344.             $intervention->setNummachine($this);
  345.         }
  347.         return $this;
  348.     }
  350.     public function removeIntervention(Intervention $intervention): static
  351.     {
  352.         if ($this->interventions->removeElement($intervention)) {
  353.             // set the owning side to null (unless already changed)
  354.             if ($intervention->getNummachine() === $this) {
  355.                 $intervention->setNummachine(null);
  356.             }
  357.         }
  359.         return $this;
  360.     }
  362.     /**
  363.      * @return Collection<int, Historiqueintervention>
  364.      */
  365.     public function getHistoriqueinterventions(): Collection
  366.     {
  367.         return $this->historiqueinterventions;
  368.     }
  370.     public function addHistoriqueintervention(Historiqueintervention $historiqueintervention): static
  371.     {
  372.         if (!$this->historiqueinterventions->contains($historiqueintervention)) {
  373.             $this->historiqueinterventions->add($historiqueintervention);
  374.             $historiqueintervention->setNummachine($this);
  375.         }
  377.         return $this;
  378.     }
  380.     public function removeHistoriqueintervention(Historiqueintervention $historiqueintervention): static
  381.     {
  382.         if ($this->historiqueinterventions->removeElement($historiqueintervention)) {
  383.             // set the owning side to null (unless already changed)
  384.             if ($historiqueintervention->getNummachine() === $this) {
  385.                 $historiqueintervention->setNummachine(null);
  386.             }
  387.         }
  389.         return $this;
  390.     }
  392.     public function getNum(): ?string
  393.     {
  394.         return $this->num;
  395.     }
  397.     public function setNum(?string $num): self
  398.     {
  399.         $this->num = $num;
  401.         return $this;
  402.     }
  404.     /**
  405.      * @return Collection<int, MachineIntervention>
  406.      */
  407.     public function getMachineInterventions(): Collection
  408.     {
  409.         return $this->machineInterventions;
  410.     }
  412.     public function addMachineIntervention(MachineIntervention $machineIntervention): self
  413.     {
  414.         if (!$this->machineInterventions->contains($machineIntervention)) {
  415.             $this->machineInterventions->add($machineIntervention);
  416.             $machineIntervention->setMachine($this);
  417.         }
  419.         return $this;
  420.     }
  422.     public function removeMachineIntervention(MachineIntervention $machineIntervention): self
  423.     {
  424.         if ($this->machineInterventions->removeElement($machineIntervention)) {
  425.             // set the owning side to null (unless already changed)
  426.             if ($machineIntervention->getMachine() === $this) {
  427.                 $machineIntervention->setMachine(null);
  428.             }
  429.         }
  431.         return $this;
  432.     }
  438. }