src/Controller/ApiAdminController.php line 376

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  6. use Symfony\Component\HttpFoundation\JsonResponse;
  7. use Symfony\Component\HttpFoundation\Request;
  8. use Symfony\Component\Security\Http\Authentication\UserAuthenticatorInterface;
  9. use Symfony\Component\Routing\Annotation\Route;
  11. use App\Repository\PcConvocatoriasRepository;
  12. use App\Entity\PcConvocatorias;
  13. use App\Entity\PcCriterios;
  14. use App\Repository\PcCriteriosRepository;
  15. use App\Entity\PcCriteriosConvocatorias;
  16. use App\Repository\PcCriteriosConvocatoriasRepository;
  17. use App\Repository\PcPostulacionRepository;
  18. use App\Service\ValidacionService;
  19. use App\Repository\RegionRepository;
  21. use Symfony\Component\Validator\Validator\ValidatorInterface;
  22. use Symfony\Component\HttpFoundation\Response;
  23. use Symfony\Component\HttpFoundation\File\Exception\FileNotFoundException;
  24. use Symfony\Component\HttpFoundation\BinaryFileResponse;
  25. use Symfony\Component\HttpFoundation\ResponseHeaderBag;
  26. use App\Service\RacService;
  27. use App\Repository\PcPuntoCulturaRepository;
  28. use Symfony\Component\Security\Core\Security;
  29. use Symfony\Bundle\SecurityBundle\Attribute\IsGranted;
  30. use DateTime;
  33. /**
  34.  * @Route("/api/admin", name="api_admin_")
  35.  */
  36. class ApiAdminController extends AbstractController
  37. {
  38.     #[Route('/login', name: 'login', methods: ['POST'])]
  39.     public function login(Request $request): JsonResponse
  40.     {
  41.         // La autenticación será manejada automáticamente por el firewall
  42.         return new JsonResponse(['message' => 'Por favor, envía credenciales válidas']);
  43.     }
  45.     #[Route('/secure/roles', name: 'obtenerRoles', methods: ['GET'])]
  46.     public function obtenerRoles(
  47.         Security $security
  48.     ): JsonResponse
  49.     {
  50.         try {
  51.             $user = $security->getUser();
  52.             if (!$user) {
  53.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  54.             }
  55.             if (!$user->isActivo()) {
  56.                 return new JsonResponse(['error' => 'Usuario no está activo'], JsonResponse::HTTP_FORBIDDEN);
  57.             }
  58.             return $this->json($user->getRoles());
  59.         } catch (\Exception $e) {
  60.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  61.         }
  62.     }
  64.     #[Route('/secure/info', name: 'obtenerInfo', methods: ['GET'])]
  65.     public function obtenerInfo(
  66.         Security $security,
  67.         RegionRepository $regionRepository
  68.     ): JsonResponse
  69.     {
  70.         try {
  71.             $user = $security->getUser();
  72.             if (!$user) {
  73.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  74.             }
  75.             if (!$user->isActivo()) {
  76.                 return new JsonResponse(['error' => 'Usuario no está activo'], JsonResponse::HTTP_FORBIDDEN);
  77.             }
  78.             $regiones = [];
  79.             if($user->isSuperAdmin()){
  80.                 $regiones = $regionRepository->findAll();
  81.             } else  {
  82.                 $regiones = $user->getRegiones();
  83.             }
  84.             $regionesLabel = [];
  85.             foreach($regiones as $regionOb){
  86.                 $regionesLabel[] = $regionOb->getNombre();
  87.             }
  88.             return $this->json([
  89.                 'roles' => $user->getRoles(),
  90.                 'regiones' => $regionesLabel,
  91.                 'maxFileSize' => $_ENV['MAX_FILE_SIZE'] ?? 10,
  92.                 'allowedExtensions' => explode(',', $_ENV['ALLOWED_EXTENSIONS'] ?? '')
  93.             ]);
  94.         } catch (\Exception $e) {
  95.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  96.         }
  97.     }
  99.     #[Route('/secure/convocatorias', name: 'obtenerTodasConvocatorias', methods: ['GET'])]
  100.     public function obtenerTodasConvocatorias(
  101.         PcConvocatoriasRepository $pcConvocatoriaRepository,
  102.         Security $security
  103.     ): JsonResponse
  104.     {
  105.         try {
  106.             $user = $security->getUser();
  107.             if (!$user) {
  108.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  109.             }
  110.             if (!$user->isActivo()) {
  111.                 return new JsonResponse(['error' => 'Usuario no está activo'], JsonResponse::HTTP_FORBIDDEN);
  112.             }
  113.             if (!$this->isGranted('ROLE_SUPER_ADMIN') && !$this->isGranted('ROLE_PU_ADMINISTRADOR_CON')) {
  114.                 return new JsonResponse(['error' => 'Acceso denegado'], 403);
  115.             }
  117.             $convocatorias = $pcConvocatoriaRepository->findAll();
  118.             $data = [];
  119.             foreach ($convocatorias as $convocatoria) {
  120.                 $data[] = [
  121.                     'id' => $convocatoria->getId(),
  122.                     'nombre' => $convocatoria->getNombre(),
  123.                     'anio' => $convocatoria->getAnio(),
  124.                     'estado' => $convocatoria->getEstado(),
  125.                 ];
  126.             }
  127.             return $this->json($data);
  128.         } catch (\Exception $e) {
  129.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  130.         }
  131.     }
  133.     #[Route('/secure/convocatoria/{id}', name: 'obtenerConvocatoria', methods: ['GET'])]
  134.     public function obtenerConvocatoria(
  135.         $id, PcConvocatoriasRepository $pcConvocatoriaRepository,
  136.         Security $security
  137.     ): JsonResponse
  138.     {
  139.         try {
  140.             $user = $security->getUser();
  141.             if (!$user) {
  142.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  143.             }
  144.             if (!$user->isActivo()) {
  145.                 return new JsonResponse(['error' => 'Usuario no está activo'], JsonResponse::HTTP_FORBIDDEN);
  146.             }
  147.             if (!$this->isGranted('ROLE_SUPER_ADMIN') && !$this->isGranted('ROLE_PU_ADMINISTRADOR_CON')) {
  148.                 return new JsonResponse(['error' => 'Acceso denegado'], 403);
  149.             }
  150.             $convocatoria = $pcConvocatoriaRepository->find($id);
  152.             if (!$convocatoria) {
  153.                 return new JsonResponse(['error' => 'Convocatoria no encontrada'], JsonResponse::HTTP_NOT_FOUND);
  154.             }
  155.             $criterios = [];
  156.             $criteriosData = $convocatoria->getCriterios();
  158.             foreach ($criteriosData as $criterioConvocatoria) {
  159.                 $criterios[] = [
  160.                     'id' => $criterioConvocatoria->getCriterios()->getId(),
  161.                     'peso' => $criterioConvocatoria->getPeso()
  162.                 ];
  163.             }
  165.             return $this->json([
  166.                 'id' => $convocatoria->getId(),
  167.                 'nombre' => $convocatoria->getNombre(),
  168.                 'descripcion' => $convocatoria->getDescripcion(),
  169.                 'anio' => $convocatoria->getAnio(),
  170.                 'bases' => $convocatoria->getBases(),
  171.                 'presupuesto' => $convocatoria->getPresupuesto(),
  172.                 'puntajeEvalCorte' => $convocatoria->getPuntajeEvalCorte(),
  173.                 'cuestionarios' => $convocatoria->getCuestionarios(),
  174.                 'documentos' => $convocatoria->getDocumentos(),
  175.                 'estado' => $convocatoria->getEstado(),
  176.                 'criterios' => $criterios,
  177.                 'apertura' => $convocatoria->getApertura(),
  178.             ]);
  179.         } catch (\Exception $e) {
  180.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  181.         }
  182.     }
  184.     #[Route('/secure/convocatoria', name: 'crearConvocatoria', methods: ['POST'])]
  185.     public function crearConvocatoria(
  186.         Request $request,
  187.         PcConvocatoriasRepository $pcConvocatoriaRepository,
  188.         PcCriteriosRepository $pcCriteriosRepository,
  189.         ValidatorInterface $validator,
  190.         ValidacionService $validacionService,
  191.         PcCriteriosConvocatoriasRepository $pcCriteriosConvocatoriasRepository,
  192.         Security $security
  193.     ): JsonResponse
  194.     {
  195.         try {
  196.             $user = $security->getUser();
  197.             if (!$user) {
  198.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  199.             }
  200.             if (!$user->isActivo()) {
  201.                 return new JsonResponse(['error' => 'Usuario no está activo'], JsonResponse::HTTP_FORBIDDEN);
  202.             }
  203.             if (!$this->isGranted('ROLE_SUPER_ADMIN') && !$this->isGranted('ROLE_PU_ADMINISTRADOR_CON')) {
  204.                 return new JsonResponse(['error' => 'Acceso denegado'], 403);
  205.             }
  206.             $data = json_decode($request->getContent(), true);
  208.             if (!$validacionService->validacionesOrNulo([
  209.                 $data['nombre'],
  210.                 $data['descripcion']
  211.             ], 'string')) {
  212.                 return new JsonResponse(['error' => 'Los campos de nombre, descripcion, estado  deben ser texto'], JsonResponse::HTTP_BAD_REQUEST);
  213.             }
  214.             if (!$validacionService->validacionesOrNulo([
  215.                 $data['apertura']
  216.             ], 'boolean')) {
  217.                 return new JsonResponse(['error' => 'Apertura  debe ser boolean'], JsonResponse::HTTP_BAD_REQUEST);
  218.             }
  219.             if (!$validacionService->validacionesOrNulo([
  220.                 $data['presupuesto'],
  221.                 $data['anio'],
  222.                 $data['puntajeEvalCorte']
  223.             ], 'integer')) {
  224.                 return new JsonResponse(['error' => 'Los campos presupuesto, anio y puntajeEvalCorte debe ser numerico'], JsonResponse::HTTP_BAD_REQUEST);
  225.             }
  226.             if (!$validacionService->validacionesOrNulo([
  227.                 $data['bases'],
  228.                 $data['cuestionarios'],
  229.                 $data['documentos']
  230.             ], 'array')) {
  231.                 return new JsonResponse(['error' => 'Los campos de bases, cuestionarios y documentos deben ser objetos'], JsonResponse::HTTP_BAD_REQUEST);
  232.             }
  234.             $convocatoria = new PcConvocatorias();
  235.             $convocatoria->setNombre($data['nombre']);
  236.             $convocatoria->setDescripcion($data['descripcion']);
  237.             $convocatoria->setAnio((string) $data['anio']);
  238.             $convocatoria->setBases($data['bases']);
  239.             $convocatoria->setPresupuesto($data['presupuesto']);
  240.             $convocatoria->setPuntajeEvalCorte($data['puntajeEvalCorte']);
  241.             $convocatoria->setCuestionarios($data['cuestionarios']);
  242.             $convocatoria->setDocumentos($data['documentos']);
  243.             $convocatoria->setApertura($data['apertura']);
  244.             if($data['apertura']){
  245.                 $convocatoria->setEstado('1');
  246.             }
  247.             // Validar con Symfony Validator
  248.             $errors = $validator->validate($convocatoria);
  249.             if (count($errors) > 0) {
  250.                 $errorMessages = [];
  251.                 foreach ($errors as $error) {
  252.                     $errorMessages[] = $error->getMessage();
  253.                 }
  254.                 return new JsonResponse(['error' => $errorMessages], JsonResponse::HTTP_BAD_REQUEST);
  255.             }
  257.             $pcConvocatoriaRepository->save($convocatoria, true);
  259.             if (isset($data['criterios'])) {
  260.                 foreach ($data['criterios'] as $criterioData) {
  261.                     // Buscar el criterio por ID
  262.                     $criterio = $pcCriteriosRepository->find($criterioData['id']);
  263.                     if ($criterio) {
  264.                         // Crear la relación entre la convocatoria y el criterio
  265.                         $criteriosConvocatoria = new PcCriteriosConvocatorias();
  266.                         $criteriosConvocatoria->setConvocatorias($convocatoria);
  267.                         $criteriosConvocatoria->setCriterios($criterio);
  268.                         $criteriosConvocatoria->setPeso($criterioData['peso']); // Asignar el peso
  270.                         // Usar el repository para guardar la relación
  271.                         $pcCriteriosConvocatoriasRepository->save($criteriosConvocatoria, true);
  272.                     }
  273.                 }
  274.             }
  275.             $convocatoriaObj = [
  276.                 'id' => $convocatoria->getId(),
  277.                 'nombre' => $convocatoria->getNombre(),
  278.                 'descripcion' => $convocatoria->getDescripcion(),
  279.                 'anio' => $convocatoria->getAnio(),
  280.                 'bases' => $convocatoria->getBases(),
  281.                 'presupuesto' => $convocatoria->getPresupuesto(),
  282.                 'puntajeEvalCorte' => $convocatoria->getPuntajeEvalCorte(),
  283.                 'cuestionarios' => $convocatoria->getCuestionarios(),
  284.                 'documentos' => $convocatoria->getDocumentos(),
  285.                 'estado' => $convocatoria->getEstado(),
  286.                 'criterios' => $data['criterios'],
  287.                 'apertura' => $convocatoria->getApertura(),
  288.             ];
  289.             return new JsonResponse(['message' => 'Convocatoria creada con éxito', 'convocatoria' => $convocatoriaObj ], JsonResponse::HTTP_CREATED);
  291.         } catch (\Exception $e) {
  292.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  293.         }
  294.     }
  296.     #[Route('/secure/convocatoria/{id}', name: 'actualizarConvocatoria', methods: ['PUT'])]
  297.     public function actualizarConvocatoria(
  298.         $id,
  299.         Request $request,
  300.         PcConvocatoriasRepository $pcConvocatoriaRepository,
  301.         PcCriteriosRepository $pcCriteriosRepository,
  302.         ValidatorInterface $validator,
  303.         ValidacionService $validacionService,
  304.         PcCriteriosConvocatoriasRepository $pcCriteriosConvocatoriasRepository,
  305.         Security $security
  306.     ): JsonResponse
  307.     {
  308.         try {
  309.             $user = $security->getUser();
  310.             if (!$user) {
  311.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  312.             }
  313.             if (!$user->isActivo()) {
  314.                 return new JsonResponse(['error' => 'Usuario no está activo'], JsonResponse::HTTP_FORBIDDEN);
  315.             }
  316.             if (!$this->isGranted('ROLE_SUPER_ADMIN') && !$this->isGranted('ROLE_PU_ADMINISTRADOR_CON')) {
  317.                 return new JsonResponse(['error' => 'Acceso denegado'], 403);
  318.             }
  320.             $convocatoria = $pcConvocatoriaRepository->find($id);
  322.             if (!$convocatoria) {
  323.                 return new JsonResponse(['error' => 'Convocatoria no encontrada'], JsonResponse::HTTP_NOT_FOUND);
  324.             }
  326.             $data = json_decode($request->getContent(), true);
  327.             if (!$validacionService->validacionesOrNulo([
  328.                 $data['nombre'],
  329.                 $data['descripcion'],
  330.                 $data['estado']
  331.             ], 'string')) {
  332.                 return new JsonResponse(['error' => 'Los campos de nombre, descripcion, estado  deben ser texto'], JsonResponse::HTTP_BAD_REQUEST);
  333.             }
  334.             if (!$validacionService->validacionesOrNulo([
  335.                 $data['apertura']
  336.             ], 'boolean')) {
  337.                 return new JsonResponse(['error' => 'Apertura  debe ser boolean'], JsonResponse::HTTP_BAD_REQUEST);
  338.             }
  339.             if (!$validacionService->validacionesOrNulo([
  340.                 $data['presupuesto'],
  341.                 $data['anio'],
  342.                 $data['puntajeEvalCorte']
  343.             ], 'integer')) {
  344.                 return new JsonResponse(['error' => 'Los campos presupuesto, anio y puntajeEvalCorte debe ser numerico'], JsonResponse::HTTP_BAD_REQUEST);
  345.             }
  346.             if (!$validacionService->validacionesOrNulo([
  347.                 $data['bases'],
  348.                 $data['cuestionarios'],
  349.                 $data['documentos']
  350.             ], 'array')) {
  351.                 return new JsonResponse(['error' => 'Los campos de bases, cuestionarios y documentos deben ser objetos'], JsonResponse::HTTP_BAD_REQUEST);
  352.             }
  354.             $aperturaExistente = $convocatoria->getApertura();
  355.             if($aperturaExistente){
  356.                 if(empty($data['estado'])){
  357.                     return new JsonResponse(['error' => 'Estado no puede ser nulo porque la convocatoria ya esta aperturada'], JsonResponse::HTTP_BAD_REQUEST);
  358.                 }
  359.                 $convocatoria->setEstado($data['estado']);
  360.             } else {
  361.                 $convocatoria->setNombre($data['nombre']);
  362.                 $convocatoria->setDescripcion($data['descripcion']);
  363.                 $convocatoria->setAnio((string) $data['anio']);
  364.                 $convocatoria->setBases($data['bases']);
  365.                 $convocatoria->setPresupuesto($data['presupuesto']);
  366.                 $convocatoria->setPuntajeEvalCorte($data['puntajeEvalCorte']);
  367.                 $convocatoria->setCuestionarios($data['cuestionarios']);
  368.                 $convocatoria->setDocumentos($data['documentos']);
  369.                 $convocatoria->setApertura($data['apertura']);
  370.                 if($data['apertura']){
  371.                     $convocatoria->setEstado('1');
  372.                 }
  373.             }
  375.                 // Validar con Symfony Validator
  376.                 $errors = $validator->validate($convocatoria);
  377.                 if (count($errors) > 0) {
  378.                     $errorMessages = [];
  379.                     foreach ($errors as $error) {
  380.                         $errorMessages[] = $error->getMessage();
  381.                     }
  382.                     return new JsonResponse(['error' => $errorMessages], JsonResponse::HTTP_BAD_REQUEST);
  383.                 }
  385.             $pcConvocatoriaRepository->save($convocatoria, true);
  387.             if (!$aperturaExistente && isset($data['criterios'])) {
  388.                 // Eliminar los criterios actuales
  389.                 foreach ($convocatoria->getCriterios() as $criterioConvocatoria) {
  390.                     $pcCriteriosConvocatoriasRepository->remove($criterioConvocatoria, true);
  391.                 }
  393.                 // Agregar los nuevos criterios
  394.                 foreach ($data['criterios'] as $criterioData) {
  395.                     // Buscar el criterio por ID
  396.                     $criterio = $pcCriteriosRepository->find($criterioData['id']);
  397.                     if ($criterio) {
  398.                         // Verificar si el criterio ya está asociado a la convocatoria
  399.                         $criteriosConvocatoria = new PcCriteriosConvocatorias();
  400.                         $criteriosConvocatoria->setConvocatorias($convocatoria);
  401.                         $criteriosConvocatoria->setCriterios($criterio);
  402.                         $criteriosConvocatoria->setPeso($criterioData['peso']); // Asignar el peso
  404.                         // Usar el repository para guardar la relación
  405.                         $pcCriteriosConvocatoriasRepository->save($criteriosConvocatoria, true);
  406.                     }
  407.                 }
  408.             }
  409.             $convocatoriaObj = [
  410.                 'id' => $convocatoria->getId(),
  411.                 'nombre' => $convocatoria->getNombre(),
  412.                 'descripcion' => $convocatoria->getDescripcion(),
  413.                 'anio' => $convocatoria->getAnio(),
  414.                 'bases' => $convocatoria->getBases(),
  415.                 'presupuesto' => $convocatoria->getPresupuesto(),
  416.                 'puntajeEvalCorte' => $convocatoria->getPuntajeEvalCorte(),
  417.                 'cuestionarios' => $convocatoria->getCuestionarios(),
  418.                 'documentos' => $convocatoria->getDocumentos(),
  419.                 'estado' => $convocatoria->getEstado(),
  420.                 'criterios' => $data['criterios'],
  421.                 'apertura' => $convocatoria->getApertura(),
  422.             ];
  423.             return new JsonResponse(['message' => 'Convocatoria actualizada con éxito', 'convocatoria' => $convocatoriaObj]);
  425.         } catch (\Exception $e) {
  426.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  427.         }
  428.     }
  430.     #[Route('/secure/criterios', name: 'obtenerCriterios', methods: ['GET'])]
  431.     public function obtenerCriterios(
  432.         PcCriteriosRepository $pcCriteriosRepository,
  433.         Security $security
  434.     ): JsonResponse
  435.     {
  436.         try {
  437.             $user = $security->getUser();
  438.             if (!$user) {
  439.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  440.             }
  441.             if (!$user->isActivo()) {
  442.                 return new JsonResponse(['error' => 'Usuario no está activo'], JsonResponse::HTTP_FORBIDDEN);
  443.             }
  444.             if (!$this->isGranted('ROLE_SUPER_ADMIN') && !$this->isGranted('ROLE_PU_ADMINISTRADOR_CON')) {
  445.                 return new JsonResponse(['error' => 'Acceso denegado'], 403);
  446.             }
  447.             $criterios = $pcCriteriosRepository->findAll();
  448.             $data = [];
  449.             foreach ($criterios as $criterio) {
  450.                 $data[] = [
  451.                     'id' => $criterio->getId(),
  452.                     'nombre' => $criterio->getNombre(),
  453.                     'descripcion' => $criterio->getDescripcion(),
  454.                     'puntajes' => $criterio->getPuntajes(),
  455.                 ];
  456.             }
  457.             return $this->json($data);
  458.         } catch (\Exception $e) {
  459.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  460.         }
  461.     }
  463.     #[Route('/secure/criterio', name: 'crearCriterio', methods: ['POST'])]
  464.     public function crearCriterio(
  465.         Request $request,
  466.         PcConvocatoriasRepository $pcConvocatoriaRepository,
  467.         PcCriteriosRepository $pcCriteriosRepository,
  468.         ValidatorInterface $validator,
  469.         ValidacionService $validacionService,
  470.         PcCriteriosConvocatoriasRepository $pcCriteriosConvocatoriasRepository,
  471.         Security $security
  472.     ): JsonResponse
  473.     {
  474.         try {
  475.             $user = $security->getUser();
  476.             if (!$user) {
  477.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  478.             }
  479.             if (!$user->isActivo()) {
  480.                 return new JsonResponse(['error' => 'Usuario no está activo'], JsonResponse::HTTP_FORBIDDEN);
  481.             }
  482.             if (!$this->isGranted('ROLE_SUPER_ADMIN') && !$this->isGranted('ROLE_PU_ADMINISTRADOR_CON')) {
  483.                 return new JsonResponse(['error' => 'Acceso denegado'], 403);
  484.             }
  485.             $data = json_decode($request->getContent(), true);
  486.             if (!$validacionService->validacionesOrNulo([
  487.                 $data['nombre'],
  488.                 $data['descripcion'],
  489.             ], 'string')) {
  490.                 return new JsonResponse(['error' => 'Los campos de  nombre y descripción deben ser texto'], JsonResponse::HTTP_BAD_REQUEST);
  491.             }
  493.             if (!$validacionService->validacionesOrNulo([
  494.                 $data['puntajes'],
  495.             ], 'array')) {
  496.                 return new JsonResponse(['error' => 'Los campos de puntajes deben ser objetos'], JsonResponse::HTTP_BAD_REQUEST);
  497.             }
  499.             $criterio = new PcCriterios();
  500.             $criterio->setNombre($data['nombre']);
  501.             $criterio->setDescripcion($data['descripcion']);
  502.             $criterio->setPuntajes($data['puntajes']);
  504.             // Validar con Symfony Validator
  505.             $errors = $validator->validate($criterio);
  506.             if (count($errors) > 0) {
  507.                 $errorMessages = [];
  508.                 foreach ($errors as $error) {
  509.                     $errorMessages[] = $error->getMessage();
  510.                 }
  511.                 return new JsonResponse(['error' => $errorMessages], JsonResponse::HTTP_BAD_REQUEST);
  512.             }
  514.             $pcCriteriosRepository->save($criterio, true);
  516.             $criterioObj = [
  517.                 'id' => $criterio->getId(),
  518.                 'nombre' => $criterio->getNombre(),
  519.                 'descripcion' => $criterio->getDescripcion(),
  520.                 'puntajes' => $criterio->getPuntajes(),
  521.             ];
  522.             return new JsonResponse(['message' => 'Criterio creado con éxito', 'criterio' => $criterioObj ], JsonResponse::HTTP_CREATED);
  524.         } catch (\Exception $e) {
  525.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  526.         }
  527.     }
  529.     #[Route('/secure/criterio/{id}', name: 'editarCriterio', methods: ['PUT'])]
  530.     public function editarCriterio(
  531.         $id,
  532.         Request $request,
  533.         PcConvocatoriasRepository $pcConvocatoriaRepository,
  534.         PcCriteriosRepository $pcCriteriosRepository,
  535.         ValidatorInterface $validator,
  536.         ValidacionService $validacionService,
  537.         PcCriteriosConvocatoriasRepository $pcCriteriosConvocatoriasRepository,
  538.         Security $security
  539.     ): JsonResponse
  540.     {
  541.         try {
  542.             $user = $security->getUser();
  543.             if (!$user) {
  544.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  545.             }
  546.             if (!$user->isActivo()) {
  547.                 return new JsonResponse(['error' => 'Usuario no está activo'], JsonResponse::HTTP_FORBIDDEN);
  548.             }
  549.             if (!$this->isGranted('ROLE_SUPER_ADMIN') && !$this->isGranted('ROLE_PU_ADMINISTRADOR_CON')) {
  550.                 return new JsonResponse(['error' => 'Acceso denegado'], 403);
  551.             }
  552.             $data = json_decode($request->getContent(), true);
  553.             if (!$validacionService->validacionesOrNulo([
  554.                 $data['nombre'],
  555.                 $data['descripcion'],
  556.             ], 'string')) {
  557.                 return new JsonResponse(['error' => 'Los campos de  nombre y descripción deben ser texto'], JsonResponse::HTTP_BAD_REQUEST);
  558.             }
  560.             if (!$validacionService->validacionesOrNulo([
  561.                 $data['puntajes'],
  562.             ], 'array')) {
  563.                 return new JsonResponse(['error' => 'Los campos de puntajes deben ser objetos'], JsonResponse::HTTP_BAD_REQUEST);
  564.             }
  566.             $criterio = $pcCriteriosRepository->find($id);
  568.             if(!$criterio){
  569.                 return new JsonResponse(['error' => 'Criterio no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  570.             }
  571.             $criterio->setNombre($data['nombre']);
  572.             $criterio->setDescripcion($data['descripcion']);
  573.             $criterio->setPuntajes($data['puntajes']);
  575.             // Validar con Symfony Validator
  576.             $errors = $validator->validate($criterio);
  577.             if (count($errors) > 0) {
  578.                 $errorMessages = [];
  579.                 foreach ($errors as $error) {
  580.                     $errorMessages[] = $error->getMessage();
  581.                 }
  582.                 return new JsonResponse(['error' => $errorMessages], JsonResponse::HTTP_BAD_REQUEST);
  583.             }
  585.             $pcCriteriosRepository->save($criterio, true);
  587.             $criterioObj = [
  588.                 'id' => $criterio->getId(),
  589.                 'nombre' => $criterio->getNombre(),
  590.                 'descripcion' => $criterio->getDescripcion(),
  591.                 'puntajes' => $criterio->getPuntajes(),
  592.             ];
  593.             return new JsonResponse(['message' => 'Criterio actualizado con éxito', 'criterio' => $criterioObj ], JsonResponse::HTTP_CREATED);
  595.         } catch (\Exception $e) {
  596.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  597.         }
  598.     }
  600.     /**
  601.      * @Route("/secure/upload-file", name="uploadFile", methods={"POST"})
  602.      */
  603.     public function uploadFile(Request $request,
  604.         Security $security
  605.     ): JsonResponse
  606.     {
  607.         try {
  608.             $user = $security->getUser();
  609.             if (!$user) {
  610.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  611.             }
  612.             if (!$user->isActivo()) {
  613.                 return new JsonResponse(['error' => 'Usuario no está activo'], JsonResponse::HTTP_FORBIDDEN);
  614.             }
  615.             if(
  616.             !$this->isGranted('ROLE_SUPER_ADMIN') &&
  617.             !$this->isGranted('ROLE_PU_ADMINISTRADOR_CON') &&
  618.             !$this->isGranted('ROLE_PU_SUPERVISOR_POS') &&
  619.             !$this->isGranted('ROLE_PU_EVALUADOR_SEL') &&
  620.             !$this->isGranted('ROLE_PU_EVALUADOR_COL') &&
  621.             !$this->isGranted('ROLE_PU_EVALUADOR_ADM')
  622.             ){
  623.                 return new JsonResponse(['error' => 'Acceso denegado'], 403);
  624.             }
  625.             $file = $request->files->get('file');
  626.             if (!$file) {
  627.                 return new JsonResponse(['error' => 'No hay documento'], 400);
  628.             }
  630.             try {
  631.                 $originalName = $file->getClientOriginalName();
  632.                 $newFilename = str_replace(' ', '_', $originalName) . '-' . uniqid() . '.' . $file->guessExtension();
  634.                 $projectRoot = $this->getParameter('kernel.project_dir');
  635.                 $dirToMove = $projectRoot . '/public/documentos/subidas';
  637.                 if (!is_dir($dirToMove)) {
  638.                     mkdir($dirToMove, 0777, true);
  639.                 }
  641.                 $file->move($dirToMove, $newFilename);
  643.                 return new JsonResponse([
  644.                     'message' => 'Documento subido con exito',
  645.                     'original_name' => $originalName,
  646.                     'new_filename' => $newFilename,
  647.                     'path' => '/documentos/subidas/' . $newFilename,
  648.                 ], 200);
  649.             } catch (FileException $e) {
  650.                 return new JsonResponse(['error' => 'Falla al subir archivo: ' . $e->getMessage()], 500);
  651.             }
  652.         } catch (\Exception $e) {
  653.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  654.         }
  655.     }
  657.     /**
  658.      * @Route("/secure/download-file/{filename}", name="downloadFile", methods={"GET"})
  659.      */
  660.     public function downloadFile(
  661.         string $filename,
  662.         Security $security
  663.         ): Response
  664.     {
  665.         try {
  666.             $user = $security->getUser();
  667.             if (!$user) {
  668.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  669.             }
  670.             if (!$user->isActivo()) {
  671.                 return new JsonResponse(['error' => 'Usuario no está activo'], JsonResponse::HTTP_FORBIDDEN);
  672.             }
  673.             if(
  674.             !$this->isGranted('ROLE_SUPER_ADMIN') &&
  675.             !$this->isGranted('ROLE_PU_ADMINISTRADOR_CON') &&
  676.             !$this->isGranted('ROLE_PU_SUPERVISOR_POS') &&
  677.             !$this->isGranted('ROLE_PU_EVALUADOR_SEL') &&
  678.             !$this->isGranted('ROLE_PU_EVALUADOR_COL') &&
  679.             !$this->isGranted('ROLE_PU_EVALUADOR_ADM')
  680.             ){
  681.                 return new JsonResponse(['error' => 'Acceso denegado'], 403);
  682.             }
  683.             $projectRoot = $this->getParameter('kernel.project_dir');
  684.             $filePath = $projectRoot . '/public/documentos/subidas/' . $filename;
  686.             if (!file_exists($filePath)) {
  687.                 throw $this->createNotFoundException("Archivo no encontrado: $filename");
  688.             }
  689.             // Devolver el archivo como una respuesta
  690.             $response = new BinaryFileResponse($filePath);
  691.             $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT, $filename);
  693.             return $response;
  694.         } catch (\Exception $e) {
  695.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  696.         }
  697.     }
  699.     #[Route('/secure/cargar', name: 'cargar', methods: ['POST'])]
  700.     public function cargarArchivos(
  701.         Request $request,
  702.         Security $security
  703.     ): JsonResponse
  704.     {
  705.         try {
  706.             $user = $security->getUser();
  707.             if (!$user) {
  708.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  709.             }
  710.             if (!$user->isActivo()) {
  711.                 return new JsonResponse(['error' => 'Usuario no está activo'], JsonResponse::HTTP_FORBIDDEN);
  712.             }
  713.             if(
  714.             !$this->isGranted('ROLE_SUPER_ADMIN') &&
  715.             !$this->isGranted('ROLE_PU_ADMINISTRADOR_CON') &&
  716.             !$this->isGranted('ROLE_PU_SUPERVISOR_POS') &&
  717.             !$this->isGranted('ROLE_PU_EVALUADOR_SEL') &&
  718.             !$this->isGranted('ROLE_PU_EVALUADOR_COL') &&
  719.             !$this->isGranted('ROLE_PU_EVALUADOR_ADM')
  720.             ){
  721.                 return new JsonResponse(['error' => 'Acceso denegado'], 403);
  722.             }
  723.             $file = $request->files->get('file');
  724.             if (!$file) {
  725.                 return new JsonResponse(['error' => 'No hay documento'], 400);
  726.             }
  728.             // Obtener configuración desde .env
  729.             $maxFileSizeMB = $_ENV['MAX_FILE_SIZE'] ?? 10;
  730.             $allowedExtensions = explode(',', $_ENV['ALLOWED_EXTENSIONS'] ?? '');
  732.             // Validar tamaño del archivo
  733.             $fileSizeMB = $file->getSize() / (1024 * 1024); // Convertir a MB
  734.             if ($fileSizeMB > $maxFileSizeMB) {
  735.                 return new JsonResponse(['error' => "El archivo supera el tamaño máximo permitido de {$maxFileSizeMB}MB"], 400);
  736.             }
  738.             // Validar extensión
  739.             $extension = $file->guessExtension();
  740.             if (!in_array($extension, $allowedExtensions)) {
  741.                 return new JsonResponse(['error' => "Extensión no permitida. Solo se aceptan: " . implode(', ', $allowedExtensions)], 400);
  742.             }
  744.             $postulacionId = $request->request->get('postulacionId');
  745.             $puntoCulturaId = $request->request->get('puntoCulturaId');
  746.             $convocatoriaId = $request->request->get('convocatoriaId');
  748.             $tipoDocumento = '';
  750.             if(!empty($postulacionId)){
  751.                 $tipoDocumento="/pcpostulaciones/postulacion_" . $postulacionId;
  752.             } else if (!empty($puntoCulturaId)){
  753.                 $tipoDocumento="/puntoscultura/puntocultura_" . $puntoCulturaId;
  754.             } else if (!empty($convocatoriaId)) {
  755.                 $tipoDocumento="/pcconvocatorias/convocatoria_" . $convocatoriaId;
  756.             } else {
  757.                 return new JsonResponse(['error' => 'postulacionId, puntoCulturaId o convocatoriaId requerido'], 400);
  758.             }
  760.             try {
  761.                 $originalName = $file->getClientOriginalName();
  762.                 $newFilename = str_replace(' ', '_', $originalName) . '-' . uniqid() . '.' . $file->guessExtension();
  764.                 $projectRoot = $this->getParameter('kernel.project_dir');
  765.                 $dirToMove = $projectRoot . '/public/documentos' . $tipoDocumento;
  767.                 if (!is_dir($dirToMove)) {
  768.                     mkdir($dirToMove, 0777, true);
  769.                 }
  771.                 $file->move($dirToMove, $newFilename);
  773.                 return new JsonResponse([
  774.                     'message' => 'Documento subido con exito',
  775.                     'original_name' => $originalName,
  776.                     'new_filename' => $newFilename,
  777.                     'path' => '/documentos' . $tipoDocumento . '/' . $newFilename,
  778.                 ], 200);
  779.             } catch (FileException $e) {
  780.                 return new JsonResponse(['error' => 'Falla al subir archivo: ' . $e->getMessage()], 500);
  781.             }
  782.         } catch (\Exception $e) {
  783.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  784.         }
  785.     }
  788.     #[Route('/secure/descargas', name: 'descargas', methods: ['POST'])]
  789.     public function descargas(
  790.         Request $request,
  791.         PcPostulacionRepository $pcPostulacionRepository,
  792.         ValidacionService $validacionService,
  793.         Security $security
  794.     ): Response
  795.     {
  796.         try {
  797.             //POSTULACION
  798.             //PUNTO CULTURA
  799.             //CONVOCATORIA
  800.             //POSTULACION PUNTO CULTURA
  801.             $user = $security->getUser();
  802.             if (!$user) {
  803.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  804.             }
  805.             if (!$user->isActivo()) {
  806.                 return new JsonResponse(['error' => 'Usuario no está activo'], JsonResponse::HTTP_FORBIDDEN);
  807.             }
  808.             if(
  809.             !$this->isGranted('ROLE_SUPER_ADMIN') &&
  810.             !$this->isGranted('ROLE_PU_ADMINISTRADOR_CON') &&
  811.             !$this->isGranted('ROLE_PU_SUPERVISOR_POS') &&
  812.             !$this->isGranted('ROLE_PU_EVALUADOR_SEL') &&
  813.             !$this->isGranted('ROLE_PU_EVALUADOR_COL') &&
  814.             !$this->isGranted('ROLE_PU_EVALUADOR_ADM')
  815.             ){
  816.                 return new JsonResponse(['error' => 'Acceso denegado'], 403);
  817.             }
  819.             $data = json_decode($request->getContent(), true);
  820.             $path = $data['path'];
  822.             if(empty($path)){
  823.                 return new JsonResponse(['error' => 'Falta enviar path'],
  824.                     JsonResponse::HTTP_BAD_REQUEST);
  825.             }
  827.             // $rutaAlArchivo = explode("/", $path);
  829.             $projectRoot = $this->getParameter('kernel.project_dir');
  830.             $filePath = $projectRoot . '/public' . $path;
  832.             if (!file_exists($filePath)) {
  833.                 throw $this->createNotFoundException("Archivo no encontrado");
  834.             }
  836.             $rutasArchivo = explode("/", $path);
  837.             $filename = $rutasArchivo[count($rutasArchivo)-1];
  838.             // Devolver el archivo como una respuesta
  839.             $response = new BinaryFileResponse($filePath);
  840.             $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT, $filename);
  842.             return $response;
  843.         } catch (\Exception $e) {
  844.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  845.         }
  846.     }
  848.     #[Route('/secure/postulacion/{id}', name: 'obtenerPostulacion', methods: ['GET'])]
  849.     public function obtenerPostulacion(
  850.         $id, PcPostulacionRepository $pcPostulacionRepository,
  851.         Security $security
  852.     ): JsonResponse
  853.     {
  854.         try {
  855.             $user = $security->getUser();
  856.             if (!$user) {
  857.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  858.             }
  859.             if (!$user->isActivo()) {
  860.                 return new JsonResponse(['error' => 'Usuario no está activo'], JsonResponse::HTTP_FORBIDDEN);
  861.             }
  862.             if(
  863.             !$this->isGranted('ROLE_SUPER_ADMIN') &&
  864.             !$this->isGranted('ROLE_PU_ADMINISTRADOR_CON') &&
  865.             !$this->isGranted('ROLE_PU_SUPERVISOR_POS') &&
  866.             !$this->isGranted('ROLE_PU_EVALUADOR_SEL') &&
  867.             !$this->isGranted('ROLE_PU_EVALUADOR_COL') &&
  868.             !$this->isGranted('ROLE_PU_EVALUADOR_ADM')
  869.             ){
  870.                 return new JsonResponse(['error' => 'Acceso denegado'], 403);
  871.             }
  872.             $postulacion = $pcPostulacionRepository->find($id);
  874.             if (!$postulacion) {
  875.                 return new JsonResponse(['error' => 'Postulacion no encontrada'], JsonResponse::HTTP_NOT_FOUND);
  876.             }
  878.             $usuarioAdmisibilidad = $postulacion->getUsuarioAdmisibilidad();
  879.             $usuarioEvaluacion = $postulacion->getUsuarioEvaluacion();
  880.             $usuarioSeleccion = $postulacion->getUsuarioSeleccion();
  882.             return $this->json([
  883.                 'id' => $postulacion->getId(),
  884.                 'montoRequerido' => $postulacion->getMontoRequerido(),
  885.                 'formularioPostulacion' => $postulacion->getFormularioPostulacion(),
  886.                 'documentosPostulacion' => $postulacion->getDocumentosPostulacion(),
  887.                 'certificadoPostulacion' => $postulacion->getCertificadoPostulacion(),
  888.                 'resultadoAdmisibilidad' => $postulacion->getResultadoAdmisibilidad(),
  889.                 'estadoAdmisibilidad' => $postulacion->getEstadoAdmisibilidad(),
  890.                 'formularioAdmisibilidad' => $postulacion->getFormularioAdmisibilidad(),
  891.                 'notaFinalEvaluacion' => $postulacion->getNotaFinalEvaluacion(),
  892.                 'formularioEvaluacion' => $postulacion->getFormularioEvaluacion(),
  893.                 'estadoEvaluacion' => $postulacion->getEstadoEvaluacion(),
  894.                 'formularioSeleccion' => $postulacion->getFormularioSeleccion(),
  895.                 'estadoSeleccion' => $postulacion->getEstadoSeleccion(),
  896.                 'formularioSeleccion' => $postulacion->getFormularioSeleccion(),
  897.                 'estado' => $postulacion->getEstado(),
  898.                 'resultadoSeleccion' => $postulacion->getResultadoSeleccion(),
  899.                 'montoAdjudicado' => $postulacion->getMontoAdjudicado(),
  900.                 'usuarioAdmisibilidad' => $usuarioAdmisibilidad ? $usuarioAdmisibilidad->getNombres() : null,
  901.                 'usuarioEvaluacion' => $usuarioEvaluacion ? $usuarioEvaluacion->getNombres() : null,
  902.                 'usuarioSeleccion' => $usuarioSeleccion ? $usuarioSeleccion->getNombres() : null,
  903.                 'admisibilidadAt' => $postulacion->getAdmisibilidadAt(),
  904.                 'evaluacionAt' => $postulacion->getEvaluacionAt(),
  905.                 'seleccionAt' => $postulacion->getSeleccionAt(),
  906.                 'anexos' => $postulacion->getDocumentos(),
  907.                 'convocatoriaId' => $postulacion->getConvocatoria()->getId(),
  908.                 'convocatoriaNombre' => $postulacion->getConvocatoria()->getNombre(),
  909.                 'puntoCulturaId' => $postulacion->getPuntoCultura()->getId(),
  910.                 'editarAdminsibilidad' => $postulacion->isEditableAdmisibilidad(),
  911.                 'editarColectivo' => $postulacion->isEditableEvaluacion(),
  912.                 'editarSeleccion' => $postulacion->isEditableSeleccion(),
  913.             ]);
  915.         } catch (\Exception $e) {
  916.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  917.         }
  918.     }
  920.     #[Route('/secure/postulaciones', name: 'obtenerPostulaciones', methods: ['GET'])]
  921.     public function obtenerPostulaciones(
  922.         PcPostulacionRepository $pcPostulacionRepository,
  923.         Security $security
  924.     ): JsonResponse
  925.     {
  926.         try {
  927.             $user = $security->getUser();
  928.             if (!$user) {
  929.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  930.             }
  931.             if (!$user->isActivo()) {
  932.                 return new JsonResponse(['error' => 'Usuario no está activo'], JsonResponse::HTTP_FORBIDDEN);
  933.             }
  934.             if(
  935.             !$this->isGranted('ROLE_SUPER_ADMIN') &&
  936.             !$this->isGranted('ROLE_PU_ADMINISTRADOR_CON') &&
  937.             !$this->isGranted('ROLE_PU_SUPERVISOR_POS') &&
  938.             !$this->isGranted('ROLE_PU_EVALUADOR_SEL') &&
  939.             !$this->isGranted('ROLE_PU_EVALUADOR_COL') &&
  940.             !$this->isGranted('ROLE_PU_EVALUADOR_ADM')
  941.             ){
  942.                 return new JsonResponse(['error' => 'Acceso denegado'], 403);
  943.             }
  944.             $userActual = $security->getUser();
  945.             $regiones = $userActual->getRegiones();
  947.             $regionesLabel = [];
  948.             foreach($regiones as $regionOb){
  949.                 $regionesLabel[] = $regionOb->getNombre();
  950.             }
  951.             if (!$userActual) {
  952.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  953.             }
  955.             $postulaciones = $pcPostulacionRepository->findByRegiones($regionesLabel, $userActual->isSuperAdmin());
  956.             //Filtrar las que no tienen postulaciones
  957.             $postulacionesJson = [];
  958.             foreach ($postulaciones as $postulacion) {
  960.                 $convocatoria = $postulacion->getConvocatoria();
  961.                 $puntoCultura = $postulacion->getPuntoCultura();
  963.                 $postulacionesJson[] = [
  964.                     'id' => $postulacion->getId(),
  965.                     'nombreOrganizacion' => $puntoCultura->getNombre(),
  966.                     'rut' => $puntoCultura->getRut() . '-' . $puntoCultura->getDv(),
  967.                     'region' => $puntoCultura->getRegion(),
  968.                     'convocatoria' => $convocatoria->getNombre(),
  969.                     'evaluacion' => $postulacion->getEtapaPostulacion(),
  970.                     'resultadoEvaluacion' => $postulacion->getResultadoPostulacion(),
  971.                     'notaFinal' =>
  972.                         $postulacion->getEstadoEvaluacion() == 'send'
  973.                         ? $postulacion->getNotaFinalEvaluacion()
  974.                         : null,
  975.                     'estadoConvocatoria' => $convocatoria->getEstado(),
  976.                     'editarAdminsibilidad' => $postulacion->isEditableAdmisibilidad(),
  977.                     'editarColectivo' => $postulacion->isEditableEvaluacion(),
  978.                     'editarSeleccion' => $postulacion->isEditableSeleccion(),
  979.                 ];
  980.             }
  981.             return $this->json(['postulaciones' => $postulacionesJson]);
  983.         } catch (\Exception $e) {
  984.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  985.         }
  986.     }
  988.     #[Route('/secure/postulacion/{id}/admisibilidad', name: 'procesoAdmisibilidad', methods: ['PUT'])]
  989.     public function procesoAdmisibilidad(
  990.         $id,
  991.         Request $request,
  992.         PcPostulacionRepository $pcPostulacionRepository,
  993.         ValidacionService $validacionService,
  994.         Security $security
  995.     ): JsonResponse
  996.     {
  997.         try {
  998.             $user = $security->getUser();
  999.             if (!$user) {
  1000.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  1001.             }
  1002.             if (!$user->isActivo()) {
  1003.                 return new JsonResponse(['error' => 'Usuario no está activo'], JsonResponse::HTTP_FORBIDDEN);
  1004.             }
  1005.             if (!$this->isGranted('ROLE_SUPER_ADMIN') && !$this->isGranted('ROLE_PU_EVALUADOR_ADM')) {
  1006.                 return new JsonResponse(['error' => 'Acceso denegado'], 403);
  1007.             }
  1009.             $postulacion = $pcPostulacionRepository->findByIdAdmin($id);
  1011.             if (!$postulacion) {
  1012.                 return new JsonResponse(['error' => 'Postulacion no encontrada'], JsonResponse::HTTP_NOT_FOUND);
  1013.             }
  1015.             if ($postulacion->getEstadoAdmisibilidad() == 'send') {
  1016.                 return new JsonResponse(['error' => 'El formulario ya fue calificado'], JsonResponse::HTTP_BAD_REQUEST);
  1017.             }
  1019.             $usuarioAdmisibilidadActual = $postulacion->getUsuarioAdmisibilidad();
  1021.             if(!empty($usuarioAdmisibilidadActual) && $usuarioAdmisibilidadActual->getId() !== $user->getId()){
  1022.                 return new JsonResponse(['error' => 'Usuario responsable es ' . $usuarioAdmisibilidadActual->getNombres()],
  1023.                     JsonResponse::HTTP_BAD_REQUEST);
  1024.             }
  1026.             $data = json_decode($request->getContent(), true);
  1027.             if (!$validacionService->validaciones([
  1028.                 $data['formularioAdmisibilidad'],
  1029.             ], 'array')) {
  1030.                 return new JsonResponse(['error' => 'formularioAdmisibilidad deben ser objetos'], JsonResponse::HTTP_BAD_REQUEST);
  1031.             }
  1033.             if (!empty($data['estado']) && ($data['estado'] !== 'save' && $data['estado'] !== 'send')) {
  1034.                 return new JsonResponse(['error' => 'Solo se permite estado save y send'], JsonResponse::HTTP_BAD_REQUEST);
  1035.             }
  1037.             if($data['estado'] == 'send'){
  1038.                 $respuesta = $data['formularioAdmisibilidad']['1']['respuesta'];
  1039.                 $postulacion->setResultadoAdmisibilidad($respuesta == 'Si');
  1040.             }
  1041.             $now = new DateTime();
  1042.             $postulacion->setUsuarioAdmisibilidad($user);
  1043.             $postulacion->setAdmisibilidadAt($now);
  1044.             $postulacion->setFormularioAdmisibilidad($data['formularioAdmisibilidad']);
  1045.             $postulacion->setEstadoAdmisibilidad($data['estado']);
  1046.             $pcPostulacionRepository->save($postulacion, true);
  1048.             $postulacionObj = [
  1049.                 'id' => $postulacion->getId(),
  1050.                 'notaFinal' =>
  1051.                     $postulacion->getEstadoEvaluacion() == 'send'
  1052.                     ? $postulacion->getNotaFinalEvaluacion()
  1053.                     : null,
  1054.                 'editarAdminsibilidad' => $postulacion->isEditableAdmisibilidad(),
  1055.                 'editarColectivo' => $postulacion->isEditableEvaluacion(),
  1056.                 'editarSeleccion' => $postulacion->isEditableSeleccion(),
  1057.             ];
  1058.             return new JsonResponse(['message' => 'Postulacion actualizada con éxito', 'postulacion' => $postulacionObj]);
  1060.         } catch (\Exception $e) {
  1061.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  1062.         }
  1063.     }
  1065.     #[Route('/secure/postulacion/{id}/colectivo', name: 'procesoColectivo', methods: ['PUT'])]
  1066.     public function procesoColectivo(
  1067.         $id,
  1068.         Request $request,
  1069.         PcPostulacionRepository $pcPostulacionRepository,
  1070.         ValidacionService $validacionService,
  1071.         Security $security
  1072.     ): JsonResponse
  1073.     {
  1074.         try {
  1075.             $user = $security->getUser();
  1076.             if (!$user) {
  1077.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  1078.             }
  1079.             if (!$user->isActivo()) {
  1080.                 return new JsonResponse(['error' => 'Usuario no está activo'], JsonResponse::HTTP_FORBIDDEN);
  1081.             }
  1082.             if (!$this->isGranted('ROLE_SUPER_ADMIN') && !$this->isGranted('ROLE_PU_EVALUADOR_COL')) {
  1083.                 return new JsonResponse(['error' => 'Acceso denegado'], 403);
  1084.             }
  1086.             $postulacion = $pcPostulacionRepository->findByIdAdmin($id);
  1088.             if (!$postulacion) {
  1089.                 return new JsonResponse(['error' => 'Postulacion no encontrada'], JsonResponse::HTTP_NOT_FOUND);
  1090.             }
  1092.             if ($postulacion->getEstadoEvaluacion() == 'send') {
  1093.                 return new JsonResponse(['error' => 'El formulario ya fue calificado'], JsonResponse::HTTP_BAD_REQUEST);
  1094.             }
  1096.             $usuarioEvaluacionActual = $postulacion->getUsuarioEvaluacion();
  1098.             if(!empty($usuarioEvaluacionActual) && $usuarioEvaluacionActual->getId() !== $user->getId()){
  1099.                 return new JsonResponse(['error' => 'Usuario responsable es ' . $usuarioEvaluacionActual->getNombres()],
  1100.                     JsonResponse::HTTP_BAD_REQUEST);
  1101.             }
  1103.             $data = json_decode($request->getContent(), true);
  1104.             if (!$validacionService->validaciones([
  1105.                 $data['formularioEvaluacion'],
  1106.             ], 'array')) {
  1107.                 return new JsonResponse(['error' => 'formularioEvaluacion deben ser objetos'], JsonResponse::HTTP_BAD_REQUEST);
  1108.             }
  1110.             if (!empty($data['estado']) && ($data['estado'] !== 'save' && $data['estado'] !== 'send')) {
  1111.                 return new JsonResponse(['error' => 'Solo se permite estado save y send'], JsonResponse::HTTP_BAD_REQUEST);
  1112.             }
  1114.             if($data['estado'] == 'send'){
  1115.                 $notaFinal = 0;
  1116.                 $pesoTotal = 0;
  1117.                 foreach($data['formularioEvaluacion'] as $criterio){
  1118.                     if($criterio['tipo'] == 'criterio'){
  1119.                         $pesoTotal = $pesoTotal + (float) $criterio['peso'];
  1120.                         $notaFinal = $notaFinal + ((float) $criterio['peso'] * (float) $criterio['valor']);
  1121.                     }
  1122.                 }
  1123.                 $notaFinal = $notaFinal / $pesoTotal;
  1124.                 $postulacion->setNotaFinalEvaluacion($notaFinal);
  1125.             }
  1127.             $now = new DateTime();
  1128.             $postulacion->setUsuarioEvaluacion($user);
  1129.             $postulacion->setEvaluacionAt($now);
  1130.             $postulacion->setFormularioEvaluacion($data['formularioEvaluacion']);
  1131.             $postulacion->setEstadoEvaluacion($data['estado']);
  1132.             $pcPostulacionRepository->save($postulacion, true);
  1134.             $postulacionObj = [
  1135.                 'id' => $postulacion->getId(),
  1136.                 'notaFinal' =>
  1137.                     $postulacion->getEstadoEvaluacion() == 'send'
  1138.                     ? $postulacion->getNotaFinalEvaluacion()
  1139.                     : null,
  1140.                 'editarAdminsibilidad' => $postulacion->isEditableAdmisibilidad(),
  1141.                 'editarColectivo' => $postulacion->isEditableEvaluacion(),
  1142.                 'editarSeleccion' => $postulacion->isEditableSeleccion(),
  1144.             ];
  1145.             return new JsonResponse(['message' => 'Postulacion actualizada con éxito', 'postulacion' => $postulacionObj]);
  1147.         } catch (\Exception $e) {
  1148.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  1149.         }
  1150.     }
  1152.     #[Route('/secure/postulacion/{id}/seleccion', name: 'procesoSeleccion', methods: ['PUT'])]
  1153.     public function procesoSeleccion(
  1154.         $id,
  1155.         Request $request,
  1156.         PcPostulacionRepository $pcPostulacionRepository,
  1157.         ValidacionService $validacionService,
  1158.         Security $security
  1159.     ): JsonResponse
  1160.     {
  1161.         try {
  1162.             $user = $security->getUser();
  1163.             if (!$user) {
  1164.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  1165.             }
  1166.             if (!$user->isActivo()) {
  1167.                 return new JsonResponse(['error' => 'Usuario no está activo'], JsonResponse::HTTP_FORBIDDEN);
  1168.             }
  1169.             if (!$this->isGranted('ROLE_SUPER_ADMIN') && !$this->isGranted('ROLE_PU_EVALUADOR_SEL')) {
  1170.                 return new JsonResponse(['error' => 'Acceso denegado'], 403);
  1171.             }
  1173.             $postulacion = $pcPostulacionRepository->findByIdAdmin($id);
  1175.             if (!$postulacion) {
  1176.                 return new JsonResponse(['error' => 'Postulacion no encontrada'], JsonResponse::HTTP_NOT_FOUND);
  1177.             }
  1179.             if ($postulacion->getEstadoSeleccion() == 'send') {
  1180.                 return new JsonResponse(['error' => 'El formulario ya fue calificado'], JsonResponse::HTTP_BAD_REQUEST);
  1181.             }
  1183.             $usuarioSeleccionActual = $postulacion->getUsuarioSeleccion();
  1185.             if(!empty($usuarioSeleccionActual) && $usuarioSeleccionActual->getId() !== $user->getId()){
  1186.                 return new JsonResponse(['error' => 'Usuario responsable es ' . $usuarioSeleccionActual->getNombres()],
  1187.                     JsonResponse::HTTP_BAD_REQUEST);
  1188.             }
  1190.             $data = json_decode($request->getContent(), true);
  1191.             if (!$validacionService->validaciones([
  1192.                 $data['formularioSeleccion'],
  1193.             ], 'array')) {
  1194.                 return new JsonResponse(['error' => 'formularioSeleccion deben ser objetos'], JsonResponse::HTTP_BAD_REQUEST);
  1195.             }
  1197.             if (!empty($data['estado']) && ($data['estado'] !== 'save' && $data['estado'] !== 'send')) {
  1198.                 return new JsonResponse(['error' => 'Solo se permite estado save y send'], JsonResponse::HTTP_BAD_REQUEST);
  1199.             }
  1201.             if($data['estado'] == 'send'){
  1202.                 $respuesta = $data['formularioSeleccion']['1']['respuesta'];
  1203.                 $montoAdjudicado = $data['formularioSeleccion']['2']['respuesta'];
  1204.                 $postulacion->setMontoAdjudicado((int) $montoAdjudicado);
  1205.                 $postulacion->setResultadoSeleccion($respuesta == 'Seleccionado');
  1206.             }
  1208.             $now = new DateTime();
  1209.             $postulacion->setUsuarioSeleccion($user);
  1210.             $postulacion->setSeleccionAt($now);
  1211.             $postulacion->setFormularioSeleccion($data['formularioSeleccion']);
  1212.             $postulacion->setEstadoSeleccion($data['estado']);
  1213.             $pcPostulacionRepository->save($postulacion, true);
  1215.             $postulacionObj = [
  1216.                 'id' => $postulacion->getId(),
  1217.                 'notaFinal' =>
  1218.                     $postulacion->getEstadoEvaluacion() == 'send'
  1219.                     ? $postulacion->getNotaFinalEvaluacion()
  1220.                     : null,
  1221.                 'editarAdminsibilidad' => $postulacion->isEditableAdmisibilidad(),
  1222.                 'editarColectivo' => $postulacion->isEditableEvaluacion(),
  1223.                 'editarSeleccion' => $postulacion->isEditableSeleccion(),
  1224.             ];
  1225.             return new JsonResponse(['message' => 'Postulacion actualizada con éxito', 'postulacion' => $postulacionObj]);
  1227.         } catch (\Exception $e) {
  1228.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  1229.         }
  1230.     }
  1232.     #[Route('/secure/puntocultura/{id}', name: 'obtenerPuntoCultura', methods: ['GET'])]
  1233.     public function obtenerPuntoCultura(
  1234.         $id,
  1235.         PcPuntoCulturaRepository $pcPuntoCulturaRepository,
  1236.         RacService $racService,
  1237.         Security $security
  1238.     ): JsonResponse
  1239.     {
  1240.         try {
  1241.             $user = $security->getUser();
  1242.             if (!$user) {
  1243.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  1244.             }
  1245.             if (!$user->isActivo()) {
  1246.                 return new JsonResponse(['error' => 'Usuario no está activo'], JsonResponse::HTTP_FORBIDDEN);
  1247.             }
  1248.             if(
  1249.             !$this->isGranted('ROLE_SUPER_ADMIN') &&
  1250.             !$this->isGranted('ROLE_PU_ADMINISTRADOR_CON') &&
  1251.             !$this->isGranted('ROLE_PU_SUPERVISOR_POS') &&
  1252.             !$this->isGranted('ROLE_PU_EVALUADOR_SEL') &&
  1253.             !$this->isGranted('ROLE_PU_EVALUADOR_COL') &&
  1254.             !$this->isGranted('ROLE_PU_EVALUADOR_ADM')
  1255.             ){
  1256.                 return new JsonResponse(['error' => 'Acceso denegado'], 403);
  1257.             }
  1258.             $punto = $pcPuntoCulturaRepository->findActivo($id);
  1259.             if (!$punto) {
  1260.                 return new JsonResponse(['error' => 'Punto no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  1261.             }
  1262.             $rut = $punto->getRut();
  1263.             $dv = $punto->getDv();
  1264.             $userRut = strval(number_format((int) $rut, 0, '', '.')) . '-' . $dv;
  1265.             $organizaciones = $racService->getRegisterRac($userRut);
  1266.             $organizacionId = (string) $punto->getOrganizacionComunitariaId();
  1267.             $rac = null;
  1268.             //org_id
  1269.             foreach($organizaciones as $org){
  1270.                 if(empty($org['org_id'])) continue;
  1271.                 $org_id = $org['org_id'];
  1272.                 if($organizacionId == $org_id){
  1273.                     $rac = $org;
  1274.                 }
  1275.             }
  1277.             return $this->json([
  1278.                 'id' => $punto->getId(),
  1279.                 'nombre' => $punto->getNombre() ?? '',
  1280.                 'resenia' => $punto->getResenia() ?? '',
  1281.                 'region' => $punto->getRegion() ?? '',
  1282.                 'comuna' => $punto->getComuna() ?? '',
  1283.                 'direccion' => $punto->getDireccion() ?? '',
  1284.                 'georeferencia' => $punto->getGeoreferencia() ?? '',
  1285.                 'nombre_contacto' => $punto->getNombreContacto() ?? '',
  1286.                 'email_contacto' => $punto->getEmailContacto() ?? '',
  1287.                 'redes_sociales' => $punto->getRedesSociales(),
  1288.                 'certificado_punto' => $punto->getCertificadoPunto() ?? '',
  1289.                 'nombre_persona_juridica' => $punto->getNombrePersonaJuridica() ?? '',
  1290.                 'nombre_representante_legal' => $punto->getNombreRepresentanteLegal() ?? '',
  1291.                 'rut_persona_juridica' => $punto->getRutPersonaJuridica() ?? '',
  1292.                 'rut_representante_legal' => $punto->getRutRepresentanteLegal() ?? '',
  1293.                 'direccion_postal' => $punto->getDireccionPostal() ?? '',
  1294.                 'correo_electronico_1' => $punto->getCorreoElectronico1() ?? '',
  1295.                 'correo_electronico_2' => $punto->getCorreoElectronico2() ?? '',
  1296.                 'telefono_1' => $punto->getTelefono1() ?? '',
  1297.                 'telefono_2' => $punto->getTelefono2() ?? '',
  1298.                 'organizacion_comunitaria_id' => $punto->getOrganizacionComunitariaId(),
  1299.                 'doc_estatuto_organizacion' => $punto->getDocEstatutoOrganizacion(),
  1300.                 'doc_certificado_vigencia_persona_juridica' => $punto->getDocCertificadoVigenciaPersonaJuridica(),
  1301.                 'doc_acredita_personeria_vigente' => $punto->getDocAcreditaPersoneriaVigente(),
  1302.                 'doc_listado_personas'=> $punto->getDocListadoPersonas(),
  1303.                 'documentos' => $punto->getDocumentos(),
  1304.                 'rut' => $punto->getRut(),
  1305.                 'dv' => $punto->getDv(),
  1306.                 'rac' => $rac,
  1307.             ]);
  1309.         } catch (\Exception $e) {
  1310.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  1311.         }
  1312.     }
  1314.     #[Route('/secure/postulaciones/admisibilidad', name: 'obtenerPostulacionesAdmisibilidad', methods: ['GET'])]
  1315.     public function obtenerPostulacionesAdmisibilidad(
  1316.         PcPostulacionRepository $pcPostulacionRepository,
  1317.         Security $security
  1318.     ): JsonResponse
  1319.     {
  1320.         try {
  1321.             $user = $security->getUser();
  1322.             if (!$user) {
  1323.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  1324.             }
  1325.             if (!$user->isActivo()) {
  1326.                 return new JsonResponse(['error' => 'Usuario no está activo'], JsonResponse::HTTP_FORBIDDEN);
  1327.             }
  1328.             if(
  1329.             !$this->isGranted('ROLE_SUPER_ADMIN') &&
  1330.             !$this->isGranted('ROLE_PU_EVALUADOR_ADM')
  1331.             ){
  1332.                 return new JsonResponse(['error' => 'Acceso denegado'], 403);
  1333.             }
  1334.             $userActual = $security->getUser();
  1335.             $regiones = $userActual->getRegiones();
  1337.             $regionesLabel = [];
  1338.             foreach($regiones as $regionOb){
  1339.                 $regionesLabel[] = $regionOb->getNombre();
  1340.             }
  1341.             if (!$userActual) {
  1342.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  1343.             }
  1345.             $postulaciones = $pcPostulacionRepository->findByRegionesAdmisibilidad($regionesLabel, $userActual->isSuperAdmin());
  1346.             //Filtrar las que no tienen postulaciones
  1347.             $postulacionesJson = [];
  1348.             foreach ($postulaciones as $postulacion) {
  1349.                 $convocatoria = $postulacion->getConvocatoria();
  1350.                 $puntoCultura = $postulacion->getPuntoCultura();
  1352.                 $postulacionesJson[] = [
  1353.                     'id' => $postulacion->getId(),
  1354.                     'nombreOrganizacion' => $puntoCultura->getNombre(),
  1355.                     'rut' => $puntoCultura->getRut() . '-' . $puntoCultura->getDv(),
  1356.                     'region' => $puntoCultura->getRegion(),
  1357.                     'convocatoria' => $convocatoria->getNombre(),
  1358.                     'notaFinal' =>
  1359.                         $postulacion->getEstadoEvaluacion() == 'send'
  1360.                         ? $postulacion->getNotaFinalEvaluacion()
  1361.                         : null,
  1362.                     'estadoConvocatoria' => $convocatoria->getEstado(),
  1363.                     'editarAdminsibilidad' => $postulacion->isEditableAdmisibilidad(),
  1364.                     'editarColectivo' => $postulacion->isEditableEvaluacion(),
  1365.                     'editarSeleccion' => $postulacion->isEditableSeleccion(),
  1366.                     'evaluacion' => $postulacion->getEtapaPostulacion(),
  1367.                     'resultadoEvaluacion' => $postulacion->getResultadoPostulacion(),
  1368.                 ];
  1369.             }
  1370.             return $this->json(['postulaciones' => $postulacionesJson]);
  1372.         } catch (\Exception $e) {
  1373.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  1374.         }
  1375.     }
  1378.     #[Route('/secure/postulaciones/colectivo', name: 'obtenerPostulacionesColectivo', methods: ['GET'])]
  1379.     public function obtenerPostulacionesColectivo(
  1380.         PcPostulacionRepository $pcPostulacionRepository,
  1381.         Security $security
  1382.     ): JsonResponse
  1383.     {
  1384.         try {
  1385.             $user = $security->getUser();
  1386.             if (!$user) {
  1387.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  1388.             }
  1389.             if (!$user->isActivo()) {
  1390.                 return new JsonResponse(['error' => 'Usuario no está activo'], JsonResponse::HTTP_FORBIDDEN);
  1391.             }
  1392.             if(
  1393.             !$this->isGranted('ROLE_SUPER_ADMIN') &&
  1394.             !$this->isGranted('ROLE_PU_EVALUADOR_ADM')
  1395.             ){
  1396.                 return new JsonResponse(['error' => 'Acceso denegado'], 403);
  1397.             }
  1398.             $userActual = $security->getUser();
  1399.             $regiones = $userActual->getRegiones();
  1401.             $regionesLabel = [];
  1402.             foreach($regiones as $regionOb){
  1403.                 $regionesLabel[] = $regionOb->getNombre();
  1404.             }
  1405.             if (!$userActual) {
  1406.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  1407.             }
  1409.             $postulaciones = $pcPostulacionRepository->findByRegionesEvaluacion($regionesLabel, $userActual->isSuperAdmin());
  1410.             //Filtrar las que no tienen postulaciones
  1411.             $postulacionesJson = [];
  1412.             foreach ($postulaciones as $postulacion) {
  1413.                 $convocatoria = $postulacion->getConvocatoria();
  1414.                 $puntoCultura = $postulacion->getPuntoCultura();
  1416.                 $postulacionesJson[] = [
  1417.                     'id' => $postulacion->getId(),
  1418.                     'nombreOrganizacion' => $puntoCultura->getNombre(),
  1419.                     'rut' => $puntoCultura->getRut() . '-' . $puntoCultura->getDv(),
  1420.                     'region' => $puntoCultura->getRegion(),
  1421.                     'convocatoria' => $convocatoria->getNombre(),
  1422.                     'evaluacion' => $postulacion->getEtapaPostulacion(),
  1423.                     'resultadoEvaluacion' => $postulacion->getResultadoPostulacion(),
  1424.                     'notaFinal' =>
  1425.                         $postulacion->getEstadoEvaluacion() == 'send'
  1426.                         ? $postulacion->getNotaFinalEvaluacion()
  1427.                         : null,
  1428.                     'estadoConvocatoria' => $convocatoria->getEstado(),
  1429.                     'editarAdminsibilidad' => $postulacion->isEditableAdmisibilidad(),
  1430.                     'editarColectivo' => $postulacion->isEditableEvaluacion(),
  1431.                     'editarSeleccion' => $postulacion->isEditableSeleccion(),
  1432.                 ];
  1433.             }
  1434.             return $this->json(['postulaciones' => $postulacionesJson]);
  1436.         } catch (\Exception $e) {
  1437.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  1438.         }
  1439.     }
  1441.     #[Route('/secure/postulaciones/seleccion', name: 'obtenerPostulacionesSeleccion', methods: ['GET'])]
  1442.     public function obtenerPostulacionesSeleccion(
  1443.         PcPostulacionRepository $pcPostulacionRepository,
  1444.         Security $security
  1445.     ): JsonResponse
  1446.     {
  1447.         try {
  1448.             $user = $security->getUser();
  1449.             if (!$user) {
  1450.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  1451.             }
  1452.             if (!$user->isActivo()) {
  1453.                 return new JsonResponse(['error' => 'Usuario no está activo'], JsonResponse::HTTP_FORBIDDEN);
  1454.             }
  1455.             if(
  1456.             !$this->isGranted('ROLE_SUPER_ADMIN') &&
  1457.             !$this->isGranted('ROLE_PU_EVALUADOR_ADM')
  1458.             ){
  1459.                 return new JsonResponse(['error' => 'Acceso denegado'], 403);
  1460.             }
  1461.             $userActual = $security->getUser();
  1462.             $regiones = $userActual->getRegiones();
  1464.             $regionesLabel = [];
  1465.             foreach($regiones as $regionOb){
  1466.                 $regionesLabel[] = $regionOb->getNombre();
  1467.             }
  1468.             if (!$userActual) {
  1469.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  1470.             }
  1472.             $postulaciones = $pcPostulacionRepository->findByRegionesSeleccion($regionesLabel, $userActual->isSuperAdmin());
  1473.             //Filtrar las que no tienen postulaciones
  1474.             $postulacionesJson = [];
  1475.             foreach ($postulaciones as $postulacion) {
  1476.                 $convocatoria = $postulacion->getConvocatoria();
  1477.                 $puntoCultura = $postulacion->getPuntoCultura();
  1479.                 $postulacionesJson[] = [
  1480.                     'id' => $postulacion->getId(),
  1481.                     'nombreOrganizacion' => $puntoCultura->getNombre(),
  1482.                     'rut' => $puntoCultura->getRut() . '-' . $puntoCultura->getDv(),
  1483.                     'region' => $puntoCultura->getRegion(),
  1484.                     'convocatoria' => $convocatoria->getNombre(),
  1485.                     'evaluacion' => $postulacion->getEtapaPostulacion(),
  1486.                     'resultadoEvaluacion' => $postulacion->getResultadoPostulacion(),
  1487.                     'notaFinal' =>
  1488.                         $postulacion->getEstadoEvaluacion() == 'send'
  1489.                         ? $postulacion->getNotaFinalEvaluacion()
  1490.                         : null,
  1491.                     'estadoConvocatoria' => $convocatoria->getEstado(),
  1492.                     'editarAdminsibilidad' => $postulacion->isEditableAdmisibilidad(),
  1493.                     'editarColectivo' => $postulacion->isEditableEvaluacion(),
  1494.                     'editarSeleccion' => $postulacion->isEditableSeleccion(),
  1495.                 ];
  1496.             }
  1497.             return $this->json(['postulaciones' => $postulacionesJson]);
  1499.         } catch (\Exception $e) {
  1500.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  1501.         }
  1502.     }
  1503. }