Proyectos de Subversion LeadersLinked - Backend

<?php

declare(strict_types=1);

namespace LeadersLinked\Controller;

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\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\Library\QueryMapper;
use ArrayObject;


class RecruitmentSelectionVacancyCriteriaController 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();

        // 🔹 Validar si la solicitud es POST
        if (!$request->isPost()) {
            return new JsonModel([
                'success' => false,
                'message' => 'Invalid request method'
            ]);
        }

        // 🔹 Obtener el ID desde form-data
        $vacancyId = $this->params()->fromPost('id');

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

        // 🔹 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', 'last_date', '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',
                'job_functions'   => 'functions',
                'job_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',
                'category_description' => 'description'
            ]
        );

        // 🔹 JOIN con LocationMapper (para obtener país y dirección formateada)
        $select->join(
            ['tb4' => LocationMapper::_TABLE],
            'tb1.location_id = tb4.id',
            [
                'location_country' => 'country',
                '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 new JsonModel([
                'success' => false,
                'message' => 'Vacancy not found'
            ]);
        }

        // 🔹 Retornar la vacante en formato JSON
        return new JsonModel([
            'success' => true,
            'data' => $vacancyData
        ]);
    }
}