Proyectos de Subversion LeadersLinked - Services

<?php

declare(strict_types=1);

namespace LeadersLinked\Controller;

use Smalot\PdfParser\Parser;

use Laminas\Mvc\Controller\AbstractActionController;
use Laminas\View\Model\ViewModel;
use Laminas\View\Model\JsonModel;
use Laminas\Db\Adapter\AdapterInterface;
use Laminas\Db\Sql\Select;
use Laminas\Db\Adapter\Adapter;
use Laminas\Db\Sql\Sql;
use Laminas\Db\ResultSet\HydratingResultSet;
use Laminas\Hydrator\ArraySerializableHydrator;
use LeadersLinked\Mapper\CompetencyMapper;
use LeadersLinked\Mapper\JobDescriptionMapper;
use LeadersLinked\Mapper\JobDescriptionCompetencyMapper;
use LeadersLinked\Mapper\LocationMapper;
use LeadersLinked\Mapper\QueryMapper;
use ArrayObject;

class RecruitmentCreateJobDescriptionController extends AbstractActionController
{
    /**
     *
     * @var \Laminas\Db\Adapter\AdapterInterface
     */
    private $adapter;

    /**
     *
     * @var \LeadersLinked\Cache\CacheInterface
     */
    private $cache;


    /**
     *
     * @var \Laminas\Log\LoggerInterface
     */
    private $logger;

    /**
     *
     * @var array
     */
    private $config;


    /**
     *
     * @var \Laminas\Mvc\I18n\Translator
     */
    private $translator;


    /**
     *
     * @param \Laminas\Db\Adapter\AdapterInterface $adapter
     * @param \LeadersLinked\Cache\CacheInterface $cache
     * @param \Laminas\Log\LoggerInterface LoggerInterface $logger
     * @param array $config
     * @param \Laminas\Mvc\I18n\Translator $translator
     */
    public function __construct($adapter, $cache, $logger, $config, $translator)
    {
        $this->adapter      = $adapter;
        $this->cache        = $cache;
        $this->logger       = $logger;
        $this->config       = $config;
        $this->translator   = $translator;
    }

    public function indexAction()
    {
        $request = $this->getRequest();

        // 🔹 Obtener el ID desde la ruta (URL) con el formato /endpoint/:id
        $jobDescriptionId = $this->params()->fromRoute('id');

        // 🔹 Verificar si el ID es válido
        if (!$jobDescriptionId) {
            return new JsonModel([
                'success' => false,
                'message' => 'Missing vacancy ID'
            ]);
        }

        // 🔹 Obtener usuario y permisos ACL
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $acl = $this->getEvent()->getViewModel()->getVariable('acl');

        // 🔹 Verificar si el usuario tiene permiso para extraer criterios
        if (!$acl->isAllowed($currentUser->usertype_id, 'recruitment-ai/job-description')) {
            return new JsonModel([
                'success' => false,
                'message' => 'Access denied'
            ]);
        }

        if ($request->isGet()) {

            // Llamar a la función que obtiene los archivos de la vacante
            $competencies = $this->getJobDescriptionCompetencies($jobDescriptionId);

            return new JsonModel([
                'success' => true,
                'data' => $competencies
            ]);
        }

        // Si el método no es GET ni POST
        return new JsonModel([
            'success' => false,
            'message' => 'Invalid request method'
        ]);
    }

    public function getJobDescriptionCompetencies($jobDescriptionId)
    {
        // 🔹 Validación básica del ID
        if (!is_numeric($jobDescriptionId) || $jobDescriptionId <= 0) {
            return null;
        }

        try {
            // 🔹 Crear el QueryMapper
            $queryMapper = QueryMapper::getInstance($this->adapter);
            $select = $queryMapper->getSql()->select();

            // 🔹 FROM JobDescriptionMapper
            $select->from(['jd' => JobDescriptionMapper::_TABLE]);
            $select->columns([
                'name',
                'functions',
                'objectives'
            ]);

            // 🔹 JOIN con JobDescriptionCompetencyMapper
            $select->join(
                ['jdc' => JobDescriptionCompetencyMapper::_TABLE],
                'jd.id = jdc.job_description_id',
                [] // No seleccionamos nada directamente de esta tabla
            );

            // 🔹 JOIN con CompetencyMapper
            $select->join(
                ['c' => CompetencyMapper::_TABLE],
                'jdc.competency_id = c.id',
                [
                    'competency_name' => 'name',
                    'competency_description' => 'description'
                ]
            );

            // 🔹 WHERE por ID de descripción de trabajo
            $select->where->equalTo('jd.id', $jobDescriptionId);

            // 🔹 Ejecutar la consulta
            $statement = $queryMapper->getSql()->prepareStatementForSqlObject($select);
            $resultSet = $statement->execute();

            // 🔹 Procesar resultados
            $hydrator = new ArraySerializableHydrator();
            $hydratingResultSet = new HydratingResultSet($hydrator);
            $hydratingResultSet->initialize($resultSet);

            // 🔹 Agrupar resultados por competencias
            $jobInfo = null;
            $competencies = [];

            foreach ($hydratingResultSet as $row) {
                if (!$jobInfo) {
                    $jobInfo = [
                        'name' => $row['name'],
                        'functions' => $row['functions'],
                        'objectives' => $row['objectives']
                    ];
                }

                $competencies[] = [
                    'name' => $row['competency_name'],
                    'description' => $row['competency_description']
                ];
            }

            if (!$jobInfo) {
                return null;
            }

            // 🔹 Construir el texto formateado
            $formattedText =
                "### Información del Trabajo\n" .
                "Nombre: {$jobInfo['name']}\n" .
                "Funciones: {$jobInfo['functions']}\n" .
                "Objetivos: {$jobInfo['objectives']}\n\n" .
                "### Competencias requeridas:\n";

            foreach ($competencies as $index => $comp) {
                $formattedText .= ($index + 1) . ". {$comp['name']} - {$comp['description']}\n";
            }

            return $formattedText;
        } catch (\Exception $e) {
            // Aquí podrías loggear el error si es necesario
            return null;
        }
    }
}