src/Controller/Mantenimiento/Preventivo/PlanMantenimientoDiagramadoController.php line 454

Open in your IDE?
  1. <?php
  3. namespace App\Controller\Mantenimiento\Preventivo;
  5. use App\Entity\Equipos\Maquinaria;
  6. use App\Entity\Mantenimiento\Preventivo\PlanMantenimientoDiagramado;
  7. use App\Form\Mantenimiento\Preventivo\PlanMantenimientoDiagramadoType;
  8. use App\Repository\Mantenimiento\Preventivo\PlanMantenimientoDiagramadoRepository;
  9. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  10. use Symfony\Component\HttpFoundation\Request;
  11. use Symfony\Component\HttpFoundation\Response;
  12. use Symfony\Component\Routing\Annotation\Route;
  13. use Doctrine\ORM\EntityRepository;
  14. use Symfony\Bridge\Doctrine\Form\Type\EntityType;
  15. use Symfony\Component\Form\Extension\Core\Type\SubmitType;
  16. use App\Repository\Mantenimiento\Preventivo\PlanMantenimientoRepository;
  17. use App\Entity\Mantenimiento\Preventivo\PlanMantenimiento;
  18. use App\Entity\Equipos\Maquinaria as Equipo;
  19. use App\Entity\Mantenimiento\Departamento;
  20. use App\Entity\Mantenimiento\PedidoReparacion;
  21. use App\Entity\Mantenimiento\Preventivo\TareaPlan;
  22. use App\Entity\Mantenimiento\Preventivo\TareaPlanDiagramada;
  23. use Doctrine\ORM\EntityManagerInterface;
  24. use Symfony\Component\Form\Extension\Core\Type\DateType;
  25. use Symfony\Component\HttpFoundation\JsonResponse;
  26. use Knp\Snappy\Pdf;
  27. use Knp\Bundle\SnappyBundle\Snappy\Response\PdfResponse;
  28. use Twig\Environment;
  31. /**
  32.  * @Route("/mantenimiento/preventivo/plan/diagramado")
  33.  */
  35. class PlanMantenimientoDiagramadoController extends AbstractController
  36. {
  38.      private $twig;
  39.     private $pdf;
  41.     public function __construct(Environment $twig, Pdf $pdf)
  42.     {
  43.         $this->twig = $twig;
  44.         $this->pdf = $pdf;
  45.     }
  48.     private function getFormFechas()
  49.     {
  50.         return $this->createFormBuilder()
  51.                     ->add('desde', 
  52.                            DateType::class, 
  53.                            [
  54.                                 'widget' => 'single_text',
  55.                                 'required' => false,
  56.                                 'attr' => ['class' => 'form-control'],
  57.                             ])
  58.                     ->add('hasta', 
  59.                            DateType::class, 
  60.                            [
  61.                                 'widget' => 'single_text',
  62.                                 'required' => false,
  63.                                 'attr' => ['class' => 'form-control'],
  64.                             ])
  65.                      ->getForm();
  66.     }
  71.     private function getFormSelectPeriodo()
  72.     {
  73.         return $this->createFormBuilder()
  75.                     ->add('periodo', \Symfony\Component\Form\Extension\Core\Type\ChoiceType::class, [
  76.                         'choices' => [
  77.                             'Semanal' => 7,
  78.                             'Mensual' => 30,
  79.                             'Semestral' => 180,
  80.                             'Anual' => 365,
  81.                         ],
  82.                         'attr' => ['class' => 'form-control form-select'],
  83.                     ])
  84.                     ->add('submit', 
  85.                           SubmitType::class, [
  86.                                                 'label' => 'Cargar Planes',
  87.                                                 'attr' => ['class' => 'btn btn-primary mt-4']
  88.                                                 ])
  89.                      ->getForm();
  90.     }
  92.     private function getFormSelectEquipo()
  93.     {
  94.         return $this->createFormBuilder()
  95.                     ->add('equipo', 
  96.                            EntityType::class, 
  97.                            [
  98.                                 'class' => Maquinaria::class,
  99.                                 'query_builder' => function (EntityRepository $er) {
  100.                                                                                         return $er->createQueryBuilder('u')
  101.                                                                                                   ->andWhere('u.activo = :activo')
  102.                                                                                                   ->setParameter('activo', true)
  103.                                                                                                   ->orderBy('u.nombre', 'ASC');
  104.                                                                                     },
  105.                                 'group_by' => function($choice, $key, $value) {
  106.                                                                                     if ($choice && $choice->getSector()) 
  107.                                                                                     {
  108.                                                                                         return $choice->getSector() . '';
  109.                                                                                     }
  111.                                                                                     return 'Sin sector';
  112.                                                                                 },
  113.                             ])
  114.                      ->getForm();
  115.     }
  117.     /**
  118.      * @Route("/informe", name="app_mantenimiento_preventivo_plan_mantenimiento_diagramado_informe", methods={"GET", "POST"})
  119.      */
  120.     public function informePlanesRealizados(Request $request, PlanMantenimientoDiagramadoRepository $planMantenimientoRepository, EntityManagerInterface $em): Response
  121.     {   
  122.         $form = $this->createFormBuilder()
  123.                     ->add('desde', 
  124.                            DateType::class, 
  125.                            [
  126.                                 'widget' => 'single_text',
  127.                                 'required' => false,
  128.                                 'attr' => ['class' => 'form-control'],
  129.                             ])
  130.                     ->add('hasta', 
  131.                            DateType::class, 
  132.                            [
  133.                                 'widget' => 'single_text',
  134.                                 'required' => false,
  135.                                 'attr' => ['class' => 'form-control'],
  136.                             ])
  137.                     ->add('equipo', 
  138.                            EntityType::class, 
  139.                            [
  140.                                 'class' => Maquinaria::class,
  141.                                 'required' => false,
  142.                                 'placeholder' => 'Todos los equipos',
  143.                                 'query_builder' => function (EntityRepository $er) {
  144.                                                                                         return $er->createQueryBuilder('u')
  145.                                                                                                   ->andWhere('u.activo = :activo')
  146.                                                                                                   ->setParameter('activo', true)
  147.                                                                                                   ->orderBy('u.nombre', 'ASC');
  148.                                                                                     },
  149.                                 'group_by' => function($choice, $key, $value) {
  150.                                                                                     if ($choice && $choice->getSector()) 
  151.                                                                                     {
  152.                                                                                         return $choice->getSector() . '';
  153.                                                                                     }
  155.                                                                                     return 'Sin sector';
  156.                                                                                 },
  157.                             ])
  158.                      ->getForm();
  159.         $form->handleRequest($request);
  160.         if ($form->isSubmitted() && $form->isValid()) 
  161.         {
  162.             $data = $form->getData();
  163.             $planes = $planMantenimientoRepository->informePlanesPreventivosRealizados($data);
  165.             $response = array();
  167.             foreach ($planes as $plan) 
  168.             {
  169.                 $planM = $plan->getPlanMantenimiento(); 
  170.                 $insumos = [];
  172.                 foreach ($plan->getTareasDiagramadas() as $tareaDiagramada) 
  173.                 {
  175.                     foreach ($tareaDiagramada->getInsumos() as $insumo)  
  176.                     {
  177.                         foreach ($insumo->getItems() as $item)
  178.                         {
  179.                             $insumos[] = [
  180.                                 'nombre' => $item->getArticulo() . '',
  181.                                 'cantidad' => $item->getCantidad(),
  182.                             ];
  183.                         }
  184.                     }
  185.                 }
  186.                 $response[] = [
  187.                     'id' => $plan->getId(),
  188.                     'equipo' => $plan->getEquipo() . '',
  189.                     'nombre' => $planM->getNombre(),
  190.                     'departamento' => $plan->getDepartamento() . '',
  191.                     'periodicidad' => $planM->getFrecuenciaPlan(),
  192.                     'fechaRealizacion' => $plan->getFechaRealizacion() ? $plan->getFechaRealizacion()->format('d/m/Y') : null,
  193.                     'fechaSort' => $plan->getFechaRealizacion() ? $plan->getFechaRealizacion()->format('Y-m-d') : null,
  194.                     'insumos' => $insumos,
  195.                 ];
  197.                 
  199.             }
  201.             return $this->render('mantenimiento/preventivo/plan_mantenimiento_diagramado/informe.html.twig', 
  202.                                 [
  203.                                     'form' => $form->createView(),
  204.                                     'planes' => $response,
  205.                                 ]);
  206.         }
  208.         return $this->render('mantenimiento/preventivo/plan_mantenimiento_diagramado/informe.html.twig', 
  209.                              [
  210.                                 'form' => $form->createView(),
  211.                              ]);
  212.     }
  214.     /**
  215.      * @Route("/proximos/preventivos/realizar", name="app_mantenimiento_preventivo_plan_mantenimiento_proximos", methods={"GET", "POST"})
  216.      */
  217.     public function proximosPreventivos(Request $request, PlanMantenimientoDiagramadoRepository $planMantenimientoRepository): Response
  218.     {   
  219.         $formFechas = $this->getFormFechas();
  220.         $formFechas->handleRequest($request);
  221.         if ($formFechas->isSubmitted() && $formFechas->isValid()) 
  222.         {
  223.             $data = $formFechas->getData();
  224.             $desde = $data['desde'] ?? new \DateTime('now');
  225.             $hasta = $data['hasta'] ?? (new \DateTime('now'))->modify('+1 month');
  226.             $planes = $planMantenimientoRepository->proximosPlanesMantenimientoEquipos($desde, $hasta);
  227.             return $this->render('mantenimiento/preventivo/plan_mantenimiento_diagramado/proximos.html.twig', [
  228.                 'form' => $formFechas->createView(),
  229.                 'planes' => $planes,
  230.                 'desde' => $desde,
  231.                 'hasta' => $hasta,
  232.             ]);
  233.         }
  234.         return $this->render('mantenimiento/preventivo/plan_mantenimiento_diagramado/proximos.html.twig', [
  235.                             'form' => $formFechas->createView(),
  236.         ]);
  237.     }
  239.     /**
  240.      * @Route("/gestion/masiva", name="app_mantenimiento_preventivo_plan_mantenimiento_gestion_masiva", methods={"GET", "POST"})
  241.      */
  242.     public function gestionMasiva(Request $request, PlanMantenimientoRepository $planMantenimientoRepository): Response
  243.     {   
  244.         $form = $this->getFormSelectPeriodo();
  245.         $form->handleRequest($request);
  249.         if ($form->isSubmitted() && $form->isValid()) 
  250.         {
  251.             $data = $form->getData();
  252.             $periodo = $data['periodo'];
  253.             $planes = $planMantenimientoRepository->findPlanesActivosPorEquipoConUltimaFechaRealizacion($periodo);
  255.             return $this->render('mantenimiento/preventivo/plan_mantenimiento_diagramado/masivo.html.twig', [
  256.                 'form' => $form->createView(),
  257.                 'planes' => $planes,
  258.                 'periodo' => $periodo,
  259.                 'departamentos' => $this->getUser()->getDepartamentos(),
  260.             ]); 
  261.         }
  262.         return $this->render('mantenimiento/preventivo/plan_mantenimiento_diagramado/masivo.html.twig', [
  263.                             'form' => $form->createView(),
  264.         ]);
  265.     }
  267.     /**
  268.      * @Route("/gestion/masiva/procesar", name="app_mantenimiento_preventivo_plan_mantenimiento_gestion_masiva_procesar", methods={"POST"})
  269.      */
  270.     public function gestionMasivaProcesar(Request $request, PlanMantenimientoDiagramadoRepository $planMantenimientoDiagramadoRepository, EntityManagerInterface $em): Response
  271.     {   
  272.         $all = $request->request->all();
  274.         if (!$all['departamento'])
  275.         {
  276.             return new JsonResponse([
  277.                 'status' => false,
  278.                 'message' => 'Debe seleccionar un departamento.',
  279.             ]);
  280.         }
  281.         $departamento = $em->find(Departamento::class, $all['departamento']);
  282.         $fechaSeleccionada = \DateTime::createFromFormat('Y-m-d', $all['fecha_diagramacion']);
  283.         $numeroSemana= (int)$fechaSeleccionada->format('W');
  284.         $numeroAnio= (int)$fechaSeleccionada->format('Y');
  285.         $numeroMes = (int)$fechaSeleccionada->format('m');
  286.         $planesDiagramados = [];
  288.         foreach ($all as $key => $value) 
  289.         {
  290.             $diagramar = false;
  291.             if (strpos($key, 'switch-') === 0) 
  292.             {
  293.                 $parts = explode('-', str_replace('switch-', '', $key));
  294.                 if (count($parts) == 3) 
  295.                 {
  296.                     $periodo = $parts[2];
  297.                     $plan = $em->find(PlanMantenimiento::class, $parts[0]);
  298.                     $equipo = $em->find(Maquinaria::class, $parts[1]);
  299.                     $fechaDiagramado = $planMantenimientoDiagramadoRepository->findUltimaFechaDiagramada($plan, $equipo, $fechaSeleccionada);
  301.                    
  303.                     if (!count($fechaDiagramado) )
  304.                     {
  305.                         $diagramar = true;
  306.                     }
  307.                     else
  308.                     {
  309.                         if ($periodo == 7)
  310.                         {
  311.                                 $planesDiagramados[$key] = ["El plan se encuentra diagramado esta semana.", false];
  312.                         }
  313.                         elseif ($periodo == 30)
  314.                         {
  315.                                 $planesDiagramados[$key] = ["El plan se encuentra diagramado este mes.", false];
  316.                         }
  317.                         elseif ($periodo == 365)
  318.                         {
  319.                                 $planesDiagramados[$key] = ["El plan se encuentra diagramado este año.", false];
  320.                             
  321.                         }
  322.                     }
  323.                     if ($diagramar)
  324.                     {
  325.                         $planDiagramado = new PlanMantenimientoDiagramado();
  326.                         $planDiagramado->setPlanMantenimiento($plan)
  327.                                         ->setEquipo($equipo)
  328.                                         ->setFechaDiagrama($fechaSeleccionada)
  329.                                         ->setDepartamento($departamento);
  331.                         $em->persist($planDiagramado);
  332.                         foreach ($plan->getTareas() as $tarea) 
  333.                         {
  334.                             $tareaPlanDiagramada = new TareaPlanDiagramada();
  335.                             $tareaPlanDiagramada->setTareaPlan($tarea)
  336.                                                 ->setDetalle($tarea->getDetalle())
  337.                                                 ->setPlanMantenimientoDiagramado($planDiagramado)
  338.                                                 ->setRealizada(false);
  339.                             $em->persist($tareaPlanDiagramada);
  340.                         }  
  341.                         
  342.                         $planesDiagramados[$key] = ["Plan mantenimineto diagramado exitosamente.", true];
  343.                     }
  344.                     
  345.                 }
  346.             }
  347.         }
  349.         $em->flush();
  351.         if (count($planesDiagramados) === 0) 
  352.         {
  353.             return new JsonResponse([
  354.                 'status' => false,
  355.                 'message' => 'No se seleccionaron planes para diagramar.',
  356.             ]);
  357.         }
  360.         return new JsonResponse([
  361.             'status' => true,
  362.             'planesDiagramados' => $planesDiagramados,
  363.             'fecha' => $fechaSeleccionada->format('d/m/Y'),
  364.         ]);
  366.     }
  369.     /**
  370.      * @Route("/marcar/{id}/diagramado", name="app_mantenimiento_preventivo_plan_mantenimiento_diagramado_realizar", methods={"GET", "POST"})
  371.      */
  372.     public function marcarDiagramado(PlanMantenimientoDiagramado $planDiagramado, EntityManagerInterface $em): Response
  373.     {   
  375.         if ($planDiagramado->isRealizado()) 
  376.         {
  377.             return new JsonResponse([
  378.                 'status' => false,
  379.                 'message' => 'El plan de mantenimiento ya ha sido realizado.',
  380.             ]);
  381.         }
  383.         $dias = $planDiagramado->getPlanMantenimiento()->getPeriodicidad();
  384.         $proximaFecha = new \DateTime();
  385.         $proximaFecha->modify("+$dias days");       
  387.         $planDiagramado->setFechaProximaRealizacion($proximaFecha);
  389.         $planDiagramado->setRealizado(true);
  390.         $planDiagramado->setFechaRealizacion(new \DateTime());
  391.         $em->flush();
  394.         return new JsonResponse([
  395.             'status' => true,
  396.             'message' => 'Plan de mantenimiento marcado como realizado.',
  397.             'fechaProximaRealizacion' => $proximaFecha->format('d/m/Y'),
  398.         ]);
  399.     
  400.     }
  404.     /**
  405.      * @Route("/print/{id}/plan", name="app_mantenimiento_preventivo_plan_mantenimiento_diagramado_print", methods={"GET", "POST"})
  406.      */
  408.     public function pdfAction(PlanMantenimientoDiagramado $planMantenimientoDiagramado, Pdf $knpSnappyPdf)
  409.     {
  410.         $html = $this->twig->render('mantenimiento/preventivo/plan_mantenimiento_diagramado/imprimir.html.twig', [ 'plan' => $planMantenimientoDiagramado ]);
  412.         $this->pdf->setTimeout(600);
  413.         return new PdfResponse(
  414.             $this->pdf->getOutputFromHtml($html),
  415.             'file.pdf'
  416.         );
  417.     }
  420.         /**
  421.      * @Route("/print/pendiente", name="app_mantenimiento_preventivo_plan_mantenimiento_pendiente_realizar_print", methods={"GET", "POST"})
  422.      */
  424.     public function pdfActionListaPendientes(Pdf $knpSnappyPdf, PlanMantenimientoDiagramadoRepository $planMantenimientoRepository)
  425.     {
  426.         $planes = $planMantenimientoRepository->planesMantenimientoEquiposPendientes();
  427.         $html = $this->twig->render('mantenimiento/diagrama_tarea/imprimirPlanesPendientes.html.twig', [ 'planes' => $planes ]);
  429.         $this->pdf->setTimeout(600);
  430.         return new PdfResponse(
  431.             $this->pdf->getOutputFromHtml($html),
  432.             'planes_pendientes.pdf'
  433.         );
  434.     }
  438.     /**
  439.      * @Route("/pendientes/realizar", name="app_mantenimiento_preventivo_plan_mantenimiento_diagramado_pendientes_index", methods={"GET", "POST"})
  440.      */
  441.     public function planesPendientes(Request $request, PlanMantenimientoDiagramadoRepository $planMantenimientoRepository): Response
  442.     {   
  444.         $planes = $planMantenimientoRepository->planesMantenimientoEquiposPendientes();
  445.         return $this->render('mantenimiento/preventivo/plan_mantenimiento_diagramado/administrar.html.twig', [
  446.                             'planes' => $planes,
  447.         ]);
  448.     }
  451.     /**
  452.      * @Route("/pendientes/{id}/gestionar", name="app_mantenimiento_preventivo_plan_mantenimiento_diagramado_administrar_tareas", methods={"GET", "POST"})
  453.      */
  454.     public function gestionarPlanDiagramado(PlanMantenimientoDiagramado $planMantenimientoDiagramado): Response
  455.     {   
  457.         return $this->render('mantenimiento/preventivo/plan_mantenimiento_diagramado/administrarTareas.html.twig', [
  458.                             'plan' => $planMantenimientoDiagramado,
  459.         ]);
  460.     } 
  464.     /**
  465.      * @Route("/pendientes/{id}/gestionar/procesar/tareas", name="app_mantenimiento_preventivo_plan_mantenimiento_diagramado_procesar_tareas", methods={"GET", "POST"})
  466.      */
  467.     public function gestionarTareasDiagramado(Request $request, EntityManagerInterface $em, PlanMantenimientoDiagramado $planMantenimientoDiagramado): Response
  468.     {   
  470.         if ($planMantenimientoDiagramado->isRealizado()) 
  471.         {
  472.             return new JsonResponse([
  473.                 'status' => false,
  474.                 'message' => 'El plan de mantenimiento ya ha sido realizado.',
  475.             ]);
  476.         }
  478.         $all = $request->request->all();
  479.         try{
  480.                 foreach ($all as $key => $value) 
  481.                 {
  482.                     if (strpos($key, 'observa_') === 0) 
  483.                     {
  484.                         $tareaId = str_replace('observa_', '', $key);
  486.                         $tarea = $em->find(TareaPlanDiagramada::class, $tareaId);
  487.                         if ($tarea) 
  488.                         {
  489.                             $realizada = isset($all['realizada_' . $tareaId]) ? true : false;
  490.                             $tarea->setRealizada($realizada)
  491.                                     ->setDetalle($value);
  492.                             if (isset($all['diagramar_' . $tareaId]))
  493.                             {
  494.                                 $pedidoReparacion = new PedidoReparacion();
  495.                                 $pedidoReparacion->setTareaPlanDiagramada($tarea)
  496.                                                 ->setFecha(new \DateTimeImmutable())
  497.                                                 ->setDetalle($tarea->getTareaPlan()->getTarea())
  498.                                                 ->setSector($planMantenimientoDiagramado->getEquipo()->getSector())
  499.                                                 ->setEquipo($planMantenimientoDiagramado->getEquipo())
  500.                                                 ->setUsuarioAlta($this->getUser());
  501.                                 $em->persist($pedidoReparacion);
  502.                             }
  503.                         }
  504.                     }
  505.                 }
  506.                 $dias = $planMantenimientoDiagramado->getPlanMantenimiento()->getPeriodicidad();
  507.                 $proximaFecha = new \DateTime();
  508.                 $proximaFecha->modify("+$dias days");       
  509.                 $planMantenimientoDiagramado->setFechaProximaRealizacion($proximaFecha);
  510.                 $planMantenimientoDiagramado->setRealizado(true);
  511.                 $planMantenimientoDiagramado->setFechaRealizacion(new \DateTime());
  512.                 $em->flush();
  513.                 return new JsonResponse([
  514.                     'status' => true,
  515.                     'message' => 'Tareas procesadas exitosamente.',
  516.                     'fechaProximaRealizacion' => $proximaFecha->format('d/m/Y'),
  517.                 ]);
  518.         } catch (\Exception $e) {
  519.             return new JsonResponse([
  520.                 'status' => false,
  521.                 'message' => 'Error al procesar las tareas: ' . $e->getMessage(),
  522.             ]);
  523.         }    
  525.     }
  529.     /**
  530.      * @Route("/", name="app_mantenimiento_preventivo_plan_mantenimiento_diagramado_index", methods={"GET", "POST"})
  531.      */
  532.     public function pleaseGo(Request $request, PlanMantenimientoRepository $planMantenimientoRepository, EntityManagerInterface $em): Response
  533.     {   
  534.         $form = $this->getFormSelectEquipo();
  536.         if ($request->isMethod('POST')) 
  537.         {
  538.             $form->handleRequest($request);
  540.             if ($form->isValid()) 
  541.             {
  542.                 
  543.                 $equipo = $form->get('equipo')->getData();
  544.                 $planes = $planMantenimientoRepository->planesMantenimientoEquipos($equipo);
  546.                 $dptos = $em->getRepository( Departamento::class  )->findAll();
  548.                 return $this->render('mantenimiento/preventivo/plan_mantenimiento_diagramado/index.html.twig', [
  549.                     'form' => $form->createView(),
  550.                     'planes' => $planes,
  551.                     'equipo' => $equipo,
  552.                     'dptos' => $dptos
  553.                 ]);
  554.             }
  555.         }
  557.         return $this->render('mantenimiento/preventivo/plan_mantenimiento_diagramado/index.html.twig', [
  558.             'form' => $form->createView(),
  559.         ]);
  560.     }
  563.     /**
  564.      * @Route("/home", name="app_mantenimiento_preventivo_plx", methods={"GET", "POST"})
  565.      */
  566.     public function indiceHome(Request $request, PlanMantenimientoRepository $planMantenimientoRepository, EntityManagerInterface $em): Response
  567.     {   
  568.         $form = $this->getFormSelectEquipo();
  569.   /////
  570.         if ($request->isMethod('POST')) 
  571.         {
  572.             $form->handleRequest($request);
  573.             if ($form->isValid()) 
  574.             {
  575.                 $equipo = $form->get('equipo')->getData();
  576.                 $planes = $planMantenimientoRepository->planesMantenimientoEquipos($equipo);
  578.                 $dptos = $em->getRepository( Departamento::class  )->findAll();
  580.                 return $this->render('mantenimiento/preventivo/plan_mantenimiento_diagramado/index.html.twig', [
  581.                     'form' => $form->createView(),
  582.                     'planes' => $planes,
  583.                     'equipo' => $equipo,
  584.                     'dptos' => $dptos
  585.                 ]);
  586.             }
  587.         }
  589.         return $this->render('mantenimiento/preventivo/plan_mantenimiento_diagramado/index.html.twig', [
  590.             'form' => $form->createView(),
  591.         ]);
  592.     }
  595.     /**
  596.      * @Route("/diagramar/{plan}/equipo/{equipo}/departamento/{depto}", name="app_mantenimiento_preventivo_plan_mantenimiento_diagramar", methods={"GET", "POST"})
  597.      */
  598.     public function diagramarPlan(PlanMantenimiento $plan, Equipo $equipo, EntityManagerInterface $em, $depto, PlanMantenimientoDiagramadoRepository $planMantenimientoDiagramadoRepository): Response
  599.     {
  600.         
  601.         $existingPlan = $planMantenimientoDiagramadoRepository->findPlanMantenimiento($plan, $equipo);
  603.         $depto = $em->find(Departamento::class, $depto);
  605.         if ($existingPlan) 
  606.         {
  607.             return new JsonResponse([
  608.                 'status' => false,
  609.                 'message' => 'El plan de mantenimiento ya ha sido diagramado para este equipo. ' ,
  610.             ]);
  611.         }
  613.         
  614.         $planMantenimientoDiagramado = new PlanMantenimientoDiagramado();
  616.         $planMantenimientoDiagramado->setPlanMantenimiento($plan)
  617.                                     ->setEquipo($equipo)
  618.                                     ->setFechaDiagrama(new \DateTime())
  619.                                     ->setDepartamento($depto)
  620.                                     ->setRealizado(false);
  621.         foreach ($plan->getTareas() as $tarea) 
  622.         {
  623.             $tareaPlanDiagramada = new TareaPlanDiagramada();
  624.             $tareaPlanDiagramada->setTareaPlan($tarea)
  625.                                 ->setPlanMantenimientoDiagramado($planMantenimientoDiagramado)
  626.                                 ->setRealizada(false);
  627.             $em->persist($tareaPlanDiagramada);
  628.         }   
  629.         $em->persist($planMantenimientoDiagramado);
  630.         $em->flush();   
  631.         return new JsonResponse([
  632.             'status' => true,
  633.             'message' => 'Plan de mantenimiento diagramado exitosamente.',
  634.             'idPlan' => $planMantenimientoDiagramado->getId(),
  635.         ]);
  636.     }
  640.     /**
  641.      * @Route("/new", name="app_mantenimiento_preventivo_plan_mantenimiento_diagramado_new", methods={"GET", "POST"})
  642.      */
  643.     public function new(Request $request, PlanMantenimientoDiagramadoRepository $planMantenimientoDiagramadoRepository): Response
  644.     {
  645.         $planMantenimientoDiagramado = new PlanMantenimientoDiagramado();
  646.         $form = $this->createForm(PlanMantenimientoDiagramadoType::class, $planMantenimientoDiagramado);
  647.         $form->handleRequest($request);
  649.         if ($form->isSubmitted() && $form->isValid()) {
  650.             $planMantenimientoDiagramadoRepository->add($planMantenimientoDiagramado, true);
  652.             return $this->redirectToRoute('app_mantenimiento_preventivo_plan_mantenimiento_diagramado_index', [], Response::HTTP_SEE_OTHER);
  653.         }
  655.         return $this->renderForm('mantenimiento/preventivo/plan_mantenimiento_diagramado/new.html.twig', [
  656.             'plan_mantenimiento_diagramado' => $planMantenimientoDiagramado,
  657.             'form' => $form,
  658.         ]);
  659.     }
  662.     /**
  663.      * @Route("/{id}", name="app_mantenimiento_preventivo_plan_mantenimiento_diagramado_show", methods={"GET", "POST"})
  664.      */
  665.     public function show(PlanMantenimientoDiagramado $planMantenimientoDiagramado): Response
  666.     {
  667.         return $this->render('mantenimiento/preventivo/plan_mantenimiento_diagramado/show.html.twig', [
  668.             'plan_mantenimiento_diagramado' => $planMantenimientoDiagramado,
  669.         ]);
  670.     }
  673.        /**
  674.      * @Route("/{id}/edit", name="app_mantenimiento_preventivo_plan_mantenimiento_diagramado_edit", methods={"GET", "POST"})
  675.      */
  676.     public function edit(Request $request, PlanMantenimientoDiagramado $planMantenimientoDiagramado, PlanMantenimientoDiagramadoRepository $planMantenimientoDiagramadoRepository): Response
  677.     {
  678.         $form = $this->createForm(PlanMantenimientoDiagramadoType::class, $planMantenimientoDiagramado);
  679.         $form->handleRequest($request);
  681.         if ($form->isSubmitted() && $form->isValid()) {
  682.             $planMantenimientoDiagramadoRepository->add($planMantenimientoDiagramado, true);
  684.             return $this->redirectToRoute('app_mantenimiento_preventivo_plan_mantenimiento_diagramado_index', [], Response::HTTP_SEE_OTHER);
  685.         }
  687.         return $this->renderForm('mantenimiento/preventivo/plan_mantenimiento_diagramado/edit.html.twig', [
  688.             'plan_mantenimiento_diagramado' => $planMantenimientoDiagramado,
  689.             'form' => $form,
  690.         ]);
  691.     }
  694.        /**
  695.      * @Route("/{id}", name="app_mantenimiento_preventivo_plan_mantenimiento_diagramado_delete", methods={"GET", "POST"})
  696.      */
  697.     public function delete(Request $request, PlanMantenimientoDiagramado $planMantenimientoDiagramado, PlanMantenimientoDiagramadoRepository $planMantenimientoDiagramadoRepository): Response
  698.     {
  699.         if ($this->isCsrfTokenValid('delete'.$planMantenimientoDiagramado->getId(), $request->request->get('_token'))) {
  700.             $planMantenimientoDiagramadoRepository->remove($planMantenimientoDiagramado, true);
  701.         }
  703.         return $this->redirectToRoute('app_mantenimiento_preventivo_plan_mantenimiento_diagramado_index', [], Response::HTTP_SEE_OTHER);
  704.     }
  705. }