src/Controller/ApiPuntoCulturaController.php line 48

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\Repository\PcPuntoCulturaRepository;
  13. use App\Entity\PcConvocatorias;
  14. use App\Entity\PcCriterios;
  15. use App\Repository\PcCriteriosRepository;
  16. use App\Entity\PcCriteriosConvocatorias;
  17. use App\Repository\PcCriteriosConvocatoriasRepository;
  18. use App\Repository\RegionRepository;
  19. use App\Service\RegionComunaService;
  20. use App\Service\RacService;
  21. use App\Service\ValidacionService;
  22. use App\Entity\PcPostulacion;
  23. use App\Repository\PcPostulacionRepository;
  24. use App\Repository\PostulacionRepository;
  25. use App\Entity\Postulacion;
  26. use App\Entity\Region;
  27. use App\Entity\Comuna;
  28. use App\Repository\ComunaRepository;
  30. use Symfony\Component\HttpFoundation\Response;
  31. use Symfony\Component\HttpFoundation\File\Exception\FileNotFoundException;
  32. use Symfony\Component\HttpFoundation\BinaryFileResponse;
  33. use Symfony\Component\HttpFoundation\ResponseHeaderBag;
  34. use Symfony\Component\Security\Core\Security;
  35. use Symfony\Component\Validator\Validator\ValidatorInterface;
  37. use DateTime;
  38. use DateTimeInterface;
  41. /**
  42.  * @Route("/api/pu", name="api_pu_")
  43.  */
  44. class ApiPuntoCulturaController extends AbstractController
  45. {
  47.     #[Route('/insecure/puntocultura', name: 'obtenerTodosPuntoCultura', methods: ['GET'])]
  48.     public function obtenerTodosPuntoCultura(
  49.         PcPuntoCulturaRepository $pcPuntoCulturaRepository
  50.     ): JsonResponse
  51.     {
  52.         try {
  53.             $puntos = $pcPuntoCulturaRepository->findAllActivos();
  54.             $data = [];
  55.             $puntoxregion = [];
  56.             foreach ($puntos as $punto) {
  57.                 $region = $punto->getRegion();
  58.                 $comuna = $punto->getComuna();
  60.                 if(empty($puntoxregion[$region])) $puntoxregion[$region] = 0;
  61.                 $puntoxregion[$region] += 1;
  63.                 if(empty($data[$region])) $data[$region] = [];
  64.                 if(empty($data[$region][$comuna])) $data[$region][$comuna] = [];
  65.                 $data[$region][$comuna][] = [
  66.                     'id' => $punto->getId(),
  67.                     'nombre' => $punto->getNombre(),
  68.                 ];
  69.             }
  70.             return $this->json(['data' => $data, 'total' => $puntoxregion]);
  71.         } catch (\Exception $e) {
  72.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  73.         }
  74.     }
  76.     #[Route('/insecure/puntocultura/{id}', name: 'obtenerPuntoCulturaPublico', methods: ['GET'])]
  77.     public function obtenerPuntoCulturaPublico(
  78.         $id, PcPuntoCulturaRepository $pcPuntoCulturaRepository
  79.     ): JsonResponse
  80.     {
  81.         try {
  82.             $punto = $pcPuntoCulturaRepository->findActivo($id);
  84.             if (!$punto) {
  85.                 return new JsonResponse(['error' => 'Punto no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  86.             }
  88.             return $this->json([
  89.                 'id' => $punto->getId(),
  90.                 'nombre' => $punto->getNombre() ?? '',
  91.                 'resenia' => $punto->getResenia() ?? '',
  92.                 'region' => $punto->getRegion() ?? '',
  93.                 'comuna' => $punto->getComuna() ?? '',
  94.                 'direccion' => $punto->getDireccion() ?? '',
  95.                 'georeferencia' => $punto->getGeoreferencia(),
  96.                 'nombre_contacto' => $punto->getNombreContacto() ?? '',
  97.                 'email_contacto' => $punto->getEmailContacto() ?? '',
  98.                 'redes_sociales' => $punto->getRedesSociales(),
  99.                 'certificado_punto' => $punto->getCertificadoPunto() ?? '',
  100.                 // 'nombre_persona_juridica' => $punto->getNombrePersonaJuridica(),
  101.                 // 'nombre_representante_legal' => $punto->getNombreRepresentanteLegal(),
  102.                 // 'rut_persona_juridica' => $punto->getRutPersonaJuridica(),
  103.                 // 'rut_representante_legal' => $punto->getRutRepresentanteLegal(),
  104.                 // 'direccion_postal' => $punto->getDireccionPostal(),
  105.                 // 'correo_electronico_1' => $punto->getCorreoElectronico1(),
  106.                 // 'correo_electronico_2' => $punto->getCorreoElectronico2(),
  107.                 // 'telefono_1' => $punto->getTelefono1(),
  108.                 // 'telefono_2' => $punto->getTelefono2(),
  109.                 // 'organizacion_comunitaria_id' => $punto->getOrganizacionComunitariaId(),
  110.                 // 'doc_estatuto_organizacion' => $punto->getDocEstatutoOrganizacion(),
  111.                 // 'doc_certificado_vigencia_persona_juridica' => $punto->getDocCertificadoVigenciaPersonaJuridica(),
  112.                 // 'doc_acredita_personeria_vigente' => $punto->getDocAcreditaPersoneriaVigente(),
  113.                 // 'doc_listado_personas'=> $punto->getDocListadoPersonas(),
  114.                 // 'documentos' => $punto->getDocumentos(),
  115.                 'rut' => $punto->getRut(),
  116.                 'dv' => $punto->getDv(),
  117.             ]);
  118.         } catch (\Exception $e) {
  119.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  120.         }
  121.     }
  123.     #[Route('/secure/puntocultura/{id}', name: 'obtenerPuntoCulturaPrivado', methods: ['GET'])]
  124.     public function obtenerPuntoCulturaPrivado(
  125.         $id,
  126.         PcPuntoCulturaRepository $pcPuntoCulturaRepository,
  127.         RacService $racService,
  128.         Security $security
  129.     ): JsonResponse
  130.     {
  131.         try {
  132.             $user = $security->getUser();
  133.             if (!$user) {
  134.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  135.             }
  136.             $rut = $user->getRut();
  137.             $dv = $user->getDv();
  138.             $userRut = strval(number_format((int) $rut, 0, '', '.')) . '-' . $dv;
  140.             $punto = $pcPuntoCulturaRepository->findByIdAndRut($id, $rut, $dv);
  141.             if (!$punto) {
  142.                 return new JsonResponse(['error' => 'Punto no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  143.             }
  144.             $organizaciones = $racService->getRegisterRac($userRut);
  145.             $organizacionId = (string) $punto->getOrganizacionComunitariaId();
  146.             $rac = null;
  148.             foreach($organizaciones as $org){
  149.                 if(empty($org['org_id'])) continue;
  150.                 $org_id = $org['org_id'];
  151.                 if($organizacionId == $org_id){
  152.                     $rac = $org;
  153.                 }
  154.             }
  156.             return $this->json([
  157.                 'id' => $punto->getId(),
  158.                 'nombre' => $punto->getNombre() ?? '',
  159.                 'resenia' => $punto->getResenia() ?? '',
  160.                 'region' => $punto->getRegion() ?? '',
  161.                 'comuna' => $punto->getComuna() ?? '',
  162.                 'direccion' => $punto->getDireccion() ?? '',
  163.                 'georeferencia' => $punto->getGeoreferencia() ?? '',
  164.                 'nombre_contacto' => $punto->getNombreContacto() ?? '',
  165.                 'email_contacto' => $punto->getEmailContacto() ?? '',
  166.                 'redes_sociales' => $punto->getRedesSociales(),
  167.                 'certificado_punto' => $punto->getCertificadoPunto() ?? '',
  168.                 'nombre_persona_juridica' => $punto->getNombrePersonaJuridica() ?? '',
  169.                 'nombre_representante_legal' => $punto->getNombreRepresentanteLegal() ?? '',
  170.                 'rut_persona_juridica' => $punto->getRutPersonaJuridica() ?? '',
  171.                 'rut_representante_legal' => $punto->getRutRepresentanteLegal() ?? '',
  172.                 'direccion_postal' => $punto->getDireccionPostal() ?? '',
  173.                 'correo_electronico_1' => $punto->getCorreoElectronico1() ?? '',
  174.                 'correo_electronico_2' => $punto->getCorreoElectronico2() ?? '',
  175.                 'telefono_1' => $punto->getTelefono1() ?? '',
  176.                 'telefono_2' => $punto->getTelefono2() ?? '',
  177.                 'organizacion_comunitaria_id' => $punto->getOrganizacionComunitariaId(),
  178.                 'doc_estatuto_organizacion' => $punto->getDocEstatutoOrganizacion(),
  179.                 'doc_certificado_vigencia_persona_juridica' => $punto->getDocCertificadoVigenciaPersonaJuridica(),
  180.                 'doc_acredita_personeria_vigente' => $punto->getDocAcreditaPersoneriaVigente(),
  181.                 'doc_listado_personas'=> $punto->getDocListadoPersonas(),
  182.                 'documentos' => $punto->getDocumentos(),
  183.                 'rut' => $punto->getRut(),
  184.                 'dv' => $punto->getDv(),
  185.                 'rac' => $rac,
  186.             ]);
  188.         } catch (\Exception $e) {
  189.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  190.         }
  191.     }
  194.     #[Route('/secure/puntocultura/{id}', name: 'actualizarPuntoCultura', methods: ['PUT'])]
  195.     public function actualizarPuntoCultura(
  196.         $id,
  197.         Request $request,
  198.         PcPuntoCulturaRepository $pcPuntoCulturaRepository,
  199.         Security $security,
  200.         ValidatorInterface $validator,
  201.         ValidacionService $validacionService
  202.     ): JsonResponse
  203.     {
  204.         try {
  205.             $user = $security->getUser();
  206.             if (!$user) {
  207.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  208.             }
  209.             $rut = $user->getRut();
  210.             $dv = $user->getDv();
  212.             $punto = $pcPuntoCulturaRepository->findByIdAndRut($id, $rut, $dv);;
  213.             if (!$punto) {
  214.                 return new JsonResponse(['error' => 'Punto cultura no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  215.             }
  216.             $data = json_decode($request->getContent(), true);
  217.             // Validacion
  218.             if (!$validacionService->validacionesOrNulo([
  219.                 $data['nombre'],
  220.                 $data['resenia'],
  221.                 $data['region'],
  222.                 $data['comuna'],
  223.                 $data['direccion'],
  224.                 $data['georeferencia'],
  225.                 $data['nombre_contacto'],
  226.                 $data['email_contacto'],
  227.                 $data['certificado_punto'],
  228.                 $data['nombre_persona_juridica'],
  229.                 $data['nombre_representante_legal'],
  230.                 $data['rut_persona_juridica'],
  231.                 $data['rut_representante_legal'],
  232.                 $data['direccion_postal'],
  233.                 $data['correo_electronico_1'],
  234.                 $data['correo_electronico_2'],
  235.                 $data['telefono_1'],
  236.                 $data['telefono_2']
  237.             ], 'string')) {
  238.                 return new JsonResponse(['error' => 'Los campos de nombre, reseña, region, comuna, georeferencia, nombre_contacto, email_contacto, certificado_punto, nombre_persona_juridica, nombre_representante_legal, rut_persona_juridica, rut_representante_legal, direccion_postal, correo_electronico_1,  correo_electronico_2, telefono_1, telefono_2 y dirección deben ser texto'], JsonResponse::HTTP_BAD_REQUEST);
  239.             }
  240.             if (!$validacionService->validacionesOrNulo([
  241.                 $data['organizacion_comunitaria_id']
  242.             ], 'integer')) {
  243.                 return new JsonResponse(['error' => 'Los campos organizacion_comunitaria_id debe ser numerico'], JsonResponse::HTTP_BAD_REQUEST);
  244.             }
  245.             if (!$validacionService->validacionesOrNulo([
  246.                 $data['redes_sociales'],
  247.                 $data['doc_estatuto_organizacion'],
  248.                 $data['doc_certificado_vigencia_persona_juridica'],
  249.                 $data['doc_acredita_personeria_vigente'],
  250.                 $data['doc_listado_personas'],
  251.                 $data['documentos']
  252.             ], 'array')) {
  253.                 return new JsonResponse(['error' => 'Los campos de redes_sociales, doc_estatuto_organizacion,  doc_certificado_vigencia_persona_juridica, doc_acredita_personeria_vigente, doc_listado_personas y documentos deben ser objetos'], JsonResponse::HTTP_BAD_REQUEST);
  254.             }
  256.             $punto->setNombre($data['nombre']);
  257.             $punto->setResenia($data['resenia']);
  258.             $punto->setRegion($data['region']);
  259.             $punto->setComuna($data['comuna']);
  260.             $punto->setDireccion($data['direccion']);
  261.             $punto->setGeoreferencia($data['georeferencia']);
  262.             $punto->setNombreContacto($data['nombre_contacto']);
  263.             $punto->setEmailContacto($data['email_contacto']);
  264.             $punto->setRedesSociales($data['redes_sociales']);
  265.             $punto->setCertificadoPunto($data['certificado_punto']);
  266.             $punto->setNombrePersonaJuridica($data['nombre_persona_juridica']);
  267.             $punto->setNombreRepresentanteLegal($data['nombre_representante_legal']);
  268.             $punto->setRutPersonaJuridica($data['rut_persona_juridica']);
  269.             $punto->setRutRepresentanteLegal($data['rut_representante_legal']);
  270.             $punto->setDireccionPostal($data['direccion_postal']);
  271.             $punto->setCorreoElectronico1($data['correo_electronico_1']);
  272.             $punto->setCorreoElectronico2($data['correo_electronico_2']);
  273.             $punto->setTelefono1($data['telefono_1']);
  274.             $punto->setTelefono2($data['telefono_2']);
  275.             $punto->setOrganizacionComunitariaId($data['organizacion_comunitaria_id']);
  276.             $punto->setDocEstatutoOrganizacion($data['doc_estatuto_organizacion']);
  277.             $punto->setDocCertificadoVigenciaPersonaJuridica($data['doc_certificado_vigencia_persona_juridica']);
  278.             $punto->setDocAcreditaPersoneriaVigente($data['doc_acredita_personeria_vigente']);
  279.             $punto->setDocListadoPersonas($data['doc_listado_personas']);
  280.             $punto->setDocumentos($data['documentos']);
  282.             // Validar con Symfony Validator
  283.             $errors = $validator->validate($punto);
  284.             if (count($errors) > 0) {
  285.                 $errorMessages = [];
  286.                 foreach ($errors as $error) {
  287.                     $errorMessages[] = $error->getMessage();
  288.                 }
  289.                 return new JsonResponse(['error' => $errorMessages], JsonResponse::HTTP_BAD_REQUEST);
  290.             }
  292.             $pcPuntoCulturaRepository->save($punto, true);
  294.             $puntoCulturaArr = [
  295.                 'id' => $punto->getId(),
  296.                 'nombre' => $punto->getNombre(),
  297.                 'resenia' => $punto->getResenia(),
  298.                 'region' => $punto->getRegion(),
  299.                 'comuna' => $punto->getComuna(),
  300.                 'direccion' => $punto->getDireccion(),
  301.                 'georeferencia' => $punto->getGeoreferencia(),
  302.                 'nombre_contacto' => $punto->getNombreContacto(),
  303.                 'email_contacto' => $punto->getEmailContacto(),
  304.                 'redes_sociales' => $punto->getRedesSociales(),
  305.                 'certificado_punto' => $punto->getCertificadoPunto(),
  306.                 'nombre_persona_juridica' => $punto->getNombrePersonaJuridica(),
  307.                 'nombre_representante_legal' => $punto->getNombreRepresentanteLegal(),
  308.                 'rut_persona_juridica' => $punto->getRutPersonaJuridica(),
  309.                 'rut_representante_legal' => $punto->getRutRepresentanteLegal(),
  310.                 'direccion_postal' => $punto->getDireccionPostal(),
  311.                 'correo_electronico_1' => $punto->getCorreoElectronico1(),
  312.                 'correo_electronico_2' => $punto->getCorreoElectronico2(),
  313.                 'telefono_1' => $punto->getTelefono1(),
  314.                 'telefono_2' => $punto->getTelefono2(),
  315.                 'organizacion_comunitaria_id' => $punto->getOrganizacionComunitariaId(),
  316.                 'doc_estatuto_organizacion' => $punto->getDocEstatutoOrganizacion(),
  317.                 'doc_certificado_vigencia_persona_juridica' => $punto->getDocCertificadoVigenciaPersonaJuridica(),
  318.                 'doc_acredita_personeria_vigente' => $punto->getDocAcreditaPersoneriaVigente(),
  319.                 'doc_listado_personas'=> $punto->getDocListadoPersonas(),
  320.                 'documentos' => $punto->getDocumentos(),
  321.                 'rut' => $punto->getRut(),
  322.                 'dv' => $punto->getDv(),
  323.             ];
  324.             return new JsonResponse(['message' => 'Punto Cultura actualizado con éxito', 'pc' => $puntoCulturaArr]);
  326.         } catch (\Exception $e) {
  327.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  328.         }
  329.     }
  331.     #[Route('/secure/region', name: 'obtenerRegiones', methods: ['GET'])]
  332.     public function obtenerRegiones(
  333.         RegionRepository $regionRepository
  334.     ): JsonResponse
  335.     {
  336.         try {
  337.             $regiones = $regionRepository->findAll();
  338.             $regionesJson = [];
  339.             foreach($regiones as $region){
  340.                 $regionesJson[] = [
  341.                     'nombre' => $region->getNombre(),
  342.                     'codigo' => $region->getId()
  343.                 ];
  344.             }
  345.             return $this->json($regionesJson);
  346.         } catch (\Exception $e) {
  347.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  348.         }
  349.     }
  351.     #[Route('/secure/region/{codigo}/comuna', name: 'obtenerComunas', methods: ['GET'])]
  352.     public function obtenerComunas(
  353.         $codigo,
  354.         ComunaRepository $comunaRepository
  355.     ): JsonResponse
  356.     {
  357.         try {
  358.             $comunas = $comunaRepository->findByRegion((int) $codigo);
  359.             $comunasJson = [];
  360.             foreach($comunas as $comuna){
  361.                 $comunasJson[] = [
  362.                     'nombre' => $comuna->getNombre(),
  363.                     'codigo' => $comuna->getId()
  364.                 ];
  365.             }
  366.             return $this->json($comunasJson);
  367.         } catch (\Exception $e) {
  368.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  369.         }
  370.     }
  372.     /**
  373.      * @Route("/secure/upload-file", name="uploadFile", methods={"POST"})
  374.      */
  375.     public function uploadFile(Request $request): JsonResponse
  376.     {
  377.         try {
  378.             $file = $request->files->get('file');
  379.             if (!$file) {
  380.                 return new JsonResponse(['error' => 'No hay documento'], 400);
  381.             }
  383.             try {
  384.                 $originalName = $file->getClientOriginalName();
  385.                 $newFilename = str_replace(' ', '_', $originalName) . '-' . uniqid() . '.' . $file->guessExtension();
  387.                 $projectRoot = $this->getParameter('kernel.project_dir');
  388.                 $dirToMove = $projectRoot . '/private/documentos/subidas';
  390.                 if (!is_dir($dirToMove)) {
  391.                     mkdir($dirToMove, 0777, true);
  392.                 }
  394.                 $file->move($dirToMove, $newFilename);
  396.                 return new JsonResponse([
  397.                     'message' => 'Documento subido con exito',
  398.                     'original_name' => $originalName,
  399.                     'new_filename' => $newFilename,
  400.                     'path' => '/documentos/subidas/' . $newFilename,
  401.                 ], 200);
  402.             } catch (FileException $e) {
  403.                 return new JsonResponse(['error' => 'Falla al subir archivo: ' . $e->getMessage()], 500);
  404.             }
  406.         } catch (\Exception $e) {
  407.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  408.         }
  409.     }
  411.     /**
  412.      * @Route("/secure/download-file/{filename}", name="downloadFile", methods={"GET"})
  413.      */
  414.     public function downloadFile(string $filename): Response
  415.     {
  416.         try {
  417.             $projectRoot = $this->getParameter('kernel.project_dir');
  418.             $filePath = $projectRoot . '/private/documentos/subidas/' . $filename;
  420.             if (!file_exists($filePath)) {
  421.                 throw $this->createNotFoundException("Archivo no encontrado: $filename");
  422.             }
  423.             // Devolver el archivo como una respuesta
  424.             $response = new BinaryFileResponse($filePath);
  425.             $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT, $filename);
  427.             return $response;
  429.         } catch (\Exception $e) {
  430.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  431.         }
  432.     }
  434.     #[Route('/secure/convocatorias', name: 'obtenerConvocatoriasAbiertas', methods: ['GET'])]
  435.     public function obtenerConvocatoriasAbiertas(
  436.         PcConvocatoriasRepository $pcConvocatoriasRepository,
  437.         Security $security,
  438.         PcPostulacionRepository $pcPostulacionRepository
  439.     ): JsonResponse
  440.     {
  441.         try {
  442.             $user = $security->getUser();
  443.             if (!$user) {
  444.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  445.             }
  446.             $rut = $user->getRut();
  447.             $dv = $user->getDv();
  449.             $convocatorias = $pcConvocatoriasRepository->findAbiertas();
  450.             $convocatoriasJson = [];
  451.             foreach ($convocatorias as $convocatoria) {
  452.                 $pu_inscritos = [];
  453.                 $postulaciones = $pcPostulacionRepository->findPuntoCulturaAndRutAndConvocatorias($rut, $dv, $convocatoria->getId());
  454.                 foreach ($postulaciones as $postulacion) {
  455.                     $pu_inscritos[] = $postulacion->getPuntoCultura()->getId();
  456.                 }
  458.                 $convocatoriasJson[] = [
  459.                     'id' => $convocatoria->getId(),
  460.                     'nombre' => $convocatoria->getNombre(),
  461.                     'descripcion' => $convocatoria->getDescripcion(),
  462.                     'anio' => $convocatoria->getAnio(),
  463.                     'estado' => $convocatoria->getEstado(),
  464.                     'pu_inscritos' => $pu_inscritos
  465.                 ];
  466.             }
  467.             return $this->json(['convocatorias' => $convocatoriasJson]);
  468.         } catch (\Exception $e) {
  469.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  470.         }
  471.     }
  473.     #[Route('/secure/postulacion', name: 'crearPostulacion', methods: ['POST'])]
  474.     public function crearPostulacion(
  475.         Request $request,
  476.         PcConvocatoriasRepository $pcConvocatoriaRepository,
  477.         PcPostulacionRepository $pcPostulacionRepository,
  478.         PcPuntoCulturaRepository $pcPuntoCulturaRepository,
  479.         Security $security,
  480.         ValidatorInterface $validator,
  481.         ValidacionService $validacionService
  482.     ): JsonResponse
  483.     {
  484.         try {
  485.             $user = $security->getUser();
  486.             if (!$user) {
  487.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  488.             }
  489.             $rut = $user->getRut();
  490.             $dv = $user->getDv();
  492.             $data = json_decode($request->getContent(), true);
  494.             if (!$validacionService->validacionesOrNulo([
  495.                 $data['convocatoriaId'],
  496.                 $data['puntoCulturaId'],
  497.             ], 'integer')) {
  498.                 return new JsonResponse(['error' => 'Los campos de convocatoriaId y puntoCulturaId  deben ser numericos'], JsonResponse::HTTP_BAD_REQUEST);
  499.             }
  500.             $convocatoriaId = $data['convocatoriaId'];
  501.             $puntoCulturaId = $data['puntoCulturaId'];
  502.             $convocatoria = $pcConvocatoriaRepository->find($convocatoriaId);
  503.             $puntoCultura = $pcPuntoCulturaRepository->findByIdAndRut($puntoCulturaId, $rut, $dv);
  504.             if (!$convocatoria) {
  505.                 return new JsonResponse(['error' => 'Convocatoria no encontrada'], JsonResponse::HTTP_NOT_FOUND);
  506.             }
  508.             if($convocatoria->getEstado() !== '1'){
  509.                 return new JsonResponse(['error' => 'Convocatoria no esta en fase de postulación'], JsonResponse::HTTP_BAD_REQUEST);
  510.             }
  512.             if (!$puntoCultura) {
  513.                 return new JsonResponse(['error' => 'Punto Cultura no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  514.             }
  516.             $postulacionExistente =  $pcPostulacionRepository->findByPuntoCulturaAndRutAndConvocatoria($puntoCulturaId, $rut, $dv, $convocatoriaId);
  518.             if (!!$postulacionExistente) {
  519.                 return new JsonResponse(['error' => 'Ya existe una postulación para esta convocatoria'], JsonResponse::HTTP_BAD_REQUEST);
  520.             }
  521.             if (!empty($data['estado']) && ($data['estado'] !== 'save' && $data['estado'] !== 'send')) {
  522.                 return new JsonResponse(['error' => 'Solo se permite estado save y send'], JsonResponse::HTTP_BAD_REQUEST);
  523.             }
  525.             $formularioAdmisibilidad = [
  526.                 1 => [
  527.                     'pregunta'=> '¿Admisibilidad?',
  528.                     'tipo'=> 'opcion',
  529.                     'opciones'=> ['Si', 'No'],
  530.                     'respuesta'=> '',
  531.                 ],
  532.                 2 => [
  533.                     'pregunta'=> 'Observaciones internas',
  534.                     'tipo'=> 'texarea',
  535.                     'respuesta'=> '',
  536.                 ],
  537.                 3 => [
  538.                     'pregunta'=> 'Observaciones publicas',
  539.                     'tipo'=> 'texarea',
  540.                     'respuesta'=> '',
  541.                 ],
  542.             ];
  544.             $formularioSeleccion = [
  545.                 1 => [
  546.                     'pregunta'=> '',
  547.                     'tipo'=> 'opcion',
  548.                     'opciones'=> ['Seleccionado', 'No seleccionado'],
  549.                     'respuesta'=> '',
  550.                 ],
  551.                 2 => [
  552.                     'pregunta'=> 'Monto adjudicado',
  553.                     'tipo'=> 'text',
  554.                     'respuesta'=> '',
  555.                 ],
  556.                 3 => [
  557.                     'pregunta'=> 'Observaciones',
  558.                     'tipo'=> 'texarea',
  559.                     'respuesta'=> '',
  560.                 ],
  561.             ];
  563.             $criteriosData = $convocatoria->getCriterios();
  564.             $formularioEvaluacion = [];
  566.             foreach ($criteriosData as $criterioConvocatoria) {
  567.                 $formularioEvaluacion[] = [
  568.                     'tipo' => 'criterio',
  569.                     'id' => $criterioConvocatoria->getId(),
  570.                     'nombre' => $criterioConvocatoria->getCriterios()->getNombre(),
  571.                     'descripcion' => $criterioConvocatoria->getCriterios()->getDescripcion(),
  572.                     'peso' => $criterioConvocatoria->getPeso(),
  573.                     'puntajes' => $criterioConvocatoria->getCriterios()->getPuntajes(),
  574.                     'valor' => null,
  575.                     'justificacion' => ''
  576.                 ];
  577.             }
  579.             $formularioEvaluacion[] = [
  580.                 'tipo' => 'pregunta',
  581.                 'pregunta'=> 'Justificación general',
  582.                 'tipo'=> 'texarea',
  583.                 'respuesta'=> '',
  584.             ];
  586.             $formulario = array_map(function($cuestionario) {
  587.                     $cuestionario['valor'] = null;
  588.                     return $cuestionario;
  589.                 }, $convocatoria->getCuestionarios());
  590.             $documentos = array_map(function($documento) {
  591.                     $documento['valor'] = null;
  592.                     return $documento;
  593.                 }, $convocatoria->getDocumentos());
  595.             $postulacion = new PcPostulacion();
  596.             $postulacion->setConvocatoria($convocatoria);
  597.             $postulacion->setPuntoCultura($puntoCultura);
  598.             $postulacion->setFormularioPostulacion($formulario);
  599.             $postulacion->setDocumentosPostulacion($documentos);
  600.             $postulacion->setFormularioAdmisibilidad($formularioAdmisibilidad);
  601.             $postulacion->setFormularioSeleccion($formularioSeleccion);
  602.             $postulacion->setFormularioEvaluacion($formularioEvaluacion);
  603.             $postulacion->setEstado('save');
  604.             $now = new DateTime();
  605.             $postulacion->setCreatedAt($now);
  606.             $postulacion->updateTimestamps();
  608.             // Validar con Symfony Validator
  609.             $errors = $validator->validate($postulacion);
  610.             if (count($errors) > 0) {
  611.                 $errorMessages = [];
  612.                 foreach ($errors as $error) {
  613.                     $errorMessages[] = $error->getMessage();
  614.                 }
  615.                 return new JsonResponse(['error' => $errorMessages], JsonResponse::HTTP_BAD_REQUEST);
  616.             }
  617.             $pcPostulacionRepository->save($postulacion, true);
  619.             $postulacionObj = [
  620.                 'id' => $postulacion->getId(),
  621.                 'montoRequerido' => $postulacion->getMontoRequerido(),
  622.                 'formularioPostulacion' => $postulacion->getFormularioPostulacion(),
  623.                 'documentosPostulacion' => $postulacion->getDocumentosPostulacion(),
  624.                 'anexos' => $postulacion->getDocumentos(),
  625.                 'convocatoriaId' => $postulacion->getConvocatoria()->getId(),
  626.                 'convocatoriaNombre' => $postulacion->getConvocatoria()->getNombre(),
  627.             ];
  628.             return new JsonResponse(['message' => 'Postulacion creada con éxito', 'postulacion' => $postulacionObj ], JsonResponse::HTTP_CREATED);
  630.         } catch (\Exception $e) {
  631.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  632.         }
  633.     }
  635.     #[Route('/secure/postulacion/{id}', name: 'actualizarPostulacion', methods: ['PUT'])]
  636.     public function actualizarPostulacion(
  637.         $id,
  638.         Request $request,
  639.         PcPostulacionRepository $pcPostulacionRepository,
  640.         Security $security,
  641.         ValidatorInterface $validator,
  642.         ValidacionService $validacionService
  643.     ): JsonResponse
  644.     {
  645.         try {
  646.             $user = $security->getUser();
  647.             if (!$user) {
  648.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  649.             }
  650.             $rut = $user->getRut();
  651.             $dv = $user->getDv();
  652.             $postulacion = $pcPostulacionRepository->findByIdAndRut($id, $rut, $dv);
  653.             if (!$postulacion) {
  654.                 return new JsonResponse(['error' => 'Postulacion no encontrada'], JsonResponse::HTTP_NOT_FOUND);
  655.             }
  657.             $punto = $postulacion->getPuntoCultura();
  658.             if(!$punto || !$punto->getActivo()){
  659.                 return new JsonResponse(['error' => 'Punto de cultura no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  660.             }
  662.             $convocatoria = $postulacion->getConvocatoria();
  663.             if (!$convocatoria) {
  664.                 return new JsonResponse(['error' => 'Convocatoria no encontrada'], JsonResponse::HTTP_NOT_FOUND);
  665.             }
  667.             if($convocatoria->getEstado() !== '1'){
  668.                 return new JsonResponse(['error' => 'Convocatoria no esta en fase de postulación'], JsonResponse::HTTP_BAD_REQUEST);
  669.             }
  671.             $estadoOriginal = $postulacion->getEstado();
  672.             if($estadoOriginal == 'send'){
  673.                 return new JsonResponse(['error' => 'Postulacion ya fue enviada'], JsonResponse::HTTP_BAD_REQUEST);
  674.             }
  676.             $data = json_decode($request->getContent(), true);
  677.             if (!$validacionService->validacionesOrNulo([
  678.                 $data['estado'],
  679.             ], 'string')) {
  680.                 return new JsonResponse(['error' => 'Los campos de estado deben ser texto'], JsonResponse::HTTP_BAD_REQUEST);
  681.             }
  682.             if (!$validacionService->validacionesOrNulo([
  683.                 $data['montoRequerido']
  684.             ], 'integer')) {
  685.                 return new JsonResponse(['error' => 'Los campos de montoRequerido deben ser numerico'], JsonResponse::HTTP_BAD_REQUEST);
  686.             }
  687.             if (!$validacionService->validacionesOrNulo([
  688.                 $data['formularioPostulacion'],
  689.                 $data['documentosPostulacion'],
  690.                 $data['anexos']
  691.             ], 'array')) {
  692.                 return new JsonResponse(['error' => 'Los campos de formularioPostulacion, documentosPostulacion y anexos deben ser objetos'], JsonResponse::HTTP_BAD_REQUEST);
  693.             }
  695.             if($data['estado'] == 'send'){
  696.                 $now = new DateTime();
  697.                 $postulacion->setPostulatedAt($now);
  698.             }
  700.             $postulacion->setMontoRequerido($data['montoRequerido']);
  701.             $postulacion->setFormularioPostulacion($data['formularioPostulacion']);
  702.             $postulacion->setDocumentosPostulacion($data['documentosPostulacion']);
  703.             $postulacion->setDocumentos($data['anexos']);
  704.             $postulacion->setEstado($data['estado'] ?? 'save');
  705.             $postulacion->updateTimestamps();
  707.             // Validar con Symfony Validator
  708.             $errors = $validator->validate($postulacion);
  709.             if (count($errors) > 0) {
  710.                 $errorMessages = [];
  711.                 foreach ($errors as $error) {
  712.                     $errorMessages[] = $error->getMessage();
  713.                 }
  714.                 return new JsonResponse(['error' => $errorMessages], JsonResponse::HTTP_BAD_REQUEST);
  715.             }
  717.             $pcPostulacionRepository->save($postulacion, true);
  719.             $postulacionObj = [
  720.                 'id' => $postulacion->getId(),
  721.                 'montoRequerido' => $postulacion->getMontoRequerido(),
  722.                 'formularioPostulacion' => $postulacion->getFormularioPostulacion(),
  723.                 'documentosPostulacion' => $postulacion->getDocumentosPostulacion(),
  724.                 'anexos' => $postulacion->getDocumentos(),
  725.                 'convocatoriaId' => $postulacion->getConvocatoria()->getId(),
  726.                 'convocatoriaNombre' => $postulacion->getConvocatoria()->getNombre(),
  727.                 'nombrePuntoCultura' => $punto->getNombre(),
  728.                 'idPuntoCultura' => $punto->getId(),
  729.             ];
  731.             return new JsonResponse(['message' => 'Postulación actualizada con éxito', 'postulacion' => $postulacionObj]);
  733.         } catch (\Exception $e) {
  734.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  735.         }
  736.     }
  738.     #[Route('/secure/postulacion/{id}', name: 'obtenerPostulacion', methods: ['GET'])]
  739.     public function obtenerPostulacion(
  740.         $id,
  741.         PcPostulacionRepository $pcPostulacionRepository,
  742.         Security $security
  743.     ): JsonResponse
  744.     {
  745.         try {
  746.             $user = $security->getUser();
  747.             if (!$user) {
  748.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  749.             }
  750.             $rut = $user->getRut();
  751.             $dv = $user->getDv();
  752.             $postulacion = $pcPostulacionRepository->findByIdAndRut($id, $rut, $dv);
  754.             if (!$postulacion) {
  755.                 return new JsonResponse(['error' => 'Postulacion no encontrada'], JsonResponse::HTTP_NOT_FOUND);
  756.             }
  758.             $punto = $postulacion->getPuntoCultura();
  759.             if(!$punto || !$punto->getActivo()){
  760.                 return new JsonResponse(['error' => 'Punto de cultura no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  761.             }
  763.             $usuarioAdmisibilidad = $postulacion->getUsuarioAdmisibilidad();
  764.             $usuarioEvaluacion = $postulacion->getUsuarioEvaluacion();
  765.             $usuarioSeleccion = $postulacion->getUsuarioSeleccion();
  767.             return $this->json([
  768.                 'id' => $postulacion->getId(),
  769.                 'montoRequerido' => $postulacion->getMontoRequerido(),
  770.                 'formularioPostulacion' => $postulacion->getFormularioPostulacion(),
  771.                 'documentosPostulacion' => $postulacion->getDocumentosPostulacion(),
  772.                 'certificadoPostulacion' => $postulacion->getCertificadoPostulacion(),
  773.                 'resultadoAdmisibilidad' => $postulacion->getResultadoAdmisibilidad(),
  774.                 'estadoAdmisibilidad' => $postulacion->getEstadoAdmisibilidad(),
  775.                 'formularioAdmisibilidad' => $postulacion->getFormularioAdmisibilidad(),
  776.                 'notaFinalEvaluacion' => $postulacion->getNotaFinalEvaluacion(),
  777.                 'formularioEvaluacion' => $postulacion->getFormularioEvaluacion(),
  778.                 'estadoEvaluacion' => $postulacion->getEstadoEvaluacion(),
  779.                 'formularioSeleccion' => $postulacion->getFormularioSeleccion(),
  780.                 'estado' => $postulacion->getEstado(),
  781.                 'formularioSeleccion' => $postulacion->getFormularioSeleccion(),
  782.                 'estadoSeleccion' => $postulacion->getEstadoSeleccion(),
  783.                 'resultadoSeleccion' => $postulacion->getResultadoSeleccion(),
  784.                 'montoAdjudicado' => $postulacion->getMontoAdjudicado(),
  785.                 'anexos' => $postulacion->getDocumentos(),
  786.                 'convocatoriaId' => $postulacion->getConvocatoria()->getId(),
  787.                 'convocatoriaNombre' => $postulacion->getConvocatoria()->getNombre(),
  788.                 'usuarioAdmisibilidad' => $usuarioAdmisibilidad ? $usuarioAdmisibilidad->getNombres() : null,
  789.                 'usuarioEvaluacion' => $usuarioEvaluacion ? $usuarioEvaluacion->getNombres() : null,
  790.                 'usuarioSeleccion' => $usuarioSeleccion ? $usuarioSeleccion->getNombres() : null,
  791.                 'admisibilidadAt' => $postulacion->getAdmisibilidadAt(),
  792.                 'evaluacionAt' => $postulacion->getEvaluacionAt(),
  793.                 'seleccionAt' => $postulacion->getSeleccionAt(),
  794.                 'nombrePuntoCultura' => $punto->getNombre(),
  795.                 'idPuntoCultura' => $punto->getId(),
  796.             ]);
  798.         } catch (\Exception $e) {
  799.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  800.         }
  801.     }
  803.     #[Route('/secure/postulaciones', name: 'obtenerPostulaciones', methods: ['GET'])]
  804.     public function obtenerPostulaciones(
  805.         PcPostulacionRepository $pcPostulacionRepository,
  806.         Security $security
  807.     ): JsonResponse
  808.     {
  809.         try {
  810.             $user = $security->getUser();
  811.             if (!$user) {
  812.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  813.             }
  814.             $rut = $user->getRut();
  815.             $dv = $user->getDv();
  816.             $postulaciones = $pcPostulacionRepository->findByRut($rut, $dv);
  817.             $postulacionesJson = [];
  818.             foreach ($postulaciones as $postulacion) {
  819.                 $puntoCultura = $postulacion->getPuntoCultura();
  820.                 $convocatoria = $postulacion->getConvocatoria();
  822.                 $postulacionesJson[] = [
  823.                     'id' => $postulacion->getId(),
  824.                     'nombre' => $convocatoria->getNombre(),
  825.                     'convocatoriaEstado' => $convocatoria->getEstado(),
  826.                     'estado' => $postulacion->getEtapaPostulacion(),
  827.                     'resultadoEvaluacion' => $postulacion->getResultadoPostulacion(),
  828.                     'editar' => $postulacion->getEstado() == 'send' ? false : true,
  829.                     'puntoCultura' => $puntoCultura->getNombre(),
  830.                     'pundoCulturaId' => $puntoCultura->getId(),
  831.                 ];
  832.             }
  833.             return $this->json(['postulaciones' => $postulacionesJson]);
  834.         } catch (\Exception $e) {
  835.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  836.         }
  837.     }
  839.     #[Route('/secure/mis-puntos', name: 'obtenerMisPuntosDeCultura', methods: ['GET'])]
  840.     public function obtenerMisPuntosDeCultura(
  841.         PcPuntoCulturaRepository $pcPuntoCulturaRepository,
  842.         Security $security
  843.     ): JsonResponse
  844.     {
  845.         try {
  846.             $user = $security->getUser();
  847.             if (!$user) {
  848.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  849.             }
  850.             $rut = $user->getRut();
  851.             $dv = $user->getDv();
  852.             $puntos = $pcPuntoCulturaRepository->findByRut($rut, $dv);
  853.             $data = [];
  854.             $puntosResponse = [];
  856.             foreach ($puntos as $punto) {
  857.                 $puntosResponse[] = [
  858.                     'id' => $punto->getId(),
  859.                     'nombre' => $punto->getNombre(),
  860.                 ];
  861.             }
  862.             return $this->json($puntosResponse);
  863.         } catch (\Exception $e) {
  864.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  865.         }
  866.     }
  869.     #[Route('/secure/mi-perfil', name: 'obtenerMiPerfil', methods: ['GET'])]
  870.     public function obtenerMiPerfil(
  871.         PcPuntoCulturaRepository $pcPuntoCulturaRepository,
  872.         RacService $racService,
  873.         Security $security
  874.     ): JsonResponse
  875.     {
  876.         try {
  877.             $user = $security->getUser();
  878.             if (!$user) {
  879.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  880.             }
  881.             $rut = $user->getRut();
  882.             $dv = $user->getDv();
  883.             $puntos = $pcPuntoCulturaRepository->findByRut($rut, $dv);
  884.             $data = [];
  885.             $puntosResponse = [];
  887.             $userRut = strval(number_format((int) $rut, 0, '', '.')) . '-' . $dv;
  888.             $organizaciones = $racService->getRegisterRac($userRut);
  890.             $organizacionesById = [];
  891.             foreach($organizaciones as $org){
  892.                 if(empty($org['org_id'])) continue;
  893.                 $org_id = $org['org_id'];
  894.                 $organizacionesById[$org_id] = $org;
  895.             }
  897.             foreach ($puntos as $punto) {
  898.                 $organizacionId = (string) $punto->getOrganizacionComunitariaId();
  899.                 $rac = $organizacionesById[$organizacionId] ?? [];
  900.                 $puntosResponse[] = [
  901.                     'id' => $punto->getId(),
  902.                     'nombre' => $punto->getNombre() ?? '',
  903.                     'resenia' => $punto->getResenia() ?? '',
  904.                     'region' => $punto->getRegion() ?? '',
  905.                     'comuna' => $punto->getComuna() ?? '',
  906.                     'direccion' => $punto->getDireccion() ?? '',
  907.                     'georeferencia' => $punto->getGeoreferencia() ?? '',
  908.                     'nombre_contacto' => $punto->getNombreContacto() ?? '',
  909.                     'email_contacto' => $punto->getEmailContacto() ?? '',
  910.                     'redes_sociales' => $punto->getRedesSociales(),
  911.                     'certificado_punto' => $punto->getCertificadoPunto() ?? '',
  912.                     'nombre_persona_juridica' => $punto->getNombrePersonaJuridica() ?? '',
  913.                     'nombre_representante_legal' => $punto->getNombreRepresentanteLegal() ?? '',
  914.                     'rut_persona_juridica' => $punto->getRutPersonaJuridica() ?? '',
  915.                     'rut_representante_legal' => $punto->getRutRepresentanteLegal() ?? '',
  916.                     'direccion_postal' => $punto->getDireccionPostal() ?? '',
  917.                     'correo_electronico_1' => $punto->getCorreoElectronico1() ?? '',
  918.                     'correo_electronico_2' => $punto->getCorreoElectronico2() ?? '',
  919.                     'telefono_1' => $punto->getTelefono1() ?? '',
  920.                     'telefono_2' => $punto->getTelefono2() ?? '',
  921.                     'organizacion_comunitaria_id' => $punto->getOrganizacionComunitariaId(),
  922.                     'doc_estatuto_organizacion' => $punto->getDocEstatutoOrganizacion(),
  923.                     'doc_certificado_vigencia_persona_juridica' => $punto->getDocCertificadoVigenciaPersonaJuridica(),
  924.                     'doc_acredita_personeria_vigente' => $punto->getDocAcreditaPersoneriaVigente(),
  925.                     'doc_listado_personas'=> $punto->getDocListadoPersonas(),
  926.                     'documentos' => $punto->getDocumentos(),
  927.                     'rut' => $punto->getRut(),
  928.                     'dv' => $punto->getDv(),
  929.                     'rac' => $rac,
  930.                 ];
  931.             }
  932.             return $this->json($puntosResponse);
  934.         } catch (\Exception $e) {
  935.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  936.         }
  937.     }
  939.     #[Route('/secure/convocatoria/{id}', name: 'obtenerConvocatoria', methods: ['GET'])]
  940.     public function obtenerConvocatoria(
  941.         $id,
  942.         PcConvocatoriasRepository $pcConvocatoriaRepository,
  943.         Security $security
  944.     ): JsonResponse
  945.     {
  946.         try {
  947.             $convocatoria = $pcConvocatoriaRepository->find($id);
  949.             if (!$convocatoria) {
  950.                 return new JsonResponse(['error' => 'Convocatoria no encontrada'], JsonResponse::HTTP_NOT_FOUND);
  951.             }
  952.             $criterios = [];
  953.             $criteriosData = $convocatoria->getCriterios();
  955.             foreach ($criteriosData as $criterioConvocatoria) {
  956.                 $criterios[] = [
  957.                     'id' => $criterioConvocatoria->getCriterios()->getId(),
  958.                     'peso' => $criterioConvocatoria->getPeso()
  959.                 ];
  960.             }
  962.             return $this->json([
  963.                 'id' => $convocatoria->getId(),
  964.                 'nombre' => $convocatoria->getNombre(),
  965.                 'descripcion' => $convocatoria->getDescripcion(),
  966.                 'anio' => $convocatoria->getAnio(),
  967.                 'bases' => $convocatoria->getBases(),
  968.                 'presupuesto' => $convocatoria->getPresupuesto(),
  969.                 'puntajeEvalCorte' => $convocatoria->getPuntajeEvalCorte(),
  970.                 'cuestionarios' => $convocatoria->getCuestionarios(),
  971.                 'documentos' => $convocatoria->getDocumentos(),
  972.                 'estado' => $convocatoria->getEstado(),
  973.                 'criterios' => $criterios,
  974.             ]);
  976.         } catch (\Exception $e) {
  977.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  978.         }
  979.     }
  981.     #[Route('/secure/cargar', name: 'cargar', methods: ['POST'])]
  982.     public function cargarArchivos(
  983.         Request $request,
  984.         PcPostulacionRepository $pcPostulacionRepository,
  985.         PcPuntoCulturaRepository $pcPuntoCulturaRepository,
  986.         Security $security
  987.     ): JsonResponse
  988.     {
  989.         try {
  990.             $user = $security->getUser();
  991.             if (!$user) {
  992.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  993.             }
  994.             $rut = $user->getRut();
  995.             $dv = $user->getDv();
  997.             $file = $request->files->get('file');
  998.             if (!$file) {
  999.                 return new JsonResponse(['error' => 'No hay documento'], 400);
  1000.             }
  1002.             // Obtener configuración desde .env
  1003.             $maxFileSizeMB = $_ENV['MAX_FILE_SIZE'] ?? 10;
  1004.             $allowedExtensions = explode(',', $_ENV['ALLOWED_EXTENSIONS'] ?? '');
  1006.             // Validar tamaño del archivo
  1007.             $fileSizeMB = $file->getSize() / (1024 * 1024); // Convertir a MB
  1008.             if ($fileSizeMB > $maxFileSizeMB) {
  1009.                 return new JsonResponse(['error' => "El archivo supera el tamaño máximo permitido de {$maxFileSizeMB}MB"], 400);
  1010.             }
  1012.             // Validar extensión
  1013.             $extension = $file->guessExtension();
  1014.             if (!in_array($extension, $allowedExtensions)) {
  1015.                 return new JsonResponse(['error' => "Extensión no permitida. Solo se aceptan: " . implode(', ', $allowedExtensions)], 400);
  1016.             }
  1018.             $postulacionId = $request->request->get('postulacionId');
  1019.             $puntoCulturaId = $request->request->get('puntoCulturaId');
  1021.             $tipoDocumento = '';
  1023.             if(!empty($postulacionId)){
  1024.                 $tipoDocumento="/pcpostulaciones/postulacion_" . $postulacionId;
  1025.                 $postulacion = $pcPostulacionRepository->findByIdAndRut($postulacionId, $rut, $dv);
  1026.                 if (!$postulacion) {
  1027.                     return new JsonResponse(['error' => 'Postulacion no encontrada'], JsonResponse::HTTP_NOT_FOUND);
  1028.                 }
  1029.             } else if (!empty($puntoCulturaId)){
  1030.                 $tipoDocumento="/puntoscultura/puntocultura_" . $puntoCulturaId;
  1031.                 $punto = $pcPuntoCulturaRepository->findByIdAndRut($puntoCulturaId, $rut, $dv);
  1032.                 if (!$punto) {
  1033.                     return new JsonResponse(['error' => 'Punto no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  1034.                 }
  1035.             } else {
  1036.                 return new JsonResponse(['error' => 'postulacionId, puntoCulturaId o convocatoriaId requerido'], 400);
  1037.             }
  1039.             try {
  1040.                 $originalName = $file->getClientOriginalName();
  1041.                 $newFilename = str_replace(' ', '_', $originalName) . '-' . uniqid() . '.' . $file->guessExtension();
  1043.                 $projectRoot = $this->getParameter('kernel.project_dir');
  1044.                 $dirToMove = $projectRoot . '/public/documentos' . $tipoDocumento;
  1046.                 if (!is_dir($dirToMove)) {
  1047.                     mkdir($dirToMove, 0777, true);
  1048.                 }
  1050.                 $file->move($dirToMove, $newFilename);
  1052.                 return new JsonResponse([
  1053.                     'message' => 'Documento subido con exito',
  1054.                     'original_name' => $originalName,
  1055.                     'new_filename' => $newFilename,
  1056.                     'path' => '/documentos' . $tipoDocumento . '/' . $newFilename,
  1057.                 ], 200);
  1058.             } catch (FileException $e) {
  1059.                 return new JsonResponse(['error' => 'Falla al subir archivo: ' . $e->getMessage()], 500);
  1060.             }
  1061.         } catch (\Exception $e) {
  1062.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  1063.         }
  1064.     }
  1067.     #[Route('/secure/descargas', name: 'descargas', methods: ['POST'])]
  1068.     public function descargas(
  1069.         Request $request,
  1070.         PcPostulacionRepository $pcPostulacionRepository,
  1071.         PcPuntoCulturaRepository $pcPuntoCulturaRepository,
  1072.         PostulacionRepository $postulacionRepository,
  1073.         Security $security
  1074.     ): Response
  1075.     {
  1076.         try {
  1077.             $user = $security->getUser();
  1078.             if (!$user) {
  1079.                 return new JsonResponse(['error' => 'Usuario no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  1080.             }
  1081.             $rut = $user->getRut();
  1082.             $dv = $user->getDv();
  1084.             $data = json_decode($request->getContent(), true);
  1085.             $path = $data['path'];
  1087.             if(empty($path)){
  1088.                 return new JsonResponse(['error' => 'Falta enviar path'],
  1089.                     JsonResponse::HTTP_BAD_REQUEST);
  1090.             }
  1092.             $rutasArchivo = explode("/", $path);
  1093.             $tipoDocumento = $rutasArchivo[2];
  1095.             if($tipoDocumento == "postulaciones"){
  1096.                 $postulacionId = explode('_', $rutasArchivo[3])[1];
  1097.                 $postulacion = $postulacionRepository->findOneByRutId($rut,  $postulacionId);
  1098.                 if (!$postulacion) {
  1099.                     return new JsonResponse(['error' => 'Postulacion no encontrada'], JsonResponse::HTTP_NOT_FOUND);
  1100.                 }
  1102.             } else if($tipoDocumento == "puntoscultura"){
  1103.                 $puntoCulturaId = explode('_', $rutasArchivo[3])[1];
  1104.                 $punto = $pcPuntoCulturaRepository->findByIdAndRut($puntoCulturaId, $rut, $dv);
  1105.                 if (!$punto) {
  1106.                     return new JsonResponse(['error' => 'Punto no encontrado'], JsonResponse::HTTP_NOT_FOUND);
  1107.                 }
  1109.             } else if($tipoDocumento == "pcpostulaciones"){
  1110.                 $postulacionId = explode('_', $rutasArchivo[3])[1];
  1111.                 $postulacion = $pcPostulacionRepository->findByIdAndRut($postulacionId, $rut, $dv);
  1112.                 if (!$postulacion) {
  1113.                     return new JsonResponse(['error' => 'Postulacion no encontrada'], JsonResponse::HTTP_NOT_FOUND);
  1114.                 }
  1115.             }
  1117.             $projectRoot = $this->getParameter('kernel.project_dir');
  1118.             $filePath = $projectRoot . '/public' . $path;
  1120.             if (!file_exists($filePath)) {
  1121.                 throw $this->createNotFoundException("Archivo no encontrado");
  1122.             }
  1124.             $filename = $rutasArchivo[count($rutasArchivo)-1];
  1125.             // Devolver el archivo como una respuesta
  1126.             $response = new BinaryFileResponse($filePath);
  1127.             $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT, $filename);
  1129.             return $response;
  1130.         } catch (\Exception $e) {
  1131.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  1132.         }
  1133.     }
  1135.     #[Route('/insecure/file', name: 'obtenerInfoFile', methods: ['GET'])]
  1136.     public function obtenerInfoFile(): JsonResponse
  1137.     {
  1138.         try {
  1139.             return $this->json([
  1140.                 'maxFileSize' => $_ENV['MAX_FILE_SIZE'] ?? 10,
  1141.                 'allowedExtensions' => explode(',', $_ENV['ALLOWED_EXTENSIONS'] ?? '')
  1142.             ]);
  1143.         } catch (\Exception $e) {
  1144.             return new JsonResponse(['error' => 'Error de servidor', 'detalle' => $e->getMessage()], 500);
  1145.         }
  1146.     }
  1147. }