src/Controller/ProgManttoCorrectivoController.php line 109

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\Equipo;
  6. use App\Entity\Evaluacion;
  7. use App\Entity\Impresora;
  8. use App\Entity\Otro;
  9. use App\Entity\Periodo;
  10. use App\Entity\Red;
  11. use App\Entity\Solicitud;
  12. use App\Entity\Usuario;
  13. use App\Form\EvaluacionSelecType;
  14. use App\Form\EvaluacionType;
  15. use App\Form\SolicitudType;
  16. use App\Form\SolicitudSelecType;
  17. use App\Service\VistaTipoEquipo;
  18. use DateTime;
  19. use Doctrine\ORM\EntityRepository;
  20. use Doctrine\ORM\EntityManagerInterface;
  21. use Symfony\Bridge\Doctrine\Form\Type\EntityType;
  22. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  23. use Symfony\Component\Form\Extension\Core\Type\ChoiceType;
  24. use Symfony\Component\Form\Extension\Core\Type\HiddenType;
  25. use Symfony\Component\Form\Extension\Core\Type\TextareaType;
  26. use Symfony\Component\HttpFoundation\JsonResponse;
  27. use Symfony\Component\HttpFoundation\Request;
  28. use Symfony\Component\HttpFoundation\Response;
  29. use Symfony\Component\Routing\Annotation\Route;
  30. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  31. use Symfony\Component\Serializer\SerializerInterface;
  32. use Symfony\Component\Validator\Constraints\NotBlank;
  34. #[Route('/programacion/correctivo')]
  35. class ProgManttoCorrectivoController extends AbstractController
  36. {
  37.     public EntityManagerInterface $entityManager;
  38.     public SerializerInterface $serializer;
  40.     /**
  41.      * @param EntityManagerInterface $entityManager
  42.      */
  43.     public function __construct(EntityManagerInterface $entityManager, SerializerInterface $serializer)
  44.     {
  45.         $this->entityManager = $entityManager;
  46.         $this->serializer = $serializer;
  47.     }
  49.     #[Route('/', name: 'prog_correctivo_index')]
  50.     public function index(Request $request): Response
  51.     {
  52.         /** @var Usuario $user */
  53.         $user = $this->getUser();
  55.         $solicitudes = $this->entityManager->getRepository(Solicitud::class)->registroTipoEquipoUsuario($user->getIdUsu(), 1);
  56.         $atendidas = array_reduce($solicitudes, function ($carry, $solicitud) {
  57.             return $solicitud['estatus'] == 3 ? $carry + 1 : $carry;
  58.         }, 0);
  60.         $invocation = $this->obtenerAtributoEntidad(null, null);
  62.         $solicitar = $this->createForm(SolicitudSelecType::class, null, ['opciones' => $invocation['opciones'], 'opciones_attr' => $invocation['opciones_attr']]);
  63.         $solicitar->handleRequest($request);
  65.         $evaluar = $this->createForm(EvaluacionSelecType::class, null, ['usuario' => $user]);
  66.         $evaluar->handleRequest($request);
  68.         if ($solicitar->isSubmitted() && $solicitar->isValid() && $request->isMethod('POST') && $solicitar->get('origen')->getData() === 'form-equipo-solicitud') {
  69.             $fallaValue = $solicitar->get('falla')->getData();
  70.             if ($fallaValue === null || trim((string) $fallaValue) === '') {
  71.                 return new JsonResponse(['mensaje' => 'El campo no debe estar vacío'], Response::HTTP_BAD_REQUEST);
  72.             }
  74.             $invo = $this->mapeoTipoEquipo($solicitar->get('tipo')->getData());
  76.             $entidad = $this->consultaEntidad([
  77.                 'id' => $solicitar->get('marbete')->getData(),
  78.                 'tipo' => $solicitar->get('tipo')->getData(),
  79.                 'campo' => $invo['atributo']
  80.             ]);
  82.             if (!$entidad) {
  83.                 return new JsonResponse(['mensaje' => $solicitar->get('tipo')->getData() . ' no encontrado'], Response::HTTP_NOT_FOUND);
  84.             }
  86.             $info = $this->programarSolicitudSave($this->construirDatosEntidad($entidad, $solicitar->get('tipo')->getData(), $solicitar));
  87.             return new JsonResponse($info);
  88.         }
  90.         if ($solicitar->isSubmitted() && !$solicitar->isValid() && $solicitar->get('origen')->getData() === 'form-equipo-solicitud') {
  91.             $view = $this->renderView('prog_correctivo/index.html.twig', [
  92.                 'equipos' => $invocation['opciones_type'],
  93.                 'solicitudes' => $solicitudes,
  94.                 'atendidas' => $atendidas,
  95.                 'solicitar' => $solicitar->createView(),
  96.                 'evaluar' => $evaluar->createView()
  97.             ]);
  98.             $response = new JsonResponse(['form' => $view]);
  99.             return $response->setStatusCode(Response::HTTP_BAD_REQUEST);
  100.         }
  102.         if ($evaluar->isSubmitted() && $evaluar->isValid() && $request->isMethod('POST') && $evaluar->get('origen')->getData() === 'form-equipo-evaluar'){
  103.             $solicitudData = $evaluar->get('marbete')->getData();
  104.             $solicitud = $this->entityManager->getRepository(Solicitud::class)->find($solicitudData->getIdSol());
  105.             
  106.             if (!$solicitud) {
  107.                 return new JsonResponse(['mensaje' => 'Solicitud no encontrada'], Response::HTTP_NOT_FOUND);
  108.             }
  109.             
  110.             $this->evaluarSolicitudSave([
  111.                 'reacta' => $evaluar->get('evalua1')->getData(),
  112.                 'reactb' => $evaluar->get('evalua2')->getData(),
  113.                 'reactc' => $evaluar->get('evalua3')->getData(),
  114.                 'reactd' => $evaluar->get('evalua4')->getData(),
  115.                 'reacte' => $evaluar->get('evalua5')->getData(),
  116.                 'solicitud' => $solicitud,
  117.                 'usuario' => $user
  118.             ]);
  119.             
  120.             return new JsonResponse(['message' => 'Evaluación guardada correctamente', 'id' => $solicitud->getIdSol()]);
  121.         }
  123.         if ($evaluar->isSubmitted() && !$evaluar->isValid() && $evaluar->get('origen')->getData() === 'form-equipo-evaluar'){
  124.             $view = $this->renderView('prog_correctivo/index.html.twig', [
  125.                 'equipos' => $invocation['opciones_type'],
  126.                 'solicitudes' => $solicitudes,
  127.                 'atendidas' => $atendidas,
  128.                 'solicitar' => $solicitar->createView(),
  129.                 'evaluar' => $evaluar->createView()
  130.             ]);
  131.             $response = new JsonResponse(['form' => $view]);
  132.             return $response->setStatusCode(Response::HTTP_BAD_REQUEST);
  133.         }
  135.         return $this->render('prog_correctivo/index.html.twig', [
  136.             'equipos' => $invocation['opciones_type'],
  137.             'solicitudes' => $solicitudes,
  138.             'atendidas' => $atendidas,
  139.             'solicitar' => $solicitar->createView(),
  140.             'evaluar' => $evaluar->createView()
  141.         ]);
  142.     }
  144.     /**
  145.      * Vista detallada de solicitud
  146.      * @Route("/vista/solicitud/{id}", name="prog_correctivo_vista_solicitud", methods={"GET", "POST"})
  147.      * @param Request $request
  148.      * @return Response
  149.      */
  150.     public function vistaSolicitud(Request $request) :Response
  151.     {
  152.         $solicitud = $this->entityManager->getRepository(Solicitud::class)->detalleTipoEquipoSolicitud($request->get('id'));
  153.         return $this->render('prog_solicitud/informacion_solicitud.html.twig', ['info' => $solicitud]);
  154.     }
  156.     #[Route('/vista/contador', name: 'prog_correctivo_vista')]
  157.     public function vistaContador() :JsonResponse
  158.     {
  159.         /** @var Usuario $user */
  160.         $user = $this->getUser();
  162.         $cTodoEquipo = $this->entityManager->getRepository(Solicitud::class)->conteoEstatusTipoEquipoUsuario($user->getIdUsu(), 1);
  163.         return new JsonResponse(['data' => $cTodoEquipo], Response::HTTP_OK);
  164.     }
  166.     /**
  167.      * Vista detallada por tipo, equipo, impresora, red, otro
  168.      * @Route("/vista/{tipo}/{id}", name="prog_correctivo_vista_tipo", methods={"GET", "POST"})
  169.      * @param Request $request
  170.      * @return Response
  171.      */
  172.     public function vistaTipo(Request $request) :Response
  173.     {
  174.         $service = new VistaTipoEquipo($this->entityManager);
  175.         $info = $service->consultaInformacion($request->get('tipo'), $request->get('id'));
  176.         return $this->render('prog_solicitud/informacion_tipo.html.twig', ['tipo' => $request->get('tipo'),'info' => $info]);
  177.     }
  179.     /**
  180.      * Elimina campos innecesarios del formulario de solicitud
  181.      * @param \Symfony\Component\Form\FormInterface $form
  182.      */
  183.     private function eliminarCamposFormulario(\Symfony\Component\Form\FormInterface $form): void
  184.     {
  185.         $campos = ['tipoEquipo', 'idEquipo', 'periodo', 'tipoMantenimiento', 'srealizado', 
  186.                    'fregistro', 'fatencion', 'ffin', 'evaluacion', 'refacciones', 'estatus', 
  187.                    'usuario', 'ubicacion', 'gestor'];
  188.         
  189.         foreach ($campos as $campo) {
  190.             $form->remove($campo);
  191.         }
  192.     }
  194.     /**
  195.      * Consulta de solicitudes programadas por equipo, de tipo impresora
  196.      * @Route("/programada/consulta/{tipo}/{id}", name="prog_correctivo_programada_tipo", methods={"GET", "POST"})
  197.      * @return Response
  198.      */
  199.     public function consultaProgramadaTipo(Request $request) :Response
  200.     {
  201.         $info = [
  202.             'tipoEquipo' => $request->get('tipo'),
  203.             'tipoMantenimiento' => 'Correctivo',
  204.             'siglasMantenimiento' => 'MC'
  205.         ];
  207.         $programadas = $this->entityManager->getRepository(Solicitud::class)->registroEquipoSolicitud($request->get('tipo'), $info['tipoEquipo'], $info['siglasMantenimiento']);
  209.         return $this->renderForm('prog_solicitud/programado.html.twig', [
  210.             'info' => $info,
  211.             'solicitud' => $programadas
  212.         ]);
  213.     }
  215.     /**
  216.      * Programar solicitud por equipo, solo tipo equipo
  217.      * @Route("/solicitud/{tipo}/{id}", name="prog_correctivo_solicitud_tipo", methods={"GET", "POST"})
  218.      * @param Request $request
  219.      * @return Response
  220.      */
  221.     public function programarSolicitud(Request $request) :Response
  222.     {
  223.         $entidad = $this->obtenerAtributoEntidad(null, $request->get('tipo'));
  224.         $entidad = $this->consultaEntidad([
  225.             'id' => $request->get('id'),
  226.             'tipo' => $request->get('tipo'),
  227.             'campo' => $entidad['propiedad']['atributo']
  228.         ]);
  230.         $info = [
  231.             'tipoEquipo' => $request->get('tipo'),
  232.             'tipoMantenimiento' => 'Correctivo',
  233.             'marbete' => $entidad->getMarbete()
  234.         ];
  236.         $form = $this->createForm(SolicitudType::class);
  237.         $this->eliminarCamposFormulario($form);
  238.         $form->handleRequest($request);
  240.         if ($form->isSubmitted() && $form->isValid()) {
  241.             if($form->get('falla')->getData() == "" || $form->get('falla') == null){
  242.                 return new JsonResponse(['mensaje' => 'El campo no debe estar vacío'], Response::HTTP_BAD_REQUEST);
  243.             }
  244.             $data = $this->construirDatosEntidad($entidad, $request->get('tipo'), $form);
  245.             $info = $this->programarSolicitudSave($data);
  246.             return new JsonResponse($info);
  247.         }
  249.         if ($form->isSubmitted() && !$form->isValid()) {
  250.             $view = $this->renderView('prog_solicitud/programar.html.twig', [
  251.                 'form' => $form->createView(),
  252.                 'info' => $info
  253.             ]);
  254.             $response = new JsonResponse(['form' => $view]);
  255.             $response->setStatusCode(Response::HTTP_BAD_REQUEST);
  256.             return $response;
  257.         }
  259.         return $this->renderForm('prog_solicitud/programar.html.twig', [
  260.             'form' => $form,
  261.             'info' => $info
  262.         ]);
  263.     }
  265.     /**
  266.      * Función para crear objeto tipo solicitud e insertar en la base de datos
  267.      * @param array $data Array con la información específica a complementar
  268.      * @return array Para creación de botón en la vista
  269.      */
  270.     private function programarSolicitudSave($data)
  271.     {
  272.         date_default_timezone_set("America/Mexico_City");
  273.         $factual = new DateTime();
  275.         # Identificador de solicitud
  276.         $partA = date("y");
  277.         $partB = substr($data['unidad']->getIdUni(), 3, 3);
  278.         $partC = str_pad($data['unidad']->getConsecutivo(), 4,"0", STR_PAD_LEFT);
  279.         $idSolicitud = $partA.$partB.$partC;
  280.         $save = new Solicitud();
  281.         $save->setIdSol($idSolicitud);
  282.         $save->setIdEquipo($data['id']);
  283.         $save->setTipoEquipo($data['tipo']);
  284.         $save->setTipoMantenimiento("MC");
  285.         $save->setUnidad($data['unidad']);
  286.         $save->setUsuario($data['usuario']);
  287.         $save->setUbicacion($data['ubicacion']);
  288.         $save->setPeriodo($data['periodo']);
  289.         $save->setFalla($data['accion']);
  290.         $save->setFregistro($factual);
  291.         $save->setFatencion($factual);
  292.         $save->setEstatus(1);
  293.         $this->entityManager->persist($save);
  294.         $this->entityManager->flush();
  296.         $unidad = $data['unidad'];
  297.         $unidad->setConsecutivo($unidad->getConsecutivo() + 1);
  298.         $this->entityManager->persist($unidad);
  299.         $this->entityManager->flush();
  301.         $info = [
  302.             'mensaje' => 'Se ha generado la solicitud de mantenimiento, con el identificador ' . $save->getIdSol(),
  303.             'ver_solicitud' => $this->generateUrl('prog_correctivo_vista_solicitud', ['id' => $save->getIdSol()], UrlGeneratorInterface::ABSOLUTE_URL),
  304.             'solicitud' => $save->getIdSol(),
  305.             'tipo_equipo' => $save->getTipoEquipo(),
  306.             'equipo' => $save->getIdEquipo(),
  307.             'marbete' => $data['marbete'],
  308.             'marca' => $data['marca'],
  309.             'modelo' => $data['modelo'],
  310.             'falla' => $save->getFalla(),
  311.             'tipo_mantenimiento' => $save->getTipoMantenimiento(),
  312.             'fregistro' => $save->getFregistro()->format("d M Y, H:i"),
  313.             'estatus' => $save->getEstatus()
  314.         ];
  315.         return $info;
  316.     }
  318.     /**
  319.      * Evaluación de mantenimiento por solicitud
  320.      * @Route("/evaluacion/{idSol}", name="prog_correctivo_evaluacion", methods={"GET", "POST"})
  321.      * @param Solicitud $solicitud
  322.      * @param Request $request
  323.      * @return Response
  324.      */
  325.     public function evaluarSolicitud(Request $request, Solicitud $solicitud) :Response
  326.     {
  327.         /** @var Usuario $user */
  328.         $user = $this->getUser();
  330.         $contestada = $this->entityManager->getRepository(Evaluacion::class)->findOneBy(['solicitud' => $solicitud->getIdSol()]);
  331.         $nueva = 0;
  333.         $info = [
  334.             'solicitud' => $solicitud->getIdSol(),
  335.             'tipoMantenimiento' => $solicitud->getTipoMantenimiento(),
  336.         ];
  338.         if (empty($contestada) && $solicitud->getEstatus() == 3) {
  339.             $nueva = 1;
  340.             $form = $this->createForm(EvaluacionType::class);
  341.             $form->handleRequest($request);
  342.             if ($form->isSubmitted() && $form->isValid()) {
  344.                 $invocation = $this->evaluarSolicitudSave([
  345.                     'reacta' => $form->get('evalua1')->getData(),
  346.                     'reactb' => $form->get('evalua2')->getData(),
  347.                     'reactc' => $form->get('evalua3')->getData(),
  348.                     'reactd' => $form->get('evalua4')->getData(),
  349.                     'reacte' => $form->get('evalua5')->getData(),
  350.                     'solicitud' => $solicitud,
  351.                     'usuario' => $user
  352.                 ]);
  354.                 return new JsonResponse([
  355.                     'id' => $solicitud->getIdSol(),
  356.                     'estatus' => $invocation['estatus'],
  357.                     'mensaje' => 'Evaluación guardada correctamente'
  358.                 ]);
  359.             }
  360.         } else {
  361.             $form = $this->createForm(EvaluacionType::class, $contestada);
  362.             $form->handleRequest($request);
  363.         }
  364.         if ($form->isSubmitted() && !$form->isValid()) {
  365.             $view = $this->renderView('prog_correctivo/evaluacion.html.twig', [
  366.                 'form' => $form->createView(),
  367.                 'info' => $info,
  368.                 'nueva' => $nueva
  369.             ]);
  370.             $response = new JsonResponse(['form' => $view]);
  371.             $response->setStatusCode(Response::HTTP_BAD_REQUEST);
  372.             return $response;
  373.         }
  375.         return $this->renderForm('prog_correctivo/evaluacion.html.twig', [
  376.             'form' => $form,
  377.             'info' => $info,
  378.             'nueva' => $nueva
  379.         ]);
  380.     }
  382.     /**
  383.      * Función para crear objeto tipo evaluacion e insertar en la base de datos
  384.      * @param array $data Array con la información específica a complementar
  385.      * @return array Para creación de botón en la vista
  386.      */
  387.     private function evaluarSolicitudSave($data){
  388.         $evaluacion = new Evaluacion();
  389.         $evaluacion->setEvalua1($data['reacta']);
  390.         $evaluacion->setEvalua2($data['reactb']);
  391.         $evaluacion->setEvalua3($data['reactc']);
  392.         $evaluacion->setEvalua4($data['reactd']);
  393.         $evaluacion->setEvalua5($data['reacte']);
  394.         $evaluacion->setSolicitud($data['solicitud']);
  395.         $this->entityManager->persist($evaluacion);
  396.         $this->entityManager->flush();
  398.         date_default_timezone_set("America/Mexico_City");
  399.         $time = new DateTime();
  401.         $solicitud = $data['solicitud'];
  402.         $solicitud->setUsuario($data['usuario']);
  403.         $solicitud->setEstatus(4);
  404.         $solicitud->setFevaluacion($time);
  405.         $this->entityManager->persist($solicitud);
  406.         $this->entityManager->flush();
  408.         $estatus = "<span class='badge bg-gradient-danger d-block'>No evaluado</span>";
  409.         if ($solicitud->getEstatus() == 4){
  410.             $estatus="<span class='badge bg-gradient-green d-block'>Evaluado</span>";
  411.         }
  413.         return ['estatus' => $estatus];
  414.     }
  415.     
  416.     /**
  417.      * Construye el array de datos para la entidad según su tipo
  418.      * @param $entidad
  419.      * @param string $tipoEquipo
  420.      * @param \Symfony\Component\Form\FormInterface $form
  421.      * @param Periodo $periodo
  422.      * @return array
  423.      */
  424.     private function construirDatosEntidad($entidad, string $tipoEquipo, \Symfony\Component\Form\FormInterface $form): array
  425.     {
  426.         $periodo = $this->entityManager->getRepository(Periodo::class)->findOneBy(['activo' => 1, 'actual' => 1]);
  427.         if (!$periodo) {
  428.             return new JsonResponse(['mensaje' => 'No existe periodo activo'], Response::HTTP_BAD_REQUEST);
  429.         }
  431.         $data = $this->obtenerAtributoEntidad($entidad, $tipoEquipo);
  432.         
  433.         if (is_object($data['marca'])) {
  434.             $marca = $this->serializer->serialize($data['marca'], 'json');
  435.         } else {
  436.             $marca = $data['marca'];
  437.         }
  438.         
  439.         $data = [
  440.             "tipo" => $tipoEquipo,
  441.             "id" => $data['id'],
  442.             "marbete" => $entidad->getMarbete(),
  443.             "marca" => $marca,
  444.             "modelo" => $entidad->getModelo(),
  445.             "iduni" => $entidad->getUnidad()->getIdUni(),
  446.             "consuni" => $entidad->getUnidad()->getConsecutivo(),
  447.             "unidad" => $entidad->getUnidad(),
  448.             "usuario" => $entidad->getUsuario(),
  449.             "ubicacion" => $entidad->getUbicacion(),
  450.             "accion" => $form->get('falla')->getData(),
  451.             "periodo" => $periodo->getIdPrd()
  452.         ];
  453.         return $data;
  454.     }
  456.     private function obtenerAtributoEntidad(Equipo|Impresora|Red|Otro|null $entidad, string|null $tipoEquipo) 
  457.     {
  458.         /** @var Usuario $user */
  459.         $user = $this->getUser();
  461.         $mappings = $this->mapeoTipoEquipo($tipoEquipo);
  462.         
  463.         if (!$entidad && !$tipoEquipo) {
  464.             //throw new \Exception('Categoría de equipo indefinida');
  465.             foreach ($this->mapeoTipoEquipo($tipoEquipo) as $tipo) {
  466.                 $entidad = $this->consultaEntidad([
  467.                     'id' => $user->getIdUsu(),
  468.                     'tipo' => $tipo['singular'],
  469.                     'campo' => null,
  470.                     'usuario' => $user->getIdUsu()
  471.                 ], 'multiple');
  473.                 foreach ($entidad as $item) {
  474.                     $nombreMetodo = $tipo['metodo_id'];
  475.                     $data['opciones'][$tipo['plural']][$item->getMarbete() . ': ' . $item->getDescripcion()] = $item->$nombreMetodo();
  476.                     $data['opciones_attr'][$item->$nombreMetodo()] = ['data-tipo' => $tipo['singular'], 'data-id' => $item->getMarbete()];
  477.                     $data['opciones_type'][$tipo['singular']][$item->$nombreMetodo()] = $item;
  478.                 }
  479.             }
  480.             return $data;
  481.         }
  483.         // Extraemos la configuración específica
  484.         $metodoId = $mappings['metodo_id'];
  485.         $metodoMarca = $mappings['metodo_marca'];
  486.         $data['propiedad'] = $mappings;
  487.         $data['id'] = null; // Inicializar por seguridad
  489.         // Validación: Si $entidad es un objeto (no null y es object)
  490.         if ($entidad instanceof \stdClass || is_object($entidad)) {
  491.             if (!method_exists($entidad, $metodoId)) {
  492.                 throw new \Exception("El objeto no tiene el método: " . $metodoId);
  493.             }
  494.             
  495.             // CORRECCIÓN: Usamos $nombreMetodo (string) en lugar del array
  496.             $data['id'] = $entidad->$metodoId();
  497.             $data['marca'] = $entidad->$metodoMarca();
  498.         }
  500.         return $data;
  501.     }
  503.     private function consultaEntidad($data = null, string $control = null)
  504.     {
  505.         try {
  506.             $claseEntity = $this->entityManager->getClassMetadata('App\\Entity\\' . $data['tipo'])->name;
  507.         } catch (\Exception $e) {
  508.             throw new \Exception("Entidad no encontrada: " . $data['tipo']);
  509.         }
  511.         $qb = $this->entityManager->createQueryBuilder();
  512.         $qb = $qb->select('e');
  513.         $qb = $qb->from($claseEntity, 'e');
  514.         if (!empty($data['campo'])) {
  515.             $qb = $qb->where($qb->expr()->eq('e.' . $data['campo'], ':valor'))
  516.                 ->setParameter('valor', $data['id']);
  517.         }
  518.         if (!empty($data['usuario'])) {
  519.             $qb = $qb->addSelect('u')
  520.                 ->join('e.usuario', 'u')
  521.                 ->where('u.idUsu = :usuario')
  522.                 ->setParameter('usuario', $data['usuario']);
  523.         }
  524.         $qb = $qb->getQuery();
  525.         if($control === 'multiple'){
  526.             $qb = $qb->getResult();
  527.         } else {
  528.             $qb = $qb->getOneOrNullResult();
  529.         }
  530.         return $qb;
  531.     }
  533.     private function mapeoTipoEquipo(string|null $tipo){
  534.         $mappings = [
  535.             'Equipo'   => ['metodo_id' => 'getIdEqu', 'metodo_marca' => 'getIdMarca',  'atributo' => 'idEqu', 'singular' => 'Equipo', 'plural' => 'Equipos'],
  536.             'Impresora'=> ['metodo_id' => 'getIdImp', 'metodo_marca' => 'getMarca',  'atributo' => 'idImp', 'singular' => 'Impresora', 'plural' => 'Impresoras'],
  537.             'Red'      => ['metodo_id' => 'getIdRed', 'metodo_marca' => 'getMarca',  'atributo' => 'idRed', 'singular' => 'Red', 'plural' => 'Redes'],
  538.             'Otro'     => ['metodo_id' => 'getIdOtro', 'metodo_marca' => 'getMarca', 'atributo' => 'idOtro', 'singular' => 'Otro', 'plural' => 'Otros'],
  539.         ];
  540.         if (!in_array($tipo, ['Equipo', 'Impresora', 'Red', 'Otro'], true)) {
  541.             //throw new \InvalidArgumentException("Tipo de equipo no válido: " . $tipo);
  542.             return $mappings;
  543.         } else {
  544.             return $mappings[$tipo];
  545.         }
  546.     }
  547. }