src/Entity/Conductor.php line 17

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\ConductorRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Symfony\Component\Validator\Constraints as Assert;
  10. use Symfony\Component\HttpFoundation\File\File;
  11. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  13. /**
  14.  * @ORM\Entity(repositoryClass=ConductorRepository::class)
  15.  * @Vich\Uploadable
  16.  */
  17. class Conductor
  18. {
  19.     /**
  20.      * @ORM\Id
  21.      * @ORM\GeneratedValue
  22.      * @ORM\Column(type="integer")
  23.      */
  24.     private $id;
  26.     /**
  27.      * @ORM\Column(type="string", length=255)
  28.      */
  29.     private $nombre;
  31.     /**
  32.      * @ORM\Column(type="string", length=255)
  33.      */
  34.     private $rut;
  36.     /**
  37.      * @ORM\Column(type="string", length=255, nullable=true)
  38.      */
  39.     private $telefono;
  41.     /**
  42.      * @ORM\Column(type="boolean")
  43.      */
  44.     private $activo;
  46.     /**
  47.      * @ORM\ManyToMany(targetEntity=LicenciaConducir::class)
  48.      */
  49.     private $licenciaConducir;
  51.     /**
  52.      * @ORM\Column(type="date", nullable=true)
  53.      */
  54.     private $fechaVencimientoLicencia;
  56.     /**
  57.      * @ORM\OneToMany(targetEntity=Ruta::class, mappedBy="conductor")
  58.      */
  59.     private $rutas;
  61.     /**
  62.      * @ORM\Column(type="datetime", nullable=true)
  63.      */
  64.     private $fechaActualizacion;
  66.     /**
  67.      * @ORM\Column(type="string", length=255, nullable=true)
  68.      */
  69.     private $documentoName;
  71.     /**
  72.      * NOTE: This is not a mapped field of entity metadata, just a simple property.
  73.      * @Assert\File(
  74.      *     maxSize = "200Mi",
  75.      *     mimeTypes={ "image/*" }
  76.      * )
  77.      * @Vich\UploadableField(mapping="conductores_foto", fileNameProperty="documentoName")
  78.      * @var File
  79.      */
  80.     private $documentoFile;
  82.     /**
  83.      * @ORM\OneToMany(targetEntity=Vehiculo::class, mappedBy="conductor")
  84.      */
  85.     private $vehiculos;
  87.     /**
  88.      * @ORM\Column(type="text", nullable=true)
  89.      */
  90.     private $observaciones;
  92.     /**
  93.      * @ORM\OneToMany(targetEntity=DocumentoConductor::class, mappedBy="conductor")
  94.      */
  95.     private $documentoConductors;
  97.     /**
  98.      * @ORM\Column(type="integer", nullable=true)
  99.      */
  100.     private $telefonoContactoAnexo;
  102.     /**
  103.      * @ORM\Column(type="string", length=255, nullable=true)
  104.      */
  105.     private $contactoEmergencia;
  107.     /**
  108.      * @ORM\Column(type="boolean", nullable=true)
  109.      */
  110.     private $examenFisico;
  112.     /**
  113.      * @ORM\Column(type="datetime", nullable=true)
  114.      */
  115.     private $examenFisicoVencimiento;
  117.     /**
  118.      * @ORM\Column(type="boolean", nullable=true)
  119.      */
  120.     private $testDrogas;
  122.     /**
  123.      * @ORM\Column(type="datetime", nullable=true)
  124.      */
  125.     private $testDrogasVencimiento;
  127.     /**
  128.      * @ORM\Column(type="datetime", nullable=true)
  129.      */
  130.     private $fechaNotificacionLicencia;
  132.     /**
  133.      * @ORM\Column(type="datetime", nullable=true)
  134.      */
  135.     private $fechaNotificacionExamenFisico;
  137.     /**
  138.      * @ORM\Column(type="datetime", nullable=true)
  139.      */
  140.     private $fechaNotificacionTestDrogas;
  142.     public function getDocumentoNameOriginal()
  143.     {
  144.         $docName = $this->getDocumentoName();
  145.         if($docName)
  146.         {
  147.             $posName = strrpos($docName, '-');
  148.             $posExt = strrpos($docName, '.');
  149.             if($posName && $posExt)
  150.             {
  151.                 $name = substr($docName, 0, $posName);
  152.                 $ext = substr($docName, $posExt);
  153.                 return $name.$ext;
  154.             }
  155.         }
  156.         return $docName;
  157.     }
  158.     
  159.     /**
  160.      * If manually uploading a file (i.e. not using Symfony Form) ensure an instance
  161.      * of 'UploadedFile' is injected into this setter to trigger the  update. If this
  162.      * bundle's configuration parameter 'inject_on_load' is set to 'true' this setter
  163.      * must be able to accept an instance of 'File' as the bundle will inject one here
  164.      * during Doctrine hydration.
  165.      *
  166.      * @param File|\Symfony\Component\HttpFoundation\File\UploadedFile $documento
  167.      *
  168.      * @return Product
  169.      */
  170.     public function setDocumentoFile(?File $documento = null): void
  171.     {
  172.         $this->documentoFile = $documento;
  174.         if ($documento) {
  175.             // It is required that at least one field changes if you are using doctrine
  176.             // otherwise the event listeners won't be called and the file is lost
  177.             $this->fechaActualizacion = new \DateTimeImmutable(null);
  178.         }
  179.     }
  181.     /**
  182.      * @return File|null
  183.      */
  184.     public function getDocumentoFile(): ?File
  185.     {
  186.         return $this->documentoFile;
  187.     }
  189.     public function getDocumentoName(): ?string
  190.     {
  191.         return $this->documentoName;
  192.     }
  194.     public function setDocumentoName(?string $documentoName = ""): self
  195.     {
  196.         $this->documentoName = $documentoName;
  198.         return $this;
  199.     }
  202.     public function __construct()
  203.     {
  204.         $this->licenciaConducir = new ArrayCollection();
  205.         $this->rutas = new ArrayCollection();
  206.         $this->vehiculos = new ArrayCollection();
  207.         $this->documentoConductors = new ArrayCollection();
  208.     }
  210.     public function __toString() 
  211.     {
  212.         return $this->nombre;
  213.     }
  215.     public function getId(): ?int
  216.     {
  217.         return $this->id;
  218.     }
  220.     public function getNombre(): ?string
  221.     {
  222.         return $this->nombre;
  223.     }
  225.     public function setNombre(string $nombre): self
  226.     {
  227.         $this->nombre = $nombre;
  229.         return $this;
  230.     }
  232.     public function getRut(): ?string
  233.     {
  234.         return $this->rut;
  235.     }
  237.     public function setRut(string $rut): self
  238.     {
  239.         $this->rut = $rut;
  241.         return $this;
  242.     }
  244.     public function getTelefono(): ?string
  245.     {
  246.         return $this->telefono;
  247.     }
  249.     public function setTelefono(?string $telefono): self
  250.     {
  251.         $this->telefono = $telefono;
  253.         return $this;
  254.     }
  256.     public function getActivo(): ?bool
  257.     {
  258.         return $this->activo;
  259.     }
  261.     public function setActivo(bool $activo): self
  262.     {
  263.         $this->activo = $activo;
  265.         return $this;
  266.     }
  268.     /**
  269.      * @return Collection|LicenciaConducir[]
  270.      */
  271.     public function getLicenciaConducir(): Collection
  272.     {
  273.         return $this->licenciaConducir;
  274.     }
  276.     public function addLicenciaConducir(LicenciaConducir $licenciaConducir): self
  277.     {
  278.         if (!$this->licenciaConducir->contains($licenciaConducir)) {
  279.             $this->licenciaConducir[] = $licenciaConducir;
  280.         }
  282.         return $this;
  283.     }
  285.     public function removeLicenciaConducir(LicenciaConducir $licenciaConducir): self
  286.     {
  287.         if ($this->licenciaConducir->contains($licenciaConducir)) {
  288.             $this->licenciaConducir->removeElement($licenciaConducir);
  289.         }
  291.         return $this;
  292.     }
  294.     public function getFechaVencimientoLicencia(): ?\DateTimeInterface
  295.     {
  296.         return $this->fechaVencimientoLicencia;
  297.     }
  299.     public function setFechaVencimientoLicencia(?\DateTimeInterface $fechaVencimientoLicencia): self
  300.     {
  301.         $this->fechaVencimientoLicencia = $fechaVencimientoLicencia;
  303.         return $this;
  304.     }
  306.     /**
  307.      * @return Collection|Ruta[]
  308.      */
  309.     public function getRutas(): Collection
  310.     {
  311.         return $this->rutas;
  312.     }
  314.     public function addRuta(Ruta $ruta): self
  315.     {
  316.         if (!$this->rutas->contains($ruta)) {
  317.             $this->rutas[] = $ruta;
  318.             $ruta->setConductor($this);
  319.         }
  321.         return $this;
  322.     }
  324.     public function removeRuta(Ruta $ruta): self
  325.     {
  326.         if ($this->rutas->contains($ruta)) {
  327.             $this->rutas->removeElement($ruta);
  328.             // set the owning side to null (unless already changed)
  329.             if ($ruta->getConductor() === $this) {
  330.                 $ruta->setConductor(null);
  331.             }
  332.         }
  334.         return $this;
  335.     }
  337.     public function getVehiculo(): ?Vehiculo
  338.     {
  339.         return $this->vehiculo;
  340.     }
  342.     public function setVehiculo(?Vehiculo $vehiculo): self
  343.     {
  344.         $this->vehiculo = $vehiculo;
  346.         // set (or unset) the owning side of the relation if necessary
  347.         $newConductor = null === $vehiculo ? null : $this;
  348.         if ($vehiculo->getConductor() !== $newConductor) {
  349.             $vehiculo->setConductor($newConductor);
  350.         }
  352.         return $this;
  353.     }
  355.     /**
  356.      * @return Collection|Vehiculo[]
  357.      */
  358.     public function getVehiculos(): Collection
  359.     {
  360.         return $this->vehiculos;
  361.     }
  363.     public function addVehiculo(Vehiculo $vehiculo): self
  364.     {
  365.         if (!$this->vehiculos->contains($vehiculo)) {
  366.             $this->vehiculos[] = $vehiculo;
  367.             $vehiculo->setConductor($this);
  368.         }
  370.         return $this;
  371.     }
  373.     public function removeVehiculo(Vehiculo $vehiculo): self
  374.     {
  375.         if ($this->vehiculos->contains($vehiculo)) {
  376.             $this->vehiculos->removeElement($vehiculo);
  377.             // set the owning side to null (unless already changed)
  378.             if ($vehiculo->getConductor() === $this) {
  379.                 $vehiculo->setConductor(null);
  380.             }
  381.         }
  383.         return $this;
  384.     }
  386.     public function getObservaciones(): ?string
  387.     {
  388.         return $this->observaciones;
  389.     }
  391.     public function setObservaciones(?string $observaciones): self
  392.     {
  393.         $this->observaciones = $observaciones;
  395.         return $this;
  396.     }
  398.     /**
  399.      * @return Collection|DocumentoConductor[]
  400.      */
  401.     public function getDocumentoConductors(): Collection
  402.     {
  403.         return $this->documentoConductors;
  404.     }
  406.     public function addDocumentoConductor(DocumentoConductor $documentoConductor): self
  407.     {
  408.         if (!$this->documentoConductors->contains($documentoConductor)) {
  409.             $this->documentoConductors[] = $documentoConductor;
  410.             $documentoConductor->setConductor($this);
  411.         }
  413.         return $this;
  414.     }
  416.     public function removeDocumentoConductor(DocumentoConductor $documentoConductor): self
  417.     {
  418.         if ($this->documentoConductors->contains($documentoConductor)) {
  419.             $this->documentoConductors->removeElement($documentoConductor);
  420.             // set the owning side to null (unless already changed)
  421.             if ($documentoConductor->getConductor() === $this) {
  422.                 $documentoConductor->setConductor(null);
  423.             }
  424.         }
  426.         return $this;
  427.     }
  429.     public function getTelefonoContactoAnexo(): ?int
  430.     {
  431.         return $this->telefonoContactoAnexo;
  432.     }
  434.     public function setTelefonoContactoAnexo(?int $telefonoContactoAnexo): self
  435.     {
  436.         $this->telefonoContactoAnexo = $telefonoContactoAnexo;
  438.         return $this;
  439.     }
  441.     public function getContactoEmergencia(): ?string
  442.     {
  443.         return $this->contactoEmergencia;
  444.     }
  446.     public function setContactoEmergencia(?string $contactoEmergencia): self
  447.     {
  448.         $this->contactoEmergencia = $contactoEmergencia;
  450.         return $this;
  451.     }
  453.     public function getExamenFisico(): ?bool
  454.     {
  455.         return $this->examenFisico;
  456.     }
  458.     public function setExamenFisico(?bool $examenFisico): self
  459.     {
  460.         $this->examenFisico = $examenFisico;
  462.         return $this;
  463.     }
  465.     public function getExamenFisicoVencimiento(): ?\DateTimeInterface
  466.     {
  467.         return $this->examenFisicoVencimiento;
  468.     }
  470.     public function setExamenFisicoVencimiento(?\DateTimeInterface $examenFisicoVencimiento): self
  471.     {
  472.         $this->examenFisicoVencimiento = $examenFisicoVencimiento;
  474.         return $this;
  475.     }
  477.     public function getTestDrogas(): ?bool
  478.     {
  479.         return $this->testDrogas;
  480.     }
  482.     public function setTestDrogas(?bool $testDrogas): self
  483.     {
  484.         $this->testDrogas = $testDrogas;
  486.         return $this;
  487.     }
  489.     public function getTestDrogasVencimiento(): ?\DateTimeInterface
  490.     {
  491.         return $this->testDrogasVencimiento;
  492.     }
  494.     public function setTestDrogasVencimiento(?\DateTimeInterface $testDrogasVencimiento): self
  495.     {
  496.         $this->testDrogasVencimiento = $testDrogasVencimiento;
  498.         return $this;
  499.     }
  501.     public function getFechaNotificacionLicencia(): ?\DateTimeInterface
  502.     {
  503.         return $this->fechaNotificacionLicencia;
  504.     }
  506.     public function setFechaNotificacionLicencia(?\DateTimeInterface $fechaNotificacionLicencia): self
  507.     {
  508.         $this->fechaNotificacionLicencia = $fechaNotificacionLicencia;
  510.         return $this;
  511.     }
  513.     public function getFechaNotificacionExamenFisico(): ?\DateTimeInterface
  514.     {
  515.         return $this->fechaNotificacionExamenFisico;
  516.     }
  518.     public function setFechaNotificacionExamenFisico(?\DateTimeInterface $fechaNotificacionExamenFisico): self
  519.     {
  520.         $this->fechaNotificacionExamenFisico = $fechaNotificacionExamenFisico;
  522.         return $this;
  523.     }
  525.     public function getFechaNotificacionTestDrogas(): ?\DateTimeInterface
  526.     {
  527.         return $this->fechaNotificacionTestDrogas;
  528.     }
  530.     public function setFechaNotificacionTestDrogas(?\DateTimeInterface $fechaNotificacionTestDrogas): self
  531.     {
  532.         $this->fechaNotificacionTestDrogas = $fechaNotificacionTestDrogas;
  534.         return $this;
  535.     }
  537.    
  538. }