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.     #[ORM\OneToMany(mappedBy: 'proyecto', targetEntity: ProyectoEmpleada::class)]
  85.     private $proyectoEmpleadas;
  87.     #[ORM\Column(type: 'date')]
  88.     private $fechaFin;
  90.     public function __construct()
  91.     {
  92.         $this->proyectos = new ArrayCollection();
  93.         $this->tareas = new ArrayCollection();
  94.         $this->justificacions = new ArrayCollection();
  95.         $this->convenios = new ArrayCollection();
  96.         $this->gastos = new ArrayCollection();
  97.         $this->fichajes = new ArrayCollection();
  98.         $this->observaciones = new ArrayCollection();
  99.         $this->proyectoEmpleadas = new ArrayCollection();
  100.     }
  103.     public function getId(): ?int
  104.     {
  105.         return $this->id;
  106.     }
  108.     public function getNombre(): ?string
  109.     {
  110.         return $this->nombre;
  111.     }
  113.     public function setNombre(string $nombre): self
  114.     {
  115.         $this->nombre = $nombre;
  117.         return $this;
  118.     }
  120.     public function getFechaInicio(): ?\DateTimeInterface
  121.     {
  122.         return $this->fechaInicio;
  123.     }
  125.     public function setFechaInicio(\DateTimeInterface $fechaInicio): self
  126.     {
  127.         $this->fechaInicio = $fechaInicio;
  129.         return $this;
  130.     }
  132.     public function getCliente(): ?Cliente
  133.     {
  134.         return $this->cliente;
  135.     }
  137.     public function setCliente(?Cliente $cliente): self
  138.     {
  139.         $this->cliente = $cliente;
  141.         return $this;
  142.     }
  144.     public function getFinanciacion(): ?float
  145.     {
  146.         return $this->financiacion;
  147.     }
  149.     public function setFinanciacion(float $financiacion): self
  150.     {
  151.         $this->financiacion = $financiacion;
  153.         return $this;
  154.     }
  156.     public function getArea(): ?Area
  157.     {
  158.         return $this->area;
  159.     }
  161.     public function setArea(?Area $area): self
  162.     {
  163.         $this->area = $area;
  165.         return $this;
  166.     }
  168.     public function getServicio(): ?Servicio
  169.     {
  170.         return $this->servicio;
  171.     }
  173.     public function setServicio(?Servicio $servicio): self
  174.     {
  175.         $this->servicio = $servicio;
  177.         return $this;
  178.     }
  180.     public function getResponsable(): ?Empleada
  181.     {
  182.         return $this->responsable;
  183.     }
  185.     public function setResponsable(?Empleada $responsable): self
  186.     {
  187.         $this->responsable = $responsable;
  189.         return $this;
  190.     }
  192.     public function getPadre(): ?self
  193.     {
  194.         return $this->padre;
  195.     }
  197.     public function setPadre(?self $padre): self
  198.     {
  199.         $this->padre = $padre;
  201.         return $this;
  202.     }
  204.     /**
  205.      * @return Collection<int, self>
  206.      */
  207.     public function getProyectos(): Collection
  208.     {
  209.         return $this->proyectos;
  210.     }
  212.     public function addProyecto(self $proyecto): self
  213.     {
  214.         if (!$this->proyectos->contains($proyecto)) {
  215.             $this->proyectos[] = $proyecto;
  216.             $proyecto->setPadre($this);
  217.         }
  219.         return $this;
  220.     }
  222.     public function removeProyecto(self $proyecto): self
  223.     {
  224.         if ($this->proyectos->removeElement($proyecto)) {
  225.             // set the owning side to null (unless already changed)
  226.             if ($proyecto->getPadre() === $this) {
  227.                 $proyecto->setPadre(null);
  228.             }
  229.         }
  231.         return $this;
  232.     }
  234.     /**
  235.      * @return Collection<int, Tarea>
  236.      */
  237.     public function getTareas(): Collection
  238.     {
  239.         return $this->tareas;
  240.     }
  242.     public function addTarea(Tarea $tarea): self
  243.     {
  244.         if (!$this->tareas->contains($tarea)) {
  245.             $this->tareas[] = $tarea;
  246.             $tarea->setProyecto($this);
  247.         }
  249.         return $this;
  250.     }
  252.     public function removeTarea(Tarea $tarea): self
  253.     {
  254.         if ($this->tareas->removeElement($tarea)) {
  255.             // set the owning side to null (unless already changed)
  256.             if ($tarea->getProyecto() === $this) {
  257.                 $tarea->setProyecto(null);
  258.             }
  259.         }
  261.         return $this;
  262.     }
  264.     public function getMultiple(): ?bool
  265.     {
  266.         return $this->multiple;
  267.     }
  269.     public function setMultiple(bool $multiple): self
  270.     {
  271.         $this->multiple = $multiple;
  273.         return $this;
  274.     }
  276.     /**
  277.      * @return Collection<int, Justificacion>
  278.      */
  279.     public function getJustificacions(): Collection
  280.     {
  281.         return $this->justificacions;
  282.     }
  284.     public function addJustificacion(Justificacion $justificacion): self
  285.     {
  286.         if (!$this->justificacions->contains($justificacion)) {
  287.             $this->justificacions[] = $justificacion;
  288.             $justificacion->setProyecto($this);
  289.         }
  291.         return $this;
  292.     }
  294.     public function removeJustificacion(Justificacion $justificacion): self
  295.     {
  296.         if ($this->justificacions->removeElement($justificacion)) {
  297.             // set the owning side to null (unless already changed)
  298.             if ($justificacion->getProyecto() === $this) {
  299.                 $justificacion->setProyecto(null);
  300.             }
  301.         }
  303.         return $this;
  304.     }
  306.     /**
  307.      * @return Collection<int, Convenio>
  308.      */
  309.     public function getConvenios(): Collection
  310.     {
  311.         return $this->convenios;
  312.     }
  314.     public function addConvenio(Convenio $convenio): self
  315.     {
  316.         if (!$this->convenios->contains($convenio)) {
  317.             $this->convenios[] = $convenio;
  318.             $convenio->setProyecto($this);
  319.         }
  321.         return $this;
  322.     }
  324.     public function removeConvenio(Convenio $convenio): self
  325.     {
  326.         if ($this->convenios->removeElement($convenio)) {
  327.             // set the owning side to null (unless already changed)
  328.             if ($convenio->getProyecto() === $this) {
  329.                 $convenio->setProyecto(null);
  330.             }
  331.         }
  333.         return $this;
  334.     }
  336.     /**
  337.      * @return Collection<int, Gasto>
  338.      */
  339.     public function getGastos(): Collection
  340.     {
  341.         return $this->gastos;
  342.     }
  344.     public function addGasto(Gasto $gasto): self
  345.     {
  346.         if (!$this->gastos->contains($gasto)) {
  347.             $this->gastos[] = $gasto;
  348.             $gasto->setProyecto($this);
  349.         }
  351.         return $this;
  352.     }
  354.     public function removeGasto(Gasto $gasto): self
  355.     {
  356.         if ($this->gastos->removeElement($gasto)) {
  357.             // set the owning side to null (unless already changed)
  358.             if ($gasto->getProyecto() === $this) {
  359.                 $gasto->setProyecto(null);
  360.             }
  361.         }
  363.         return $this;
  364.     }
  366.     /**
  367.      * @return Collection<int, Fichaje>
  368.      */
  369.     public function getFichajes(): Collection
  370.     {
  371.         return $this->fichajes;
  372.     }
  374.     public function addFichaje(Fichaje $fichaje): self
  375.     {
  376.         if (!$this->fichajes->contains($fichaje)) {
  377.             $this->fichajes[] = $fichaje;
  378.             $fichaje->setProyecto($this);
  379.         }
  381.         return $this;
  382.     }
  384.     public function removeFichaje(Fichaje $fichaje): self
  385.     {
  386.         if ($this->fichajes->removeElement($fichaje)) {
  387.             // set the owning side to null (unless already changed)
  388.             if ($fichaje->getProyecto() === $this) {
  389.                 $fichaje->setProyecto(null);
  390.             }
  391.         }
  393.         return $this;
  394.     }
  397.     public function __toString() {
  398.         return $this->nombre;
  399.     }
  400.     
  401.     public function getTerceros() {
  402.         return $this->terceros;
  403.     }
  405.     public function setTerceros($terceros): void {
  406.         $this->terceros = $terceros;
  407.     }
  409.   
  411.     public function addTercero(Tercero $tercero): self
  412.     {
  413.         if (!$this->terceros->contains($tercero)) {
  414.             $this->terceros[] = $tercero;
  415.             $tercero->setProyecto($this);
  416.         }
  418.         return $this;
  419.     }
  421.     public function removeTercero(Tercero $tercero): self
  422.     {
  423.         if ($this->terceros->removeElement($tercero)) {
  424.             // set the owning side to null (unless already changed)
  425.             if ($tercero->getProyecto() === $this) {
  426.                 $tercero->setProyecto(null);
  427.             }
  428.         }
  430.         return $this;
  431.     }
  433.     /**
  434.      * @return Collection<int, ProyectoReunion>
  435.      */
  436.     public function getObservaciones(): Collection
  437.     {
  438.         return $this->observaciones;
  439.     }
  441.     public function addObservacione(ProyectoReunion $observacione): self
  442.     {
  443.         if (!$this->observaciones->contains($observacione)) {
  444.             $this->observaciones[] = $observacione;
  445.             $observacione->setProyecto($this);
  446.         }
  448.         return $this;
  449.     }
  451.     public function removeObservacione(ProyectoReunion $observacione): self
  452.     {
  453.         if ($this->observaciones->removeElement($observacione)) {
  454.             // set the owning side to null (unless already changed)
  455.             if ($observacione->getProyecto() === $this) {
  456.                 $observacione->setProyecto(null);
  457.             }
  458.         }
  460.         return $this;
  461.     }
  463.     public function getEstado(): ?int
  464.     {
  465.         return $this->estado;
  466.     }
  468.     public function setEstado(int $estado): self
  469.     {
  470.         $this->estado = $estado;
  472.         return $this;
  473.     }
  474.     
  475.     public  function estadoToString(){
  476.         if($this->estado==0){
  477.             return "proyecto.sinIniciar";
  478.         }
  479.         if($this->estado==1){
  480.             return "proyecto.iniciado";
  481.         }
  482.         if($this->estado==2){
  483.             return "proyecto.finalizado";
  484.         }
  485.     }
  486.     
  487.     public function getGastado(){
  488.         $gastos= $this->gastos;
  489.         $convenios= $this->convenios;
  490.         $gastado=0;
  491.         foreach($gastos as $gasto){
  492.             $gastado+=$gasto->getCantidad();
  493.         }
  494.         foreach ($convenios as $convenio){
  495.             $gastado+=$convenio->getCantidad();
  496.         }
  497.         
  498.         return $gastado;
  499.     }
  501.     public function getRestante(){
  502.         return $this->financiacion-$this->getGastado();
  503.     }
  505.     /**
  506.      * @return Collection<int, ProyectoEmpleada>
  507.      */
  508.     public function getProyectoEmpleadas(): Collection
  509.     {
  510.         return $this->proyectoEmpleadas;
  511.     }
  513.     public function addProyectoEmpleada(ProyectoEmpleada $proyectoEmpleada): self
  514.     {
  515.         if (!$this->proyectoEmpleadas->contains($proyectoEmpleada)) {
  516.             $this->proyectoEmpleadas[] = $proyectoEmpleada;
  517.             $proyectoEmpleada->setProyecto($this);
  518.         }
  520.         return $this;
  521.     }
  523.     public function removeProyectoEmpleada(ProyectoEmpleada $proyectoEmpleada): self
  524.     {
  525.         if ($this->proyectoEmpleadas->removeElement($proyectoEmpleada)) {
  526.             // set the owning side to null (unless already changed)
  527.             if ($proyectoEmpleada->getProyecto() === $this) {
  528.                 $proyectoEmpleada->setProyecto(null);
  529.             }
  530.         }
  532.         return $this;
  533.     }
  535.     public function getFechaFin(): ?\DateTimeInterface
  536.     {
  537.         return $this->fechaFin;
  538.     }
  540.     public function setFechaFin(\DateTimeInterface $fechaFin): self
  541.     {
  542.         $this->fechaFin = $fechaFin;
  544.         return $this;
  545.     }
  547. }