src/Entity/Comun/Proyecto.php line 18

Open in your IDE?
  1. <?php
  3. namespace App\Entity\Comun;
  5. use App\Entity\Accion\ProyectoReunion;
  6. use App\Entity\Admin\Area;
  7. use App\Entity\Admin\Cliente;
  8. use App\Entity\Admin\Empleada;
  9. use App\Entity\Admin\Servicio;
  10. use App\Repository\Comun\ProyectoRepository;
  11. use Doctrine\Common\Collections\ArrayCollection;
  12. use Doctrine\Common\Collections\Collection;
  13. use Doctrine\ORM\Mapping as ORM;
  14. use App\Entity\Accesos\Tercero;
  15. use App\Entity\Comun\Justificacion;
  16. use App\Entity\Comun\Gasto;
  17. #[ORM\Entity(repositoryClass: ProyectoRepository::class)]
  18. class Proyecto
  19. {
  20.     #[ORM\Id]
  21.     #[ORM\GeneratedValue]
  22.     #[ORM\Column(type: 'integer')]
  23.     private $id;
  25.     #[ORM\Column(type: 'string', length: 255)]
  26.     private $nombre;
  28.     #[ORM\Column(type: 'date')]
  29.     private $fechaInicio;
  31.     #[ORM\ManyToOne(targetEntity: Cliente::class, inversedBy: 'proyectos')]
  32.     #[ORM\JoinColumn(nullable: false)]
  33.     private $cliente;
  35.     #[ORM\Column(type: 'float')]
  36.     private $financiacion;
  38.     
  39.     #[ORM\ManyToOne(targetEntity: Area::class, inversedBy: 'proyectos')]
  40.     #[ORM\JoinColumn(nullable: false)]
  41.     private $area;
  43.     #[ORM\ManyToOne(targetEntity: Servicio::class, inversedBy: 'proyectos')]
  44.     #[ORM\JoinColumn(nullable: false)]
  45.     private $servicio;
  47.     #[ORM\ManyToOne(targetEntity: Empleada::class, inversedBy: 'proyectos')]
  48.     #[ORM\JoinColumn(nullable: false)]
  49.     private $responsable;
  51.     #[ORM\ManyToOne(targetEntity: self::class, inversedBy: 'proyectos')]
  52.     private $padre;
  54.     #[ORM\OneToMany(mappedBy: 'padre', targetEntity: self::class)]
  55.     private $proyectos;
  57.     #[ORM\OneToMany(mappedBy: 'proyecto', targetEntity: Tarea::class)]
  58.     private $tareas;
  59.     
  60.     #[ORM\OneToMany(mappedBy: 'proyecto', targetEntity: Tercero::class)]
  61.     private $terceros;
  63.     #[ORM\Column(type: 'boolean')]
  64.     private $multiple;
  66.     #[ORM\OneToMany(mappedBy: 'proyecto', targetEntity: Justificacion::class)]
  67.     private $justificacions;
  69.     #[ORM\OneToMany(mappedBy: 'proyecto', targetEntity: Convenio::class)]
  70.     private $convenios;
  72.     #[ORM\OneToMany(mappedBy: 'proyecto', targetEntity: Gasto::class)]
  73.     private $gastos;
  75.     #[ORM\OneToMany(mappedBy: 'proyecto', targetEntity: Fichaje::class)]
  76.     private $fichajes;
  78.     #[ORM\OneToMany(mappedBy: 'proyecto', targetEntity: ProyectoReunion::class)]
  79.     private $observaciones;
  81.     #[ORM\Column(type: 'integer')]
  82.     private $estado;
  84.     public function __construct()
  85.     {
  86.         $this->proyectos = new ArrayCollection();
  87.         $this->tareas = new ArrayCollection();
  88.         $this->justificacions = new ArrayCollection();
  89.         $this->convenios = new ArrayCollection();
  90.         $this->gastos = new ArrayCollection();
  91.         $this->fichajes = new ArrayCollection();
  92.         $this->observaciones = new ArrayCollection();
  93.     }
  96.     public function getId(): ?int
  97.     {
  98.         return $this->id;
  99.     }
  101.     public function getNombre(): ?string
  102.     {
  103.         return $this->nombre;
  104.     }
  106.     public function setNombre(string $nombre): self
  107.     {
  108.         $this->nombre = $nombre;
  110.         return $this;
  111.     }
  113.     public function getFechaInicio(): ?\DateTimeInterface
  114.     {
  115.         return $this->fechaInicio;
  116.     }
  118.     public function setFechaInicio(\DateTimeInterface $fechaInicio): self
  119.     {
  120.         $this->fechaInicio = $fechaInicio;
  122.         return $this;
  123.     }
  125.     public function getCliente(): ?Cliente
  126.     {
  127.         return $this->cliente;
  128.     }
  130.     public function setCliente(?Cliente $cliente): self
  131.     {
  132.         $this->cliente = $cliente;
  134.         return $this;
  135.     }
  137.     public function getFinanciacion(): ?float
  138.     {
  139.         return $this->financiacion;
  140.     }
  142.     public function setFinanciacion(float $financiacion): self
  143.     {
  144.         $this->financiacion = $financiacion;
  146.         return $this;
  147.     }
  149.     public function getArea(): ?Area
  150.     {
  151.         return $this->area;
  152.     }
  154.     public function setArea(?Area $area): self
  155.     {
  156.         $this->area = $area;
  158.         return $this;
  159.     }
  161.     public function getServicio(): ?Servicio
  162.     {
  163.         return $this->servicio;
  164.     }
  166.     public function setServicio(?Servicio $servicio): self
  167.     {
  168.         $this->servicio = $servicio;
  170.         return $this;
  171.     }
  173.     public function getResponsable(): ?Empleada
  174.     {
  175.         return $this->responsable;
  176.     }
  178.     public function setResponsable(?Empleada $responsable): self
  179.     {
  180.         $this->responsable = $responsable;
  182.         return $this;
  183.     }
  185.     public function getPadre(): ?self
  186.     {
  187.         return $this->padre;
  188.     }
  190.     public function setPadre(?self $padre): self
  191.     {
  192.         $this->padre = $padre;
  194.         return $this;
  195.     }
  197.     /**
  198.      * @return Collection<int, self>
  199.      */
  200.     public function getProyectos(): Collection
  201.     {
  202.         return $this->proyectos;
  203.     }
  205.     public function addProyecto(self $proyecto): self
  206.     {
  207.         if (!$this->proyectos->contains($proyecto)) {
  208.             $this->proyectos[] = $proyecto;
  209.             $proyecto->setPadre($this);
  210.         }
  212.         return $this;
  213.     }
  215.     public function removeProyecto(self $proyecto): self
  216.     {
  217.         if ($this->proyectos->removeElement($proyecto)) {
  218.             // set the owning side to null (unless already changed)
  219.             if ($proyecto->getPadre() === $this) {
  220.                 $proyecto->setPadre(null);
  221.             }
  222.         }
  224.         return $this;
  225.     }
  227.     /**
  228.      * @return Collection<int, Tarea>
  229.      */
  230.     public function getTareas(): Collection
  231.     {
  232.         return $this->tareas;
  233.     }
  235.     public function addTarea(Tarea $tarea): self
  236.     {
  237.         if (!$this->tareas->contains($tarea)) {
  238.             $this->tareas[] = $tarea;
  239.             $tarea->setProyecto($this);
  240.         }
  242.         return $this;
  243.     }
  245.     public function removeTarea(Tarea $tarea): self
  246.     {
  247.         if ($this->tareas->removeElement($tarea)) {
  248.             // set the owning side to null (unless already changed)
  249.             if ($tarea->getProyecto() === $this) {
  250.                 $tarea->setProyecto(null);
  251.             }
  252.         }
  254.         return $this;
  255.     }
  257.     public function getMultiple(): ?bool
  258.     {
  259.         return $this->multiple;
  260.     }
  262.     public function setMultiple(bool $multiple): self
  263.     {
  264.         $this->multiple = $multiple;
  266.         return $this;
  267.     }
  269.     /**
  270.      * @return Collection<int, Justificacion>
  271.      */
  272.     public function getJustificacions(): Collection
  273.     {
  274.         return $this->justificacions;
  275.     }
  277.     public function addJustificacion(Justificacion $justificacion): self
  278.     {
  279.         if (!$this->justificacions->contains($justificacion)) {
  280.             $this->justificacions[] = $justificacion;
  281.             $justificacion->setProyecto($this);
  282.         }
  284.         return $this;
  285.     }
  287.     public function removeJustificacion(Justificacion $justificacion): self
  288.     {
  289.         if ($this->justificacions->removeElement($justificacion)) {
  290.             // set the owning side to null (unless already changed)
  291.             if ($justificacion->getProyecto() === $this) {
  292.                 $justificacion->setProyecto(null);
  293.             }
  294.         }
  296.         return $this;
  297.     }
  299.     /**
  300.      * @return Collection<int, Convenio>
  301.      */
  302.     public function getConvenios(): Collection
  303.     {
  304.         return $this->convenios;
  305.     }
  307.     public function addConvenio(Convenio $convenio): self
  308.     {
  309.         if (!$this->convenios->contains($convenio)) {
  310.             $this->convenios[] = $convenio;
  311.             $convenio->setProyecto($this);
  312.         }
  314.         return $this;
  315.     }
  317.     public function removeConvenio(Convenio $convenio): self
  318.     {
  319.         if ($this->convenios->removeElement($convenio)) {
  320.             // set the owning side to null (unless already changed)
  321.             if ($convenio->getProyecto() === $this) {
  322.                 $convenio->setProyecto(null);
  323.             }
  324.         }
  326.         return $this;
  327.     }
  329.     /**
  330.      * @return Collection<int, Gasto>
  331.      */
  332.     public function getGastos(): Collection
  333.     {
  334.         return $this->gastos;
  335.     }
  337.     public function addGasto(Gasto $gasto): self
  338.     {
  339.         if (!$this->gastos->contains($gasto)) {
  340.             $this->gastos[] = $gasto;
  341.             $gasto->setProyecto($this);
  342.         }
  344.         return $this;
  345.     }
  347.     public function removeGasto(Gasto $gasto): self
  348.     {
  349.         if ($this->gastos->removeElement($gasto)) {
  350.             // set the owning side to null (unless already changed)
  351.             if ($gasto->getProyecto() === $this) {
  352.                 $gasto->setProyecto(null);
  353.             }
  354.         }
  356.         return $this;
  357.     }
  359.     /**
  360.      * @return Collection<int, Fichaje>
  361.      */
  362.     public function getFichajes(): Collection
  363.     {
  364.         return $this->fichajes;
  365.     }
  367.     public function addFichaje(Fichaje $fichaje): self
  368.     {
  369.         if (!$this->fichajes->contains($fichaje)) {
  370.             $this->fichajes[] = $fichaje;
  371.             $fichaje->setProyecto($this);
  372.         }
  374.         return $this;
  375.     }
  377.     public function removeFichaje(Fichaje $fichaje): self
  378.     {
  379.         if ($this->fichajes->removeElement($fichaje)) {
  380.             // set the owning side to null (unless already changed)
  381.             if ($fichaje->getProyecto() === $this) {
  382.                 $fichaje->setProyecto(null);
  383.             }
  384.         }
  386.         return $this;
  387.     }
  390.     public function __toString() {
  391.         return $this->nombre;
  392.     }
  393.     
  394.     public function getTerceros() {
  395.         return $this->terceros;
  396.     }
  398.     public function setTerceros($terceros): void {
  399.         $this->terceros = $terceros;
  400.     }
  402.   
  404.     public function addTercero(Tercero $tercero): self
  405.     {
  406.         if (!$this->terceros->contains($tercero)) {
  407.             $this->terceros[] = $tercero;
  408.             $tercero->setProyecto($this);
  409.         }
  411.         return $this;
  412.     }
  414.     public function removeTercero(Tercero $tercero): self
  415.     {
  416.         if ($this->terceros->removeElement($tercero)) {
  417.             // set the owning side to null (unless already changed)
  418.             if ($tercero->getProyecto() === $this) {
  419.                 $tercero->setProyecto(null);
  420.             }
  421.         }
  423.         return $this;
  424.     }
  426.     /**
  427.      * @return Collection<int, ProyectoReunion>
  428.      */
  429.     public function getObservaciones(): Collection
  430.     {
  431.         return $this->observaciones;
  432.     }
  434.     public function addObservacione(ProyectoReunion $observacione): self
  435.     {
  436.         if (!$this->observaciones->contains($observacione)) {
  437.             $this->observaciones[] = $observacione;
  438.             $observacione->setProyecto($this);
  439.         }
  441.         return $this;
  442.     }
  444.     public function removeObservacione(ProyectoReunion $observacione): self
  445.     {
  446.         if ($this->observaciones->removeElement($observacione)) {
  447.             // set the owning side to null (unless already changed)
  448.             if ($observacione->getProyecto() === $this) {
  449.                 $observacione->setProyecto(null);
  450.             }
  451.         }
  453.         return $this;
  454.     }
  456.     public function getEstado(): ?int
  457.     {
  458.         return $this->estado;
  459.     }
  461.     public function setEstado(int $estado): self
  462.     {
  463.         $this->estado = $estado;
  465.         return $this;
  466.     }
  467.     
  468.     public  function estadoToString(){
  469.         if($this->estado==0){
  470.             return "proyecto.sinIniciar";
  471.         }
  472.         if($this->estado==1){
  473.             return "proyecto.iniciado";
  474.         }
  475.         if($this->estado==2){
  476.             return "proyecto.finalizado";
  477.         }
  478.     }
  479.     
  480.     public function getGastado(){
  481.         $gastos= $this->gastos;
  482.         $convenios= $this->convenios;
  483.         $gastado=0;
  484.         foreach($gastos as $gasto){
  485.             $gastado+=$gasto->getCantidad();
  486.         }
  487.         foreach ($convenios as $convenio){
  488.             $gastado+=$convenio->getCantidad();
  489.         }
  490.         
  491.         return $gastado;
  492.     }
  494.     public function getRestante(){
  495.         return $this->financiacion-$this->getGastado();
  496.     }
  498. }