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\RecruitmentSelectionVacancyMapper;

use LeadersLinked\Mapper\JobDescriptionMapper;

use LeadersLinked\Mapper\JobCategoryMapper;

use LeadersLinked\Mapper\LocationMapper;

use LeadersLinked\Mapper\QueryMapper;

use ArrayObject;

class RecruitmentPreAplicationController 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

        $vacancyId = $this->params()->fromRoute('id');

        // 🔹 Verificar si el ID es válido

        if (!$vacancyId) {

            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, 'ia-vacancies-aplications')) {

            return new JsonModel([

                'success' => false,

                'message' => 'Access denied'

            ]);

        }

        if ($request->isGet()) {

            // Llamar a la función que obtiene los archivos de la vacante

            $candidates = $this->getSelectionPreAplicationCandidates($vacancyId);

            return new JsonModel([

                'success' => true,

                'data' => $candidates

            ]);

        }

        if ($request->isPost()) {

            // 🔹 Obtener los CVs en Base64 desde el cuerpo de la solicitud

            $bodyParams = json_decode($this->getRequest()->getContent(), true);

            $cvs = $bodyParams['cvs'] ?? [];

            // 🔹 Verificar si hay CVs

            if (empty($cvs)) {

                return new JsonModel([

                    'success' => false,

                    'message' => 'Missing CVs data'

                ]);

            }

            // 🔹 Obtener criterios desde la base de datos

            $criteria = $this->getSelectionCriteriaVacancy($vacancyId);

            // 🔹 Verificar si los criterios existen

            if (!$criteria) {

                return new JsonModel([

                    'success' => false,

                    'message' => 'No selection criteria found for this vacancy'

                ]);

            }

            // 🔹 Procesar los CVs y analizar compatibilidad con los criterios

            try {

                $processedCvs = $this->processCvs($cvs, $criteria, $vacancyId);

                return new JsonModel([

                    'success' => true,

                    'data' => $processedCvs

                ]);

            } catch (\Exception $e) {

                return new JsonModel([

                    'success' => false,

                    'message' => 'Error processing CVs: ' . $e->getMessage()

                ]);

            }

        }

        // Si el método no es GET ni POST

        return new JsonModel([

            'success' => false,

            'message' => 'Invalid request method'

        ]);

    }

    public function getSelectionCriteriaVacancy($vacancyId)

    {

        // 🔹 Verificar si el ID es válido

        if (!$vacancyId) {

            return null;

        }

        // 🔹 Construcción de la consulta con QueryMapper

        $queryMapper = QueryMapper::getInstance($this->adapter);

        $select = $queryMapper->getSql()->select();

        $select->from(['tb1' => RecruitmentSelectionVacancyMapper::_TABLE]);

        $select->columns(['uuid', 'name', 'status']);

        // 🔹 JOIN con JobDescriptionMapper (incluyendo functions y objectives)

        $select->join(

            ['tb2' => JobDescriptionMapper::_TABLE],

            'tb1.job_description_id = tb2.id AND tb1.company_id = tb2.company_id',

            [

                'job_description_name' => 'name',

                'job_description_functions'   => 'functions',

                'job_description_objectives'  => 'objectives'

            ]

        );

        // 🔹 JOIN con JobCategoryMapper (para obtener nombre y descripción de la categoría)

        $select->join(

            ['tb3' => JobCategoryMapper::_TABLE],

            'tb1.job_category_id = tb3.id',

            [

                'job_category_name'        => 'name',

                'job_category_description' => 'description'

            ]

        );

        // 🔹 JOIN con LocationMapper (para obtener país y dirección formateada)

        $select->join(

            ['tb4' => LocationMapper::_TABLE],

            'tb1.location_id = tb4.id',

            [

                'job_location_country' => 'country',

                'job_location_address' => 'formatted_address'

            ]

        );

        // 🔹 Filtrar por el ID de la vacante

        $select->where->equalTo('tb1.id', $vacancyId);

        // 🔹 Ejecutar la consulta

        $statement = $queryMapper->getSql()->prepareStatementForSqlObject($select);

        $resultSet = $statement->execute();

        // 🔹 Procesar los resultados

        $hydrator = new ArraySerializableHydrator();

        $hydratingResultSet = new HydratingResultSet($hydrator);

        $hydratingResultSet->initialize($resultSet);

        // 🔹 Obtener un solo resultado como diccionario

        $vacancyData = $hydratingResultSet->current();

        // 🔹 Validar si no se encontró la vacante

        if (!$vacancyData) {

            return null;

        }

        // 🔹 Formatear la respuesta en una variable de texto

        $formattedText =

            "Nombre: {$vacancyData['name']}\n" .

            "### Descripción del trabajo\n" .

            "Nombre: {$vacancyData['job_description_name']}\n" .

            "Funciones: {$vacancyData['job_description_functions']}\n\n" .

            "Objetivos: {$vacancyData['job_description_objectives']}\n\n" .

            "### Ubicación\n" .

            "País: {$vacancyData['job_location_country']}\n" .

            "Dirección: {$vacancyData['job_location_address']}\n";

        return $formattedText;

    }

    public function getSelectionPreAplicationCandidates($vacancyId)

    {

        // 🔹 Verificar si el ID es válido

        if (!$vacancyId) {

            return new JsonModel([

                'success' => true,

                'message' => 'No existen aplicaciones para la vacante.',

            ]);

        }

        // 🔹 Construcción de la consulta SQL

        $queryMapper = QueryMapper::getInstance($this->adapter);

        $select = $queryMapper->getSql()->select();

        $select->from('tbl_recruitment_selection_pre_aplications'); // Se cambia la tabla

        $select->columns(['*']); // Obtener todos los campos

        // 🔹 Filtrar por vacancy_id

        $select->where->equalTo('vacancy_id', $vacancyId);

        // 🔹 Ejecutar la consulta

        $statement = $queryMapper->getSql()->prepareStatementForSqlObject($select);

        $resultSet = $statement->execute();

        // 🔹 Procesar los resultados en un array de diccionarios

        $hydrator = new ArraySerializableHydrator();

        $hydratingResultSet = new HydratingResultSet($hydrator);

        $hydratingResultSet->initialize($resultSet);

        // 🔹 Convertir los resultados en un array de diccionarios

        $applications = [];

        foreach ($hydratingResultSet as $row) {

            $row['skills'] = json_decode($row['skills'], true) ?? [];

            $row['previous_positions'] = json_decode($row['previous_positions'], true) ?? [];

            $applications[] = $row;

        }

        return $applications;

    }

    function extractTextFromBase64Cvs(array $cvs): array

    {

        $parser = new Parser();

        $results = [];

        foreach ($cvs as $cv) {

            $decodedFile = base64_decode($cv['file']); // Decodificar el contenido del archivo

            $filePath = sys_get_temp_dir() . '/' . uniqid() . '.pdf'; // Guardarlo temporalmente

            file_put_contents($filePath, $decodedFile);

            // Extraer texto del PDF

            $pdf = $parser->parseFile($filePath);

            $text = $pdf->getText();

            if (!$text) {

                throw new \Exception('Could not extract text from CV: ' . $cv['name']);

            }

            $results[] = [

                'id' => $cv['id'],

                'name' => $cv['name'],

                'text' => $text,

            ];

            unlink($filePath); // Eliminar archivo temporal

        }

        return $results;

    }

    function cleanContent($text)

    {

        // Eliminar la palabra "json"

        $text = str_replace("json", "", $text);

        // Eliminar los saltos de línea \n

        $text = str_replace("\n", "", $text);

        // Eliminar los acentos invertidos (```)

        $text = str_replace("```", "", $text);

        // Retornar el contenido arreglado

        return $text;

    }

    public function processCvs(array $cvs, $criteria, $vacancyId)

    {

        // Extraer los textos de los CVs desde base64

        $extractedCvs = $this->extractTextFromBase64Cvs($cvs);

        $extractedData = [];

        // Mensaje inicial para la IA (Contexto del sistema)

        $messages = [

            ['role' => 'system', 'content' => 'Extrae información clave de los currículums en formato JSON estructurado.']

        ];

        // 🔹 Primera consulta: Extraer información clave de los CVs

        foreach ($extractedCvs as $cv) {

            // Mensaje para la IA con la instrucción de formateo JSON

            $messages[] = [

                'role' => 'user',

                'content' => "Extrae la información del currículum en formato JSON válido y estructurado, sin texto adicional ni explicaciones:

                {

                    \"name\": \"Nombre del candidato\",

                    \"location\": \"Ubicación\",

                    \"years_of_experience\": \"Número de años de experiencia\",

                    \"previous_positions\": [\"Cargo 1\", \"Cargo 2\", \"Cargo 3\"],

                    \"specialization\": \"Especialización en educación\",

                    \"skills\": [\"Habilidad1\", \"Habilidad2\", \"Habilidad3\"],

                }

                Adicionalmente genera una clave uuid para cada aplicante y colocala en el json.

                Aquí está el currículum: " . $cv['text']

            ];

            // Enviar consulta a la IA

            $response = $this->analyzeCvWithAi($messages);

            // Eliminar la palabra json del texto

            $content = $this->cleanContent($response['choices'][0]['message']['content'] ?? '{}');

            // Decodificar JSON desde la respuesta de la IA

            $aiResponse = json_decode($content, true);

            if ($aiResponse === null) {

                return [false, 'Error en JSON: ' . json_last_error_msg()];

            }

            // Guardar los datos extraídos de cada CV

            $extractedData[] = [

                'uuid' => $aiResponse['uuid'] ?? 'Desconocido',

                'vacancy_id' => $vacancyId,

                'full_name' => $aiResponse['name'] ?? 'Desconocido',

                'location' => $aiResponse['location'] ?? 'Desconocida',

                'years_of_experience' => $aiResponse['years_of_experience'] ?? '0',

                'previous_positions' => $aiResponse['previous_positions'] ?? [],

                'specialization' => $aiResponse['specialization'] ?? 'Desconocida',

                'skills' => $aiResponse['skills'] ?? 'Desconocida'

            ];

            // Agregar la respuesta al contexto para la siguiente consulta

            $messages[] = ['role' => 'assistant', 'content' => json_encode($aiResponse)];

        }

        // Agregar mensaje de evaluación para la IA

        $messages[] = [

            'role' => 'user',

            'content' => "Añade el puntaje de compatibilidad a las respuestas ya generadas sin modificar el resto de la información.

            Devuelve un JSON donde solo se incluya la clave \"uuid\" y su correspondiente \"compatibility_score\" dentro de cada candidato, asegurando que el puntaje (del 0 al 100) corresponda al candidato correcto según su UUID.

            El JSON debe tener la siguiente estructura:

            {

                \"uuid1_del_cv_ya_analizado\": puntaje_entre_0_y_100,

                \"uuid2_del_cv_ya_analizado\": puntaje_entre_0_y_100,

                ...

            }

            Criterios de la vacante: " . json_encode($criteria)

        ];

        // Enviar consulta a la IA para evaluar la compatibilidad

        $evaluationResponse = $this->analyzeCvWithAi($messages);

        $evaluation = $this->cleanContent($evaluationResponse['choices'][0]['message']['content'] ?? '{}');

        // Decodificar la respuesta de la IA

        $evaluation = json_decode($evaluation, true);

        // Asignar solo el puntaje de compatibilidad correcto a cada CV

        foreach ($extractedData as &$data) {

            $data['compatibility_score'] = $evaluation[$data['uuid']] ?? 0;

        }

        // Guardar o actualizar los datos en la base de datos

        $saveResult = $this->saveOrUpdatePreApplications($extractedData);

        // Validar si la inserción falló

        if ($saveResult !== true) {

            return [false, 'Error al guardar los datos: ' . json_encode($saveResult)];

        }

        // Retornar los datos procesados con las puntuaciones de compatibilidad

        return $extractedData;

    }

    private function saveOrUpdatePreApplications(array $extractedData)

    {

        $sql = new Sql($this->adapter);

        $errors = [];

        foreach ($extractedData as $data) {

            // Convertir los arrays a JSON antes de almacenarlos

            $data['previous_positions'] = json_encode($data['previous_positions'], JSON_UNESCAPED_UNICODE);

            $data['skills'] = json_encode($data['skills'], JSON_UNESCAPED_UNICODE);

            $select = $sql->select()

                ->from('tbl_recruitment_selection_pre_aplications')

                ->where(['uuid' => $data['uuid'], 'full_name' => $data['full_name']]);

            $statement = $sql->prepareStatementForSqlObject($select);

            $result = $statement->execute();

            if ($result->current()) {

                // Si existe, realizar UPDATE

                $update = $sql->update('tbl_recruitment_selection_pre_aplications')

                    ->set([

                        'vacancy_id' => $data['vacancy_id'],

                        'location' => $data['location'],

                        'years_experience' => $data['years_of_experience'],

                        'previous_positions' => $data['previous_positions'], // Ahora es JSON

                        'specialization' => $data['specialization'],

                        'skills' => $data['skills'], // Ahora es JSON

                        'vacancy_compatibility_score' => $data['compatibility_score']

                    ])

                    ->where(['uuid' => $data['uuid'], 'full_name' => $data['full_name']]);

                $updateStatement = $sql->prepareStatementForSqlObject($update);

                try {

                    $updateStatement->execute();

                } catch (\Exception $e) {

                    $errors[] = "Error al actualizar: " . $e->getMessage();

                }

            } else {

                // Si no existe, realizar INSERT

                $insert = $sql->insert('tbl_recruitment_selection_pre_aplications')

                    ->values([

                        'uuid' => $data['uuid'],

                        'vacancy_id' => $data['vacancy_id'],

                        'full_name' => $data['full_name'],

                        'location' => $data['location'],

                        'years_experience' => $data['years_of_experience'],

                        'previous_positions' => $data['previous_positions'], // Ahora es JSON

                        'specialization' => $data['specialization'],

                        'skills' => $data['skills'], // Ahora es JSON

                        'vacancy_compatibility_score' => $data['compatibility_score']

                    ]);

                $insertStatement = $sql->prepareStatementForSqlObject($insert);

                try {

                    $result = $insertStatement->execute();

                    if (!$result->getGeneratedValue()) {

                        $errors[] = "Falló la inserción para UUID: " . $data['uuid'];

                    }

                } catch (\Exception $e) {

                    $errors[] = "Error al insertar: " . $e->getMessage();

                }

            }

        }

        return empty($errors) ? true : $errors;

    }

    function callExternalApi($url, $payload, $headers)

    {

        $ch = curl_init($url);

        curl_setopt($ch, CURLOPT_CAINFO, '/etc/apache2/ssl/cacert.pem');

        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        curl_setopt($ch, CURLOPT_POST, true);

        curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);

        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

        $response = curl_exec($ch);

        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

        $curlError = curl_error($ch);

        curl_close($ch);

        // Verificar si hubo un error en la petición

        if ($curlError) {

            error_log("cURL Error: " . $curlError);

            return [false, "cURL Error: " . $curlError];

        }

        // Si la API devuelve un código de error (4xx o 5xx), registrarlo

        if ($httpCode >= 400) {

            error_log("Error HTTP {$httpCode}: " . $response);

            return [false, "Error HTTP {$httpCode}: " . $response];

        }

        // Intentar decodificar la respuesta JSON

        $decodedResponse = json_decode($response, true);

        // Verificar si la respuesta es válida

        if (json_last_error() !== JSON_ERROR_NONE) {

            error_log("Error al decodificar JSON: " . json_last_error_msg());

            return [false, "Error al decodificar JSON: " . json_last_error_msg()];

        }

        return $decodedResponse;

    }

    function analyzeCvWithAi(array $messages)

    {

        $apiKey = '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';

        $url = "https://api.openai.com/v1/chat/completions";

        $payload = json_encode([

            'model' => 'gpt-4o-mini',

            'messages' => $messages,

            'temperature' => 0.7

        ]);

        $headers = [

            'Content-Type: application/json',

            "Authorization: Bearer $apiKey"

        ];

        return $this->callExternalApi($url, $payload, $headers);

    }

}