Proyectos de Subversion LeadersLinked - Services

<?php

/**

 *

 * Controlador: Mis Perfiles

 *

 */

declare(strict_types=1);

namespace LeadersLinked\Controller;

use Laminas\Db\Adapter\AdapterInterface;

use Laminas\Mvc\Controller\AbstractActionController;

use Laminas\Log\LoggerInterface;

use Laminas\View\Model\ViewModel;

use Laminas\View\Model\JsonModel;

use LeadersLinked\Library\Functions;

use LeadersLinked\Mapper\KnowledgeAreaCategoryMapper;

use LeadersLinked\Mapper\KnowledgeAreaCategoryUserMapper;

use LeadersLinked\Mapper\UserMapper;

use LeadersLinked\Model\KnowledgeAreaCategory;

use LeadersLinked\Model\KnowledgeAreaCategoryUser;

use LeadersLinked\Form\KnowledgeArea\KnowledgeAreaCreateForm;

use LeadersLinked\Mapper\KnowledgeAreaContentMapper;

use LeadersLinked\Model\KnowledgeAreaContent;

use LeadersLinked\Form\KnowledgeArea\KnowledgeAreaEditForm;

use LeadersLinked\Mapper\CommentMapper;

use LeadersLinked\Form\KnowledgeArea\CommentForm;

use LeadersLinked\Model\Comment;

use LeadersLinked\Mapper\ContentReactionMapper;

use LeadersLinked\Model\ContentReaction;

use LeadersLinked\Mapper\KnowledgeAreaCategoryJobDescriptionMapper;

use LeadersLinked\Mapper\OrganizationPositionMapper;

use LeadersLinked\Model\User;

use LeadersLinked\Library\Storage;

class KnowledgeAreaController 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;

    }

    /**

     *

     * Handles the display of the knowledge area content listing.

     * Fetches knowledge areas based on user permissions, network settings, and filters.

     * Returns a JSON response suitable for a data table or list view.

     * {@inheritDoc}

     * @see \Laminas\Mvc\Controller\AbstractActionController::indexAction()

     */

    public function indexAction()

    {

        // Get current user and network information from plugins.

        $currentUserPlugin = $this->plugin('currentUserPlugin');

        $currentUser = $currentUserPlugin->getUser();

        $currentNetworkPlugin = $this->plugin('currentNetworkPlugin');

        $currentNetwork = $currentNetworkPlugin->getNetwork();

        $request = $this->getRequest();

        if ($request->isGet()) {

            // --- ACL Permissions ---

            // Determine user permissions for various knowledge area actions.

            $acl = $this->getEvent()->getViewModel()->getVariable('acl');

            $allowAdd       = $acl->isAllowed($currentUser->usertype_id, 'knowledge-area/add') ? 1 : 0;

            $allowEdit      = $acl->isAllowed($currentUser->usertype_id, 'knowledge-area/edit');

            $allowDelete    = $acl->isAllowed($currentUser->usertype_id, 'knowledge-area/delete');

            $allowView      = $acl->isAllowed($currentUser->usertype_id, 'knowledge-area/view');

            // --- Query Parameters ---

            // Retrieve and sanitize query parameters for filtering, searching, and pagination.

            $category_filter_id = Functions::sanitizeFilterString($this->params()->fromQuery('category_id'));

            $search             = Functions::sanitizeFilterString($this->params()->fromQuery('search'));

            $page               = intval($this->params()->fromQuery('start', 1), 10);

            $order_field        = 'added_on'; // Default order field

            $order_direction    = 'asc';      // Default order direction

            $records_x_page     = 12;         // Default records per page

            // --- Category Fetching and Processing ---

            // Initialize arrays to store category information.

            $category_with_edition_ids = [];   // IDs of categories the user can edit.

            $category_with_edition_uuids = []; // UUIDs of categories the user can edit (for response).

            $user_accessible_category_ids = []; // All category IDs accessible to the user directly.

            $categories = [];                  // Master array of category details (id => [uuid, name]).

            // Instantiate mappers.

            $knowledgeAreaCategoryMapper = KnowledgeAreaCategoryMapper::getInstance($this->adapter);

            $knowledgeAreaCategoryUserMapper = KnowledgeAreaCategoryUserMapper::getInstance($this->adapter);

            // 1. Fetch categories based on user's direct permissions (via KnowledgeAreaCategoryUser).

            $userCategoryRecords =  $knowledgeAreaCategoryUserMapper->fetchAllByUserId($currentUser->id);

            foreach ($userCategoryRecords as $record) {

                if ($record->role == KnowledgeAreaCategoryUser::ROLE_ADMINISTRATOR || $record->role == KnowledgeAreaCategoryUser::ROLE_USER) {

                    // User has admin or user role in this category, allowing edition.

                    array_push($category_with_edition_ids, $record->category_id);

                    // Fetch category details to get UUID for the response.

                    $categoryDetails = $knowledgeAreaCategoryMapper->fetchOne($record->category_id);

                    if($categoryDetails) {

                        array_push($category_with_edition_uuids, $categoryDetails->uuid);

                    }

                }

                array_push($user_accessible_category_ids, $record->category_id);

            }

            // 2. Fetch details for all directly accessible categories if any exist.

            if (!empty($user_accessible_category_ids)) {

                $detailedUserCategories =  $knowledgeAreaCategoryMapper->fetchAllByIds($user_accessible_category_ids);

                foreach ($detailedUserCategories as $record) {

                    if (!isset($categories[$record->id])) { // Add if not already present

                        $categories[$record->id] = [

                            'uuid' => $record->uuid,

                            'name' => $record->name,

                        ];

                    }

                }

            }

            // 3. Fetch all public categories within the current network.

            $publicCategories =  $knowledgeAreaCategoryMapper->fetchAllPublicByNetworkId($currentNetwork->id);

            foreach ($publicCategories as $record) {

                if (!isset($categories[$record->id])) { // Add if not already present (ensures no duplicates from user-specific list)

                    $categories[$record->id] = [

                        'uuid' => $record->uuid,

                        'name' => $record->name,

                    ];

                }

            }

            // Sort all collected categories alphabetically by name.

            uasort($categories, function ($a, $b) {

                return $a['name'] <=> $b['name'];

            });

            // --- Filtering by Category ---

            // If a specific category filter is applied, narrow down the category_ids to search in.

            $category_ids_to_filter = array_keys($categories); // Start with all accessible category IDs.

            if ($category_filter_id) {

                $categoryFilter = $knowledgeAreaCategoryMapper->fetchOneByUuid($category_filter_id);

                if ($categoryFilter && isset($categories[$categoryFilter->id])) { // Ensure filtered category is accessible

                    $category_ids_to_filter = [$categoryFilter->id];

                } else {

                    $category_ids_to_filter = []; // Filtered category not found or not accessible, show no results for this filter.

                }

            }

            // --- Content Fetching ---

            $storage = Storage::getInstance($this->config, $this->adapter);

            // $path is the base path for knowledge area, used by getGenericImage.

            $path = $storage->getPathKnowledgeArea();

            $knowledgeAreaContentMapper = KnowledgeAreaContentMapper::getInstance($this->adapter);

            // Fetch paginated knowledge area content based on accessible categories and search criteria.

            $paginator = $knowledgeAreaContentMapper->fetchAllDataTableByCategoryIds($category_ids_to_filter, $search, $page, $records_x_page, $order_field, $order_direction);

            // --- Response Item Construction ---

            $items = [];

            $contentRecords = $paginator->getCurrentItems();

            foreach ($contentRecords as $record) {

                // Ensure category details are available for the current content item.

                // This might happen if content somehow exists for a category not in the user's compiled list (e.g. stale data).

                if (!isset($categories[$record->category_id])) {

                    $category = $knowledgeAreaCategoryMapper->fetchOne($record->category_id);

                    if ($category) {

                        $categories[$category->id] = [

                            'uuid' =>  $category->uuid,

                            'name' =>  $category->name,

                        ];

                    } else {

                        // Fallback if category is still not found (should be rare).

                        $categories[$record->category_id] = ['uuid' => null, 'name' => 'Unknown Category'];

                    }

                }

                // Strip HTML tags and truncate description for display.

                $description = strip_tags($record->description);

                if (strlen($description) > 120) {

                    $description = substr($description, 0, 120) . '...';

                }

                // Construct the item for the JSON response.

                $item = [

                    // Use the KnowledgeAreaCategory's UUID for the image path.

                    'image' => $storage->getGenericImage($path, ($categories[$record->category_id]['uuid'] ?? null), $record->image),

                    'title' => $record->title,

                    'description' => $description,

                    'category' => $categories[$record->category_id]['name'],

                    'link_view' => $allowView ?  $this->url()->fromRoute('knowledge-area/view', ['id' => $record->uuid]) : '',

                ];

                // Add edit/delete links if user has permission for the content's category.

                if (in_array($record->category_id, $category_with_edition_ids)) {

                    $item['link_edit'] = $allowEdit ?  $this->url()->fromRoute('knowledge-area/edit', ['id' => $record->uuid]) : '';

                    $item['link_delete'] = $allowDelete ? $this->url()->fromRoute('knowledge-area/delete', ['id' => $record->uuid]) : '';

                }

                array_push($items, $item);

            }

            // --- JSON Response ---

            // Configured image size for frontend reference.

            $image_size = $this->config['leaderslinked.image_sizes.knowledge_area'];

            // Return all data in a JSON format.

            return new JsonModel([

                'success' => true,

                'data' => [

                    'items' => $items,                         // Paginated content items.

                    'total' => $paginator->getTotalItemCount(), // Total number of content items.

                    'page' => $paginator->getCurrentPageNumber(), // Current page number.

                    'total_pages' => $paginator->getPages()->pageCount, // Total number of pages.

                    'categories' => array_values($categories), // List of all accessible categories (re-indexed).

                    'categories_with_edition' => $category_with_edition_uuids, // UUIDs of categories user can edit.

                    'link_add' => $allowAdd ? $this->url()->fromRoute('knowledge-area/add') : '', // Link to add new content if allowed.

                    'image_size' => $image_size,             // Expected image dimensions.

                    'content_edit' => count($category_with_edition_ids) > 0, // Flag if user can edit any content.

                ]

            ]);

        } else {

            return new JsonModel([

                'success' => false,

                'data' => 'ERROR_METHOD_NOT_ALLOWED'

            ]);

        }

    }

    public function addAction()

    {

        $currentUserPlugin  = $this->plugin('currentUserPlugin');

        $currentUser        = $currentUserPlugin->getUser();

        $request            = $this->getRequest();

        if ($request->isPost()) {

            $category_with_edition_ids = [];

            $category_ids = [];

            $categories = [];

            $knowledgeAreaCategoryUserMapper = KnowledgeAreaCategoryUserMapper::getInstance($this->adapter);

            $records =  $knowledgeAreaCategoryUserMapper->fetchAllByUserId($currentUser->id);

            foreach ($records as $record) {

                if ($record->role == KnowledgeAreaCategoryUser::ROLE_ADMINISTRATOR || $record->role == KnowledgeAreaCategoryUser::ROLE_USER) {

                    array_push($category_with_edition_ids, $record->category_id);

                }

                array_push($category_ids, $record->category_id);

            }

            $knowledgeAreaCategoryMapper = KnowledgeAreaCategoryMapper::getInstance($this->adapter);

            if ($category_ids) {

                $records =  $knowledgeAreaCategoryMapper->fetchAllByIds($category_ids);

                foreach ($records as $record) {

                    if ($record->status == KnowledgeAreaCategory::STATUS_ACTIVE) {

                        $categories[$record->id] = [

                            'uuid' => $record->uuid,

                            'name' => $record->name,

                        ];

                    }

                }

            }

            $categories = array_values($categories);

            usort($categories, function ($a, $b) {

                return $a['name'] <=> $b['name'];

            });

            $dataPost = array_merge($request->getPost()->toArray(), $request->getFiles()->toArray());

            $form = new KnowledgeAreaCreateForm($this->adapter, $category_with_edition_ids);

            $form->setData($dataPost);

            if ($form->isValid()) {

                $dataPost = (array) $form->getData();

                $knowledgeAreaCategoryMapper = KnowledgeAreaCategoryMapper::getInstance($this->adapter);

                $knowledgeAreaCategory = $knowledgeAreaCategoryMapper->fetchOneByUuid($dataPost['category_id']);

                $knowledgeAreaContent = new KnowledgeAreaContent();

                $knowledgeAreaContent->network_id = $knowledgeAreaCategory->network_id;

                $knowledgeAreaContent->company_id = $knowledgeAreaCategory->company_id;

                $knowledgeAreaContent->category_id = $knowledgeAreaCategory->id;

                $knowledgeAreaContent->user_id = $currentUser->id;

                $knowledgeAreaContent->title = $dataPost['title'];

                $knowledgeAreaContent->description = $dataPost['description'];

                $knowledgeAreaContent->link = $dataPost['link'];

                $knowledgeAreaContentMapper = KnowledgeAreaContentMapper::getInstance($this->adapter);

                if ($knowledgeAreaContentMapper->insert($knowledgeAreaContent)) {

                    $knowledgeAreaContent = $knowledgeAreaContentMapper->fetchOne($knowledgeAreaContent->id);

                    // Se instancia la clase Storage para manejar el almacenamiento de archivos.

                    // La clase Image fue eliminada debido a que no se encontraba o estaba obsoleta.

                    $storage = Storage::getInstance($this->config, $this->adapter);

                    // Obtiene la ruta base para los archivos del área de conocimiento.

                    // $target_path = $storage->getPathKnowledgeArea(); // No longer needed directly here, composePathTo methods use storagePath internally

                    $files = $this->getRequest()->getFiles()->toArray();

                    // Manejo del archivo de imagen principal.

                    if (isset($files['image']) && empty($files['image']['error'])) {

                        $tmp_image_name  = $files['image']['tmp_name'];

                        $original_image_name_parts = explode('.',  $files['image']['name']);

                        // Genera un nombre de archivo único y normalizado, forzando la extensión .png.

                        $final_image_filename = Functions::normalizeString(uniqid() . '-' . $original_image_name_parts[0] . '.png');

                        // Obtener dimensiones para el redimensionamiento de la imagen del área de conocimiento.

                        list($target_width_str, $target_height_str) = explode('x', $this->config['leaderslinked.image_sizes.knowledge_area']);

                        $target_width = (int)$target_width_str;

                        $target_height = (int)$target_height_str;

                        $uuid_path_segment = $knowledgeAreaCategory->uuid;

                        // Construye la ruta completa del directorio de destino usando el UUID de la categoría.

                        $full_target_dir = $storage->composePathToDirectory(Storage::TYPE_KNOWLEDGE_AREA, $uuid_path_segment);

                        // Crea el directorio si no existe.

                        if (!is_dir($full_target_dir)) {

                            mkdir($full_target_dir, 0775, true);

                        }

                        // Construye la ruta completa del archivo de destino.

                        $full_target_path_for_image = $storage->composePathToFilename(Storage::TYPE_KNOWLEDGE_AREA, $uuid_path_segment, $final_image_filename);

                        // Sube y redimensiona la imagen usando el método de la clase Storage.

                        if ($storage->uploadImageResize($tmp_image_name, $full_target_path_for_image, $target_width, $target_height)) {

                            $knowledgeAreaContent->image = $final_image_filename; // Guarda solo el nombre del archivo.

                            $knowledgeAreaContentMapper->update($knowledgeAreaContent);

                        }

                    }

                    // Manejo del archivo adjunto.

                    if (isset($files['attachment']) && empty($files['attachment']['error'])) {

                        $tmp_attachment_name   = $files['attachment']['tmp_name'];

                        // Normaliza el nombre del archivo adjunto, manteniendo su extensión original.

                        $final_attachment_filename = Functions::normalizeString($files['attachment']['name']);

                        $uuid_path_segment = $knowledgeAreaCategory->uuid;

                        // Necesitamos la ruta base para los adjuntos si composePathToDirectory no se usa aquí directamente

                        $base_attachment_path = $storage->getPathKnowledgeArea();

                        $full_target_dir_for_attachment = $base_attachment_path . DIRECTORY_SEPARATOR . $uuid_path_segment;

                        if (!is_dir($full_target_dir_for_attachment)) {

                            mkdir($full_target_dir_for_attachment, 0775, true);

                        }

                        $full_target_path_for_attachment = $full_target_dir_for_attachment . DIRECTORY_SEPARATOR . $final_attachment_filename;

                        // Mueve el archivo adjunto subido a su ubicación final.

                        if ($storage->moveUploadedFile($tmp_attachment_name, $full_target_path_for_attachment)) {

                            $knowledgeAreaContent->attachment = $final_attachment_filename; // Guarda solo el nombre del archivo.

                            $knowledgeAreaContentMapper->update($knowledgeAreaContent);

                        }

                    }

                    $this->logger->info('Se agrego el contenido ' . $knowledgeAreaContent->title, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);

                    $data = [

                        'success'   => true,

                        'data'   => 'LABEL_RECORD_ADDED'

                    ];

                } else {

                    $data = [

                        'success'   => false,

                        'data'      => $knowledgeAreaContentMapper->getError()

                    ];

                }

                return new JsonModel($data);

            } else {

                $messages = [];

                $form_messages = (array) $form->getMessages();

                foreach ($form_messages  as $fieldname => $field_messages) {

                    $messages[$fieldname] = array_values($field_messages);

                }

                return new JsonModel([

                    'success'   => false,

                    'data'   => $messages

                ]);

            }

        } else {

            $data = [

                'success' => false,

                'data' => 'ERROR_METHOD_NOT_ALLOWED'

            ];

            return new JsonModel($data);

        }

        return new JsonModel($data);

    }

    public function deleteAction()

    {

        $currentUserPlugin = $this->plugin('currentUserPlugin');

        $currentUser    = $currentUserPlugin->getUser();

        $request    = $this->getRequest();

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

        $knowledgeAreaContentMapper = KnowledgeAreaContentMapper::getInstance($this->adapter);

        $knowledgeAreaContent = $knowledgeAreaContentMapper->fetchOneByUuid($id);

        if (!$knowledgeAreaContent) {

            return new JsonModel([

                'success'   => false,

                'data'   => 'ERROR_RECORD_NOT_FOUND'

            ]);

        }

        $knowledgeAreaCategoryUserMapper = KnowledgeAreaCategoryUserMapper::getInstance($this->adapter);

        $knowledgeAreaCategoryUser = $knowledgeAreaCategoryUserMapper->fetchOneByCategoryIdAndUserId($knowledgeAreaContent->category_id, $currentUser->id);

        $ok = false;

        if ($knowledgeAreaCategoryUser) {

            if ($knowledgeAreaCategoryUser->role == KnowledgeAreaCategoryUser::ROLE_EDITOR) {

                $ok = $knowledgeAreaContent->user_id == $currentUser->id;

            }

            if ($knowledgeAreaCategoryUser->role == KnowledgeAreaCategoryUser::ROLE_ADMINISTRATOR) {

                $ok = true;

            }

        }

        if (!$ok) {

            return new JsonModel([

                'success'   => false,

                'data'   => 'ERROR_KNOWLEDGE_AREA_YOU_DO_NOT_HAVE_PERMISSION'

            ]);

        }

        if ($request->isPost()) {

            $result =  $knowledgeAreaContentMapper->delete($knowledgeAreaContent);

            if ($result) {

                $this->logger->info('Se borro el cotenido : ' .  $knowledgeAreaContent->title, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);

                $storage = Storage::getInstance($this->config, $this->adapter);

                $target_path = $storage->getPathKnowledgeArea();

                if($knowledgeAreaContent->attachment) {

                    $storage->deleteFile($target_path, $knowledgeAreaContent->uuid, $knowledgeAreaContent->attachment);

                }

                if ($knowledgeAreaContent->image) {

                    $storage->deleteFile($target_path, $knowledgeAreaContent->uuid, $knowledgeAreaContent->image);

                }

                $data = [

                    'success' => true,

                    'data' => 'LABEL_RECORD_DELETED'

                ];

            } else {

                $data = [

                    'success'   => false,

                    'data'      => $knowledgeAreaContentMapper->getError()

                ];

                return new JsonModel($data);

            }

        } else {

            $data = [

                'success' => false,

                'data' => 'ERROR_METHOD_NOT_ALLOWED'

            ];

            return new JsonModel($data);

        }

        return new JsonModel($data);

    }

    public function editAction()

    {

        $currentUserPlugin = $this->plugin('currentUserPlugin');

        $currentUser    = $currentUserPlugin->getUser();

        $request    = $this->getRequest();

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

        $knowledgeAreaContentMapper = KnowledgeAreaContentMapper::getInstance($this->adapter);

        $knowledgeAreaContent = $knowledgeAreaContentMapper->fetchOneByUuid($id);

        if (!$knowledgeAreaContent) {

            return new JsonModel([

                'success'   => false,

                'data'   => 'ERROR_RECORD_NOT_FOUND'

            ]);

        }

        $knowledgeAreaCategoryUserMapper = KnowledgeAreaCategoryUserMapper::getInstance($this->adapter);

        $knowledgeAreaCategoryUser = $knowledgeAreaCategoryUserMapper->fetchOneByCategoryIdAndUserId($knowledgeAreaContent->category_id, $currentUser->id);

        $ok = false;

        if ($knowledgeAreaCategoryUser) {

            if ($knowledgeAreaCategoryUser->role == KnowledgeAreaCategoryUser::ROLE_EDITOR) {

                $ok = $knowledgeAreaContent->user_id == $currentUser->id;

            }

            if ($knowledgeAreaCategoryUser->role == KnowledgeAreaCategoryUser::ROLE_ADMINISTRATOR) {

                $ok = true;

            }

        }

        if (!$ok) {

            return new JsonModel([

                'success'   => false,

                'data'   => 'ERROR_KNOWLEDGE_AREA_YOU_DO_NOT_HAVE_PERMISSION'

            ]);

        }

        if ($request->isGet()) {

            $knowledgeAreaCategoryMapper = KnowledgeAreaCategoryMapper::getInstance($this->adapter);

            $knowledgeAreaCategory = $knowledgeAreaCategoryMapper->fetchOne($knowledgeAreaContent->category_id);

            $data = [

                'success' => true,

                'data' => [

                    'category_id' => $knowledgeAreaCategory->uuid,

                    'title' => $knowledgeAreaContent->title,

                    'description' => $knowledgeAreaContent->description,

                    'link' => $knowledgeAreaContent->link,

                ]

            ];

            return new JsonModel($data);

        } else if ($request->isPost()) {

            $category_with_edition_ids = [];

            $category_ids = [];

            $categories = [];

            $knowledgeAreaCategoryUserMapper = KnowledgeAreaCategoryUserMapper::getInstance($this->adapter);

            $records =  $knowledgeAreaCategoryUserMapper->fetchAllByUserId($currentUser->id);

            foreach ($records as $record) {

                if ($record->role == KnowledgeAreaCategoryUser::ROLE_ADMINISTRATOR || $record->role == KnowledgeAreaCategoryUser::ROLE_USER) {

                    array_push($category_with_edition_ids, $record->category_id);

                }

                array_push($category_ids, $record->category_id);

            }

            $knowledgeAreaCategoryMapper = KnowledgeAreaCategoryMapper::getInstance($this->adapter);

            if ($category_ids) {

                $records =  $knowledgeAreaCategoryMapper->fetchAllByIds($category_ids);

                foreach ($records as $record) {

                    if ($record->status == KnowledgeAreaCategory::STATUS_ACTIVE) {

                        $categories[$record->id] = [

                            'uuid' => $record->uuid,

                            'name' => $record->name,

                        ];

                    }

                }

            }

            $categories = array_values($categories);

            usort($categories, function ($a, $b) {

                return $a['name'] <=> $b['name'];

            });

            $dataPost = array_merge($request->getPost()->toArray(), $request->getFiles()->toArray());

            $form = new KnowledgeAreaEditForm($this->adapter, $category_with_edition_ids);

            $form->setData($dataPost);

            if ($form->isValid()) {

                $dataPost = (array) $form->getData();

                $knowledgeAreaCategoryMapper = KnowledgeAreaCategoryMapper::getInstance($this->adapter);

                $knowledgeAreaCategory = $knowledgeAreaCategoryMapper->fetchOneByUuid($dataPost['category_id']);

                $knowledgeAreaContent->category_id = $knowledgeAreaCategory->id;

                $knowledgeAreaContent->title = $dataPost['title'];

                $knowledgeAreaContent->description = $dataPost['description'];

                if ($knowledgeAreaContentMapper->update($knowledgeAreaContent)) {

                    // Se instancia la clase Storage para manejar el almacenamiento de archivos.

                    $storage = Storage::getInstance($this->config, $this->adapter);

                    // Obtiene la ruta base para los archivos del área de conocimiento.

                    // $target_path = $storage->getPathKnowledgeArea(); // No longer needed directly here, composePathTo methods use storagePath internally

                    $files = $this->getRequest()->getFiles()->toArray();

                    // Manejo de la actualización de la imagen principal.

                    if (isset($files['image']) && empty($files['image']['error'])) {

                        // Si existe una imagen previa, se elimina.

                        if ($knowledgeAreaContent->image) {

                            $storage->deleteFile($target_path, $knowledgeAreaContent->uuid, $knowledgeAreaContent->image);

                        }

                        $tmp_image_name  = $files['image']['tmp_name'];

                        $original_image_name_parts = explode('.',  $files['image']['name']);

                        // Genera un nombre de archivo único y normalizado para la nueva imagen, forzando .png.

                        $final_image_filename = Functions::normalizeString(uniqid() . '-' . $original_image_name_parts[0] . '.png');

                        // Obtener dimensiones para el redimensionamiento de la imagen del área de conocimiento.

                        list($target_width_str, $target_height_str) = explode('x', $this->config['leaderslinked.image_sizes.knowledge_area']);

                        $target_width = (int)$target_width_str;

                        $target_height = (int)$target_height_str;

                        $uuid_path_segment = $knowledgeAreaCategory->uuid;

                        // Construye la ruta completa del directorio de destino.

                        $full_target_dir = $storage->composePathToDirectory(Storage::TYPE_KNOWLEDGE_AREA, $uuid_path_segment);

                        // Crea el directorio si no existe.

                        if (!is_dir($full_target_dir)) {

                            mkdir($full_target_dir, 0775, true);

                        }

                        $full_target_path_for_image = $storage->composePathToFilename(Storage::TYPE_KNOWLEDGE_AREA, $uuid_path_segment, $final_image_filename);

                        // Sube y redimensiona la imagen.

                        if ($storage->uploadImageResize($tmp_image_name, $full_target_path_for_image, $target_width, $target_height)) {

                            $knowledgeAreaContent->image = $final_image_filename;

                            $knowledgeAreaContentMapper->update($knowledgeAreaContent);

                        }

                    }

                    // Manejo de la actualización del archivo adjunto.

                    if (isset($files['attachment']) && empty($files['attachment']['error'])) {

                        $tmp_attachment_name   = $files['attachment']['tmp_name'];

                        // Normaliza el nombre del nuevo archivo adjunto.

                        $final_attachment_filename = Functions::normalizeString($files['attachment']['name']);

                        // Si existe un adjunto previo, se elimina.

                        if ($knowledgeAreaContent->attachment) {

                            $storage->deleteFile($target_path, $knowledgeAreaContent->uuid, $knowledgeAreaContent->attachment);

                        }

                        // Construye la ruta completa del directorio de destino para el adjunto.

                        $uuid_path_segment = $knowledgeAreaCategory->uuid; // Similar al comentario de la imagen.

                        $full_target_dir_for_attachment = $target_path . DIRECTORY_SEPARATOR . $uuid_path_segment;

                        if (!is_dir($full_target_dir_for_attachment)) {

                            mkdir($full_target_dir_for_attachment, 0775, true);

                        }

                        $full_target_path_for_attachment = $full_target_dir_for_attachment . DIRECTORY_SEPARATOR . $final_attachment_filename;

                        // Mueve el nuevo archivo adjunto a su ubicación final.

                        if ($storage->moveUploadedFile($tmp_attachment_name, $full_target_path_for_attachment)) {

                            $knowledgeAreaContent->attachment = $final_attachment_filename;

                            $knowledgeAreaContentMapper->update($knowledgeAreaContent);

                        }

                    }

                    $this->logger->info('Se edito el contenido ' . $knowledgeAreaContent->title, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);

                    $data = [

                        'success'   => true,

                        'data'   => 'LABEL_RECORD_UPDATED'

                    ];

                } else {

                    $data = [

                        'success'   => false,

                        'data'      => $knowledgeAreaContentMapper->getError()

                    ];

                }

                return new JsonModel($data);

            } else {

                $messages = [];

                $form_messages = (array) $form->getMessages();

                foreach ($form_messages  as $fieldname => $field_messages) {

                    $messages[$fieldname] = array_values($field_messages);

                }

                return new JsonModel([

                    'success'   => false,

                    'data'   => $messages

                ]);

            }

        } else {

            $data = [

                'success' => false,

                'data' => 'ERROR_METHOD_NOT_ALLOWED'

            ];

            return new JsonModel($data);

        }

        return new JsonModel($data);

    }

    public function viewAction()

    {

        $currentUserPlugin = $this->plugin('currentUserPlugin');

        $currentUser    = $currentUserPlugin->getUser();

        $request    = $this->getRequest();

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

        $knowledgeAreaContentMapper = KnowledgeAreaContentMapper::getInstance($this->adapter);

        $knowledgeAreaContent = $knowledgeAreaContentMapper->fetchOneByUuid($id);

        if (!$knowledgeAreaContent) {

            return new JsonModel([

                'success'   => false,

                'data'   => 'ERROR_RECORD_NOT_FOUND'

            ]);

        }

        $request = $this->getRequest();

        if ($request->isGet()) {

            $knowledgeAreaCategoryMapper = KnowledgeAreaCategoryMapper::getInstance($this->adapter);

            $knowledgeAreaCategory = $knowledgeAreaCategoryMapper->fetchOne($knowledgeAreaContent->category_id);

            $ok = false;

            if ($knowledgeAreaCategory->privacy == KnowledgeAreaCategory::PRIVACY_COMPANY) {

                $knowledgeAreaCategoryUserMapper = KnowledgeAreaCategoryUserMapper::getInstance($this->adapter);

                $knowledgeAreaCategoryUser = $knowledgeAreaCategoryUserMapper->fetchOneByCategoryIdAndUserId($knowledgeAreaContent->category_id, $currentUser->id);

                if ($knowledgeAreaCategoryUser) {

                    $ok = true;

                }

            }

            if ($knowledgeAreaCategory->privacy == KnowledgeAreaCategory::PRIVACY_PUBLIC) {

                $ok = true;

            }

            if (!$ok) {

                return new JsonModel([

                    'success'   => false,

                    'data'   => 'ERROR_KNOWLEDGE_AREA_YOU_DO_NOT_HAVE_PERMISSION'

                ]);

            }

            $contentReactionMapper = ContentReactionMapper::getInstance($this->adapter);

            $contentReaction = $contentReactionMapper->fetchOneByKnowledgeAreaIdAndUserId($knowledgeAreaContent->id, $currentUser->id);

            $storage = Storage::getInstance($this->config, $this->adapter);

            $path = $storage->getPathKnowledgeArea();

                return new JsonModel([

                    'success' => true,

                    'data' => [

                        'category' => $knowledgeAreaCategory->name,

                        'title' => $knowledgeAreaContent->title,

                        'description' => $knowledgeAreaContent->description,

                        'link' => $knowledgeAreaContent->link,

                        'image' =>  $storage->getGenericImage($path, $knowledgeAreaContent->uuid,  $knowledgeAreaContent->image),

                        'attachment' =>  $knowledgeAreaContent->attachment ? $storage->getGenericFile($path, $knowledgeAreaContent->uuid,  $knowledgeAreaContent->attachment) : '',

                        'reaction' => $contentReaction ? $contentReaction->reaction : '',

                        'routeComments' => $this->url()->fromRoute('knowledge-area/comments', ['id' => $knowledgeAreaContent->uuid],['force_canonical' => true]),

                        'routeCommentAdd' => $this->url()->fromRoute('knowledge-area/comments/add', ['id' => $knowledgeAreaContent->uuid],['force_canonical' => true]),

                        'routeSaveReaction' => $this->url()->fromRoute('knowledge-area/save-reaction', ['id' => $knowledgeAreaContent->uuid],['force_canonical' => true]),

                        'routeDeleteReaction' => $this->url()->fromRoute('knowledge-area/delete-reaction', ['id' => $knowledgeAreaContent->uuid],['force_canonical' => true]),

                        'routeReactions' => $this->url()->fromRoute('knowledge-area/reactions', ['id' => $knowledgeAreaContent->uuid],['force_canonical' => true]),

                    ]

                ]);

        } else {

            $data = [

                'success' => false,

                'data' => 'ERROR_METHOD_NOT_ALLOWED'

            ];

            return new JsonModel($data);

        }

        return new JsonModel($data);

    }

    public function reactionsAction()

    {

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

        $request = $this->getRequest();

        $request = $this->getRequest();

        if ($request->isGet()) {

            $currentUserPlugin = $this->plugin('currentUserPlugin');

            $currentUser = $currentUserPlugin->getUser();

            $knowledgeAreaContentMapper = KnowledgeAreaContentMapper::getInstance($this->adapter);

            $knowledgeAreaContent = $knowledgeAreaContentMapper->fetchOneByUuid($id);

            if (!$knowledgeAreaContent || $knowledgeAreaContent->network_id != $currentUser->network_id) {

                return new JsonModel([

                    'success'   => false,

                    'data'   => 'ERROR_RECORD_NOT_FOUND'

                ]);

            }

            $userMapper = UserMapper::getInstance($this->adapter);

            $items = [];

            $storage = Storage::getInstance($this->config, $this->adapter);

            $path = $storage->getPathKnowledgeArea();

            $contentReactionMapper = ContentReactionMapper::getInstance($this->adapter);

            $records = $contentReactionMapper->fetchAllByKnowledgeAreaId($knowledgeAreaContent->id);

            foreach($records as $record)

            {

                $user = $userMapper->fetchOne($record->user_id);

                if($user && $user->status == User::STATUS_ACTIVE) {

                    array_push($items, [

                        'first_name' => $user->first_name,

                        'last_name' => $user->last_name,

                        'email' => $user->email,

                        'image' => $storage->getGenericImage($path, $user->uuid, $user->image),

                        'reaction' => $record->reaction,

                    ]);

                }

            }

            $response = [

                'success' => true,

                'data' => $items

            ];

            return new JsonModel($response);

        } else {

            $response = [

                'success' => false,

                'data' => 'ERROR_METHOD_NOT_ALLOWED'

            ];

            return new JsonModel($response);

        }

    }

    public function addCommentAction()

    {

        $currentUserPlugin = $this->plugin('currentUserPlugin');

        $currentUser    = $currentUserPlugin->getUser();

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

        $request = $this->getRequest();

        if ($request->isPost()) {

            $knowledgeAreaContentMapper = KnowledgeAreaContentMapper::getInstance($this->adapter);

            $knowledgeAreaContent = $knowledgeAreaContentMapper->fetchOneByUuid($id);

            if (!$knowledgeAreaContent || $knowledgeAreaContent->network_id != $currentUser->network_id) {

                return new JsonModel([

                    'success'   => false,

                    'data'   => 'ERROR_RECORD_NOT_FOUND'

                ]);

            }

            $dataPost = $request->getPost()->toArray();

            $form = new CommentForm();

            $form->setData($dataPost);

            if ($form->isValid()) {

                $dataPost = (array) $form->getData();

                $comment = new Comment();

                $comment->network_id = $currentUser->network_id;

                $comment->comment = $dataPost['comment'];

                $comment->user_id = $currentUser->id;

                $comment->knowledge_area_id = $knowledgeAreaContent->id;

                $comment->relational = Comment::RELATIONAL_KNOWLEDGE_AREA;

                $commentMapper = CommentMapper::getInstance($this->adapter);

                $now = $commentMapper->getDatebaseNow();

                if ($commentMapper->insert($comment)) {

                    $total_comments = $commentMapper->fetchCountCommentByKnowledgeAreaId($comment->knowledge_area_id);

                    $knowledgeAreaContent->total_comments = $total_comments;

                    $knowledgeAreaContentMapper->update($knowledgeAreaContent);

                    $response = [

                        'success'   => true,

                        'data'   => $this->renderComment($comment->id, $now),

                        'total_comments' => $total_comments

                    ];

                    return new JsonModel($response);

                } else {

                    $response = [

                        'success'   => false,

                        'data'   => $commentMapper->getError()

                    ];

                    return new JsonModel($response);

                }

            } else {

                $message = '';;

                $form_messages = (array) $form->getMessages();

                foreach ($form_messages  as $fieldname => $field_messages) {

                    foreach ($field_messages as $key => $value) {

                        $message = $value;

                    }

                }

                $response = [

                    'success'   => false,