WebSVN – LeadersLinked - Services – Diff – /module/LeadersLinked/src/Controller/MyProfilesController.php

     /**
+     *
      * @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
      * {@inheritDoc}
      * @see \Laminas\Mvc\Controller\AbstractActionController::indexAction()
      */
     public function indexAction()
+    {
+        // Obtener el usuario actual del sistema
         $currentUserPlugin = $this->plugin('currentUserPlugin');
         $currentUser = $currentUserPlugin->getUser();
         // Obtener la petición HTTP
         $request = $this->getRequest();
+        if ($request->isGet()) {
+            // Sanitizar el parámetro de búsqueda si existe
-        if ($request->isGet()) {
+            $search = Functions::sanitizeFilterString($this->params()->fromQuery('search'));
-                $search = Functions::sanitizeFilterString($this->params()->fromQuery('search'));
+            // Obtener el control de acceso (ACL) para verificar permisos
+            $acl = $this->getEvent()->getViewModel()->getVariable('acl');
-                $acl = $this->getEvent()->getViewModel()->getVariable('acl');
+            // Verificar permisos para diferentes acciones
-                $allowView = $acl->isAllowed($currentUser->usertype_id, 'profile/view');
+            $allowView = $acl->isAllowed($currentUser->usertype_id, 'profile/view');
-                $allowEdit = $acl->isAllowed($currentUser->usertype_id, 'profile/my-profiles/edit');
-                $allowDelete = $acl->isAllowed($currentUser->usertype_id, 'profile/my-profiles/delete');
+            $allowEdit = $acl->isAllowed($currentUser->usertype_id, 'profile/my-profiles/edit');
-                $storage = Storage::getInstance($this->config, $this->adapter);
+            $allowDelete = $acl->isAllowed($currentUser->usertype_id, 'profile/my-profiles/delete');
-                $userProfileMapper = UserProfileMapper::getInstance($this->adapter);
-                $records  = $userProfileMapper->fetchAllByUserIdAndSearch($currentUser->id, $search);
-                $items = [];
-                foreach ($records as $record) {
+            // Inicializar el sistema de almacenamiento para manejar imágenes
-                    $item = [
+            $storage = Storage::getInstance($this->config, $this->adapter);
-                        'id' => $record->id,
-                        'name' => $record->name,
-                        'image' => $storage->getUserProfileImage($currentUser, $record),
-                        'link_view' => $allowView ? $this->url()->fromRoute('profile/view', ['id' => $record->uuid])  : '',
-                        'link_edit' => $allowEdit ? $this->url()->fromRoute('profile/my-profiles/edit', ['id' => $record->uuid])  : '',
-                        'link_delete' => $allowDelete && $record->public == UserProfile::PUBLIC_NO ? $this->url()->fromRoute('profile/my-profiles/delete', ['id' => $record->uuid]) : '',
+            // Obtener el mapper de perfiles de usuario
+            $userProfileMapper = UserProfileMapper::getInstance($this->adapter);
+            // Obtener todos los perfiles del usuario actual, opcionalmente filtrados por búsqueda
+            $records  = $userProfileMapper->fetchAllByUserIdAndSearch($currentUser->id, $search);
+            // Preparar el array de items para la respuesta
+            $items = [];
+            foreach ($records as $record) {
+                // Construir cada item con la información del perfil
+                $item = [
+                    'id' => $record->id,
+                    'name' => $record->name,
+                    'image' => $storage->getUserProfileImage($currentUser, $record),
+                    'link_view' => $allowView ? $this->url()->fromRoute('profile/view', ['id' => $record->uuid])  : '',
+                    'link_edit' => $allowEdit ? $this->url()->fromRoute('profile/my-profiles/edit', ['id' => $record->uuid])  : '',
-                    ];
+                    'link_delete' => $allowDelete && $record->public == UserProfile::PUBLIC_NO ? $this->url()->fromRoute('profile/my-profiles/delete', ['id' => $record->uuid]) : '',
+                ];
-                    array_push($items, $item);
-                }
+                array_push($items, $item);
+            }
+            // Preparar la respuesta exitosa con los items
-                $response = [
+            $response = [
-                    'success' => true,
+                'success' => true,
-                    'data' => $items
+                'data' => $items
-                ];
+            ];
+        }
         $userProfileMapper = UserProfileMapper::getInstance($this->adapter);
         $userProfile = $userProfileMapper->fetchOneByUuid($id);
         if (!$userProfile) {
-             // Use helper for consistency
+            // Use helper for consistency
             return $this->_createSimpleErrorResponse('ERROR_RECORD_NOT_FOUND');
+        }
         // Authorize: Check if current user owns the profile
         if ($currentUser->id != $userProfile->user_id) {
-             // Use helper for consistency
+            // Use helper for consistency
             return $this->_createSimpleErrorResponse('ERROR_UNAUTHORIZED');
+        }
+                }
+            }
             $cover_deleted = true;
             if ($userProfile->cover) {
                 $cover_deleted = $storage->deleteFile($target_path, $user_uuid, $userProfile->cover);
-                 if (!$cover_deleted) {
+                if (!$cover_deleted) {
                     $this->logger->err("Failed to delete profile cover file: {$target_path}/{$user_uuid}/{$userProfile->cover}", ['user_id' => $userProfile->user_id]);
                     // Decide if this is a critical error. Proceeding with DB deletion for now.
+                }
+            }
         // Return JsonModel for all paths
         return $data instanceof JsonModel ? $data : new JsonModel($data);
+    }
     /**
+     * Presenta el perfil con las opciones de edición de cada sección.
+     * Este método:
+     * - Obtiene y valida el perfil del usuario
+     * - Recopila toda la información relacionada (educación, experiencia, habilidades, etc.)
+     * - Prepara los datos para la vista de edición
+     * - Genera las URLs necesarias para las diferentes acciones de edición
      * Presenta el perfil con las opciónes de edición de cada sección
      * @return \Laminas\Http\Response|\Laminas\View\Model\ViewModel|\Laminas\View\Model\JsonModel
      */
     public function editAction()
+    {
         // Obtener el usuario actual del sistema
         $currentUserPlugin = $this->plugin('currentUserPlugin');
+        $currentUser = $currentUserPlugin->getUser();
         $currentUser = $currentUserPlugin->getUser();
+        // Obtener el plugin para mensajes flash
         $flashMessenger = $this->plugin('FlashMessenger');
+        // Obtener parámetros de la petición
         $request = $this->getRequest();
         $id = $this->params()->fromRoute('id');
         // Validar que se proporcionó un ID
-        if (!$id) {
-            $flashMessenger->addErrorMessage('ERROR_INVALID_PARAMETER');
+        if (!$id) {
-            return $this->redirect()->toRoute('dashboard');
+            $flashMessenger->addErrorMessage('ERROR_INVALID_PARAMETER');
             return $this->redirect()->toRoute('dashboard');
+        }
         // Obtener el perfil de usuario correspondiente
         $userProfileMapper = UserProfileMapper::getInstance($this->adapter);
-        $userProfileMapper = UserProfileMapper::getInstance($this->adapter);
+        $userProfile = $userProfileMapper->fetchOneByUuid($id);
-        $userProfile = $userProfileMapper->fetchOneByUuid($id);
+        // Validar que el perfil existe
         if (!$userProfile) {
-        if (!$userProfile) {
+            $flashMessenger->addErrorMessage('ERROR_RECORD_NOT_FOUND');
-            $flashMessenger->addErrorMessage('ERROR_RECORD_NOT_FOUND');
+            return $this->redirect()->toRoute('dashboard');
-            return $this->redirect()->toRoute('dashboard');
+        }
         // Verificar que el usuario actual es el propietario del perfil
         if ($currentUser->id != $userProfile->user_id) {
             $flashMessenger->addErrorMessage('ERROR_UNAUTHORIZED');
             return $this->redirect()->toRoute('dashboard');
+        }
         // Determinar la clave de API de Google Maps según el entorno
+        $sandbox = $this->config['leaderslinked.runmode.sandbox'];
-        $sandbox = $this->config['leaderslinked.runmode.sandbox'];
+        if ($sandbox) {
-        if ($sandbox) {
+            $google_map_key  = $this->config['leaderslinked.google_map.sandbox_api_key'];
-            $google_map_key  = $this->config['leaderslinked.google_map.sandbox_api_key'];
+        } else {
-        } else {
+            $google_map_key  = $this->config['leaderslinked.google_map.production_api_key'];
             } else {
                 $formattedAddress = '';
                 $country = '';
+            }
             // Obtener información del usuario
             $userMapper = UserMapper::getInstance($this->adapter);
+            $user = $userMapper->fetchOne($userProfile->user_id);
             $user = $userMapper->fetchOne($userProfile->user_id);
             // Obtener idiomas del usuario
             $userLanguages = [];
             $languageMapper = LanguageMapper::getInstance($this->adapter);
             $userLanguageMapper = UserLanguageMapper::getInstance($this->adapter);
             $records = $userLanguageMapper->fetchAllByUserProfileId($userProfile->id);
             foreach ($records as $record) {
                 $language = $languageMapper->fetchOne($record->language_id);
-                $userLanguages[$language->id] = $language->name;
+                $userLanguages[$language->id] = $language->name;
+            }
             // Obtener educación del usuario
             $locationMapper = LocationMapper::getInstance($this->adapter);
-            $degreeMapper = DegreeMapper::getInstance($this->adapter);
-            $userEducationMapper = UserEducationMapper::getInstance($this->adapter);
+            $degreeMapper = DegreeMapper::getInstance($this->adapter);
-            $userEducations = $userEducationMapper->fetchAllByUserProfileId($userProfile->id);
+            $userEducationMapper = UserEducationMapper::getInstance($this->adapter);
             $userEducations = $userEducationMapper->fetchAllByUserProfileId($userProfile->id);
             // Formatear información de educación
                     'link_edit' => $this->url()->fromRoute('profile/my-profiles/education', ['id' => $userProfile->uuid, 'operation' => 'edit', 'user_education_id' => $userEducation->uuid]),
                     'link_delete' => $this->url()->fromRoute('profile/my-profiles/education', ['id' => $userProfile->uuid, 'operation' => 'delete', 'user_education_id' => $userEducation->uuid]),
                 ];
+            }
             // Obtener experiencia laboral del usuario
             $industryMapper = IndustryMapper::getInstance($this->adapter);
-            $companySizeMapper = CompanySizeMapper::getInstance($this->adapter);
             $companySizeMapper = CompanySizeMapper::getInstance($this->adapter);
             $userExperienceMapper = UserExperienceMapper::getInstance($this->adapter);
+            $userExperiences = $userExperienceMapper->fetchAllByUserProfileId($userProfile->id);
             $userExperiences = $userExperienceMapper->fetchAllByUserProfileId($userProfile->id);
             // Formatear información de experiencia laboral
             foreach ($userExperiences  as &$userExperience) {
                 $location = $locationMapper->fetchOne($userExperience->location_id);
                     'link_edit' => $this->url()->fromRoute('profile/my-profiles/experience', ['id' => $userProfile->uuid, 'operation' => 'edit', 'user_experience_id' => $userExperience->uuid]),
                     'link_delete' => $this->url()->fromRoute('profile/my-profiles/experience', ['id' => $userProfile->uuid, 'operation' => 'delete', 'user_experience_id' => $userExperience->uuid])
                 ];
+            }
             // Obtener aptitudes del usuario
             $userAptitudes = [];
             $aptitudeMapper = AptitudeMapper::getInstance($this->adapter);
             $userAptitudeMapper = UserAptitudeMapper::getInstance($this->adapter);
             $records  = $userAptitudeMapper->fetchAllByUserProfileId($userProfile->id);
                 if ($aptitude) {
                     $userAptitudes[$aptitude->uuid] = $aptitude->name;
+                }
+            }
             // Obtener hobbies e intereses del usuario
             $userHobbiesAndInterests = [];
             $hobbyAndInterestMapper = HobbyAndInterestMapper::getInstance($this->adapter);
             $userHobbyAndInterestMapper = UserHobbyAndInterestMapper::getInstance($this->adapter);
             $records  = $userHobbyAndInterestMapper->fetchAllByUserProfileId($userProfile->id);
                 if ($hobbyAndInterest) {
                     $userHobbiesAndInterests[$hobbyAndInterest->uuid] = $hobbyAndInterest->name;
+                }
+            }
             // Obtener habilidades del usuario
             $userSkills = [];
             $userSkillMapper = UserSkillMapper::getInstance($this->adapter);
             $skillMapper = SkillMapper::getInstance($this->adapter);
             $records  = $userSkillMapper->fetchAllByUserProfileId($userProfile->id);
             foreach ($records as $record) {
                 $skill = $skillMapper->fetchOne($record->skill_id);
                 $userSkills[$skill->uuid] = $skill->name;
-            }
+            }
             // Obtener estadísticas de conexiones
             $companyFollowerMapper = CompanyFollowerMapper::getInstance($this->adapter);
             $following = $companyFollowerMapper->getCountFollowing($user->id);
             $connectionMapper = ConnectionMapper::getInstance($this->adapter);
             $follower = $connectionMapper->fetchTotalConnectionByUser($user->id);
             // Obtener configuraciones de tamaño de imágenes
+            $image_size_cover = $this->config['leaderslinked.image_sizes.user_cover_upload'];
+            $image_size_profile = $this->config['leaderslinked.image_sizes.user_upload'];
-            $image_size_cover = $this->config['leaderslinked.image_sizes.user_cover_upload'];
-            $image_size_profile = $this->config['leaderslinked.image_sizes.user_upload'];
+            // Inicializar el sistema de almacenamiento
+            $storage = Storage::getInstance($this->config, $this->adapter);
-            $storage = Storage::getInstance($this->config, $this->adapter);
+            // Preparar datos para la respuesta
-                $data = [
+            $data = [
-                    'following'         => $following,
+                'following'         => $following,
-                    'follower'          => $follower,
+                'follower'          => $follower,
-                    'user_id'           => $user->id,
+                'user_id'           => $user->id,
-                    'user_uuid'         => $user->uuid,
+                'user_uuid'         => $user->uuid,
-                    'full_name'         => trim($user->first_name . ' ' . $user->last_name),
+                'full_name'         => trim($user->first_name . ' ' . $user->last_name),
-                    'user_profile_id'   => $userProfile->id,
+                'user_profile_id'   => $userProfile->id,
-                    'user_profile_uuid' => $userProfile->uuid,
+                'user_profile_uuid' => $userProfile->uuid,
-                    'image'             => $storage->getUserProfileImage($currentUser, $userProfile),
+                'image'             => $storage->getUserProfileImage($currentUser, $userProfile),
-                    'cover'             => $storage->getUserProfileCover($currentUser, $userProfile),
+                'cover'             => $storage->getUserProfileCover($currentUser, $userProfile),
-                    'overview'          => $userProfile->description,
+                'overview'          => $userProfile->description,
-                    'facebook'          => $userProfile->facebook,
+                'facebook'          => $userProfile->facebook,
-                    'instagram'         => $userProfile->instagram,
+                'instagram'         => $userProfile->instagram,
-                    'twitter'           => $userProfile->twitter,
+                'twitter'           => $userProfile->twitter,
-                    'formatted_address' => $formattedAddress,
+                'formatted_address' => $formattedAddress,
-                    'country'           => $country,
+                'country'           => $country,
-                    'user_skills'       => $userSkills,
+                'user_skills'       => $userSkills,
-                    'user_languages'    => $userLanguages,
+                'user_languages'    => $userLanguages,
-                    'user_educations'   => $userEducations,
+                'user_educations'   => $userEducations,
+                'user_experiences'  => $userExperiences,
-                    'user_experiences'  => $userExperiences,
+                'user_aptitudes'                => $userAptitudes,
-                    'user_aptitudes'                => $userAptitudes,
+                'user_hobbies_and_interests'    => $userHobbiesAndInterests,
-                    'user_hobbies_and_interests'    => $userHobbiesAndInterests,
+                'image_size_cover' =>  $image_size_cover,
-                    'image_size_cover' =>  $image_size_cover,
+                'image_size_profile' => $image_size_profile,
-                    'image_size_profile' => $image_size_profile,
+                // Generar URLs para las diferentes acciones de edición
-                    'link_extended' => $this->url()->fromRoute('profile/my-profiles/extended', ['id' => $userProfile->uuid] ),
+                'link_extended' => $this->url()->fromRoute('profile/my-profiles/extended', ['id' => $userProfile->uuid]),
-                    'link_image_upload' => $this->url()->fromRoute('profile/my-profiles/image', ['id' => $userProfile->uuid, 'operation' => 'upload']),
+                'link_image_upload' => $this->url()->fromRoute('profile/my-profiles/image', ['id' => $userProfile->uuid, 'operation' => 'upload']),
-                    'link_image_delete' => $this->url()->fromRoute('profile/my-profiles/image', ['id' => $userProfile->uuid, 'operation' => 'delete']),
+                'link_image_delete' => $this->url()->fromRoute('profile/my-profiles/image', ['id' => $userProfile->uuid, 'operation' => 'delete']),
-                    'link_cover_upload' => $this->url()->fromRoute('profile/my-profiles/cover', ['id' => $userProfile->uuid, 'operation' => 'upload']),
+                'link_cover_upload' => $this->url()->fromRoute('profile/my-profiles/cover', ['id' => $userProfile->uuid, 'operation' => 'upload']),
-                    'link_cover_delete' => $this->url()->fromRoute('profile/my-profiles/cover', ['id' => $userProfile->uuid, 'operation' => 'delete']),
+                'link_cover_delete' => $this->url()->fromRoute('profile/my-profiles/cover', ['id' => $userProfile->uuid, 'operation' => 'delete']),
-                    'link_experience_add' => $this->url()->fromRoute('profile/my-profiles/experience', ['id' => $userProfile->uuid, 'operation' => 'add']),
+                'link_experience_add' => $this->url()->fromRoute('profile/my-profiles/experience', ['id' => $userProfile->uuid, 'operation' => 'add']),
-                    'link_education_add' => $this->url()->fromRoute('profile/my-profiles/education', ['id' => $userProfile->uuid, 'operation' => 'add']),
+                'link_education_add' => $this->url()->fromRoute('profile/my-profiles/education', ['id' => $userProfile->uuid, 'operation' => 'add']),
-                    'link_language' => $this->url()->fromRoute('profile/my-profiles/language', ['id' => $userProfile->uuid]),
-                    'link_location' => $this->url()->fromRoute('profile/my-profiles/location', ['id' => $userProfile->uuid]),
+                'link_language' => $this->url()->fromRoute('profile/my-profiles/language', ['id' => $userProfile->uuid]),
-                    'link_skill' => $this->url()->fromRoute('profile/my-profiles/skill', ['id' => $userProfile->uuid] ),
+                'link_location' => $this->url()->fromRoute('profile/my-profiles/location', ['id' => $userProfile->uuid]),
-                    'link_social_network' => $this->url()->fromRoute('profile/my-profiles/social-network', ['id' => $userProfile->uuid]),
-                    'link_aptitude' => $this->url()->fromRoute('profile/my-profiles/aptitude', ['id' => $userProfile->uuid] ),
+                'link_skill' => $this->url()->fromRoute('profile/my-profiles/skill', ['id' => $userProfile->uuid]),
+                'link_social_network' => $this->url()->fromRoute('profile/my-profiles/social-network', ['id' => $userProfile->uuid]),
-                    'link_hobby_and_interest' => $this->url()->fromRoute('profile/my-profiles/hobby-and-interest', ['id' => $userProfile->uuid]),
+                'link_aptitude' => $this->url()->fromRoute('profile/my-profiles/aptitude', ['id' => $userProfile->uuid]),
                 'link_hobby_and_interest' => $this->url()->fromRoute('profile/my-profiles/hobby-and-interest', ['id' => $userProfile->uuid]),
-                ];
+            ];
         return new JsonModel($data);
     }
         return new JsonModel($data);
+    }
+    /**
+     * Maneja la subida y eliminación de la imagen del perfil de usuario.
+     * Este método permite:
+     * - Subir una nueva imagen de perfil
+     * - Eliminar la imagen existente
-    /**
+     * - Actualizar la imagen principal del usuario si el perfil es público
      * Cambio de la imagen del image del perfil
      * @return \Laminas\View\Model\JsonModel
      */
+    public function imageAction()
     public function imageAction()
         // Obtener el usuario actual del sistema
+        $currentUserPlugin = $this->plugin('currentUserPlugin');
-        $currentUserPlugin = $this->plugin('currentUserPlugin');
+        $currentUser = $currentUserPlugin->getUser();
         $currentUser = $currentUserPlugin->getUser();
+        // Obtener parámetros de la ruta: ID del perfil y operación (upload/delete)
         $user_profile_id    = $this->params()->fromRoute('id');
-        $user_profile_id    = $this->params()->fromRoute('id');
         $operation          = $this->params()->fromRoute('operation');
+        // Obtener el perfil de usuario correspondiente
         $userProfileMapper = UserProfileMapper::getInstance($this->adapter);
-        $userProfileMapper = UserProfileMapper::getInstance($this->adapter);
         $userProfile = $userProfileMapper->fetchOneByUuid($user_profile_id);
         $userProfile = $userProfileMapper->fetchOneByUuid($user_profile_id);
-        if (!$userProfile) {
+        // Validar que el perfil existe
-            // Use helper
+        if (!$userProfile) {
-            return $this->_createSimpleErrorResponse('ERROR_INVALID_PARAMETER');
             return $this->_createSimpleErrorResponse('ERROR_INVALID_PARAMETER');
+        }
-        // Authorize: Check if current user owns the profile
+        // Verificar que el usuario actual es el propietario del perfil
         if ($currentUser->id != $userProfile->user_id) {
-            // Use helper
+            return $this->_createSimpleErrorResponse('ERROR_UNAUTHORIZED');
             return $this->_createSimpleErrorResponse('ERROR_UNAUTHORIZED');
+        // Procesar solo peticiones POST
         $request = $this->getRequest();
+        if ($request->isPost()) {
-        if ($request->isPost()) {
+            // Inicializar el sistema de almacenamiento
+            $storage = Storage::getInstance($this->config, $this->adapter);
             $target_path = $storage->getPathUser();
+            $user_uuid = $currentUser->uuid;
             $storage = Storage::getInstance($this->config, $this->adapter);
-            $target_path = $storage->getPathUser();
-            $user_uuid = $currentUser->uuid; // Assuming user UUID for path
+            // Manejar la eliminación de la imagen
             if ($operation == 'delete') {
-                $this->logger->info('Se borro el image del perfil ' . ($userProfile->public == UserProfile::PUBLIC_YES ? 'público' : $userProfile->name), ['user_id' => $userProfile->user_id, 'ip' => Functions::getUserIP()]);
+                // Registrar la acción en el log
                 $this->logger->info('Se borro el image del perfil ' . ($userProfile->public == UserProfile::PUBLIC_YES ? 'público' : $userProfile->name), ['user_id' => $userProfile->user_id, 'ip' => Functions::getUserIP()]);
-                if ($userProfile->image) {
-                    // Attempt deletion
+                // Si existe una imagen, intentar eliminarla
-                    if (!$storage->deleteFile($target_path, $user_uuid, $userProfile->image)) {
+                if ($userProfile->image) {
-                        // Use helper
-                        return $this->_createSimpleErrorResponse('ERROR_THERE_WAS_AN_ERROR');
+                    if (!$storage->deleteFile($target_path, $user_uuid, $userProfile->image)) {
                         return $this->_createSimpleErrorResponse('ERROR_THERE_WAS_AN_ERROR');
-                }
+                    }
+                }
-                // Clear image field and update DB
+                // Limpiar el campo de imagen y actualizar la base de datos
                 $userProfile->image = '';
                 if (!$userProfileMapper->updateImage($userProfile)) {
-                    // Use helper
+                    return $this->_createSimpleErrorResponse('ERROR_THERE_WAS_AN_ERROR');
                     return $this->_createSimpleErrorResponse('ERROR_THERE_WAS_AN_ERROR');
-                }
-            } else { // Handle upload
+            } else {
-                $form = new ImageForm($this->config);
-                $data = array_merge($request->getPost()->toArray(), $request->getFiles()->toArray());
+                // Manejar la subida de una nueva imagen
                 $form = new ImageForm($this->config);
-                $form->setData($data);
+                $data = array_merge($request->getPost()->toArray(), $request->getFiles()->toArray());
-                if ($form->isValid()) {
+                $form->setData($data);
-                    $storage->setFiles($request->getFiles()->toArray());
+                if ($form->isValid()) {
+                    // Configurar el archivo para procesamiento
-                    // *** FIX: Use correct input field name 'image' ***
+                    $storage->setFiles($request->getFiles()->toArray());
                     if (!$storage->setCurrentFilename('image')) {
-                        // Use helper
+                        return $this->_createSimpleErrorResponse('ERROR_UPLOAD_FILE');
-                        return $this->_createSimpleErrorResponse('ERROR_UPLOAD_FILE');
+                    }
-                    }
                     // Obtener dimensiones objetivo para el redimensionamiento
-                    // Prepare for resize and save
                     list($target_width_str, $target_height_str) = explode('x', $this->config['leaderslinked.image_sizes.user_size']);
                     $target_width = (int)$target_width_str;
                     $target_height = (int)$target_height_str;
-                    $source_filename    = $storage->getTmpFilename();
+                    // Generar nombres de archivo únicos
-                    $filename           = 'user-profile-' . uniqid() . '.png';
+                    $source_filename    = $storage->getTmpFilename();
-                    $target_filename    = $storage->composePathToFilename(Storage::TYPE_USER, $user_uuid, $filename);
                     $filename           = 'user-profile-' . uniqid() . '.png';
-                    // Upload, resize, save
+                    $target_filename    = $storage->composePathToFilename(Storage::TYPE_USER, $user_uuid, $filename);
                     if (!$storage->uploadImageResize($source_filename, $target_filename, $target_width, $target_height)) {
-                        // Use helper
+                    // Subir y redimensionar la imagen
-                        return $this->_createSimpleErrorResponse('ERROR_THERE_WAS_AN_ERROR');
+                    if (!$storage->uploadImageResize($source_filename, $target_filename, $target_width, $target_height)) {
                         return $this->_createSimpleErrorResponse('ERROR_THERE_WAS_AN_ERROR');
                     // Delete old image if exists
                     if ($userProfile->image) {
-                        if (!$storage->deleteFile($target_path, $user_uuid, $userProfile->image)) {
+                    // Eliminar la imagen anterior si existe
-                            // Use helper
+                    if ($userProfile->image) {
-                            return $this->_createSimpleErrorResponse('ERROR_THERE_WAS_AN_ERROR');
-                        }
+                        if (!$storage->deleteFile($target_path, $user_uuid, $userProfile->image)) {
-                    }
+                            return $this->_createSimpleErrorResponse('ERROR_THERE_WAS_AN_ERROR');
-                    // Update profile model and DB
+                        }
-                    $userProfile->image = $filename;
+                    }
-                    if (!$userProfileMapper->updateImage($userProfile)) {
-                        // Use helper
-                        return $this->_createSimpleErrorResponse('ERROR_THERE_WAS_AN_ERROR');
+                    // Actualizar el perfil con la nueva imagen
                     $userProfile->image = $filename;
+                    if (!$userProfileMapper->updateImage($userProfile)) {
-                    // Special handling: If this is the PUBLIC profile, also update the main user image
+                        return $this->_createSimpleErrorResponse('ERROR_THERE_WAS_AN_ERROR');
                     if ($userProfile->public == UserProfile::PUBLIC_YES) {
-                        $main_user_filename = 'user-' . uniqid() . '.png'; // Use different name for safety?
-                        // $source_filename_for_copy = $target_filename; // The newly saved profile image
+                    // Si es un perfil público, actualizar también la imagen principal del usuario
-                        $target_filename_main_user = $storage->composePathToFilename(Storage::TYPE_USER, $user_uuid, $main_user_filename);
+                    if ($userProfile->public == UserProfile::PUBLIC_YES) {
                         $main_user_filename = 'user-' . uniqid() . '.png';
-                        // Copy the *newly processed* profile image to be the main user image
+                        $target_filename_main_user = $storage->composePathToFilename(Storage::TYPE_USER, $user_uuid, $main_user_filename);
                         if (!$storage->copyFile($target_filename, $target_filename_main_user)) { // Source is the *new* profile image
-                            // Use helper
+                        // Copiar la imagen del perfil para la imagen principal
-                             return $this->_createSimpleErrorResponse('ERROR_THERE_WAS_AN_ERROR');
+                        if (!$storage->copyFile($target_filename, $target_filename_main_user)) {
-                        }
+                            return $this->_createSimpleErrorResponse('ERROR_THERE_WAS_AN_ERROR');
                         // Delete the old main user image if it exists
                         if ($currentUser->image) {
+                        // Eliminar la imagen principal anterior si existe
-                            if (!$storage->deleteFile($target_path, $user_uuid, $currentUser->image)) {
+                        if ($currentUser->image) {
-                                 // Use helper
+                            if (!$storage->deleteFile($target_path, $user_uuid, $currentUser->image)) {
                                 return $this->_createSimpleErrorResponse('ERROR_THERE_WAS_AN_ERROR');
+                            }
+                        }
-                        // Update current user model and DB
+                        // Actualizar la imagen principal del usuario
                         $currentUser->image = $main_user_filename;
-                        $userMapper = UserMapper::getInstance($this->adapter);
-                        if (!$userMapper->updateImage($currentUser)) {
+                        $userMapper = UserMapper::getInstance($this->adapter);
-                             // Use helper
+                        if (!$userMapper->updateImage($currentUser)) {
-                             return $this->_createSimpleErrorResponse('ERROR_THERE_WAS_AN_ERROR');
+                            return $this->_createSimpleErrorResponse('ERROR_THERE_WAS_AN_ERROR');
+                        }
+                    }
-                    $this->logger->info('Se actualizo el image del perfil ' . ($userProfile->public == UserProfile::PUBLIC_YES ? 'público' : $userProfile->name), ['user_id' => $userProfile->user_id, 'ip' => Functions::getUserIP()]);
+                    // Registrar la actualización en el log
-                } else {
+                    $this->logger->info('Se actualizo el image del perfil ' . ($userProfile->public == UserProfile::PUBLIC_YES ? 'público' : $userProfile->name), ['user_id' => $userProfile->user_id, 'ip' => Functions::getUserIP()]);
-                    // Use helper for form errors
+                } else {
-                    return $this->_createFormErrorResponse($form);
+                    // Devolver errores de validación del formulario
-                }
+                    return $this->_createFormErrorResponse($form);
-            } // End upload/delete logic
+                }
             // Success response (for both upload and delete)
             // Instantiate storage again just to be safe, though the instance from above should be okay
-            $storage = Storage::getInstance($this->config, $this->adapter);
+            // Devolver respuesta exitosa con las URLs actualizadas
         $request = $this->getRequest();
         if ($request->isPost()) {
             $storage = Storage::getInstance($this->config, $this->adapter);
             $target_path = $storage->getPathUser(); // Base path for user-specific files
             $user_uuid = $currentUser->uuid;
             // Handle cover deletion operation
             if ($operation == 'delete') {
                 if ($userProfile->cover) {
                     // Attempt to delete the existing cover file from storage
                     if (!$storage->deleteFile($target_path, $user_uuid, $userProfile->cover)) {
+                    }
+                }
                 // Log the deletion action
                 $this->logger->info('Se borro el cover del perfil ' . ($userProfile->public == UserProfile::PUBLIC_YES ? 'público' : $userProfile->name), ['user_id' => $userProfile->user_id, 'ip' => Functions::getUserIP()]);
                 $userProfile->cover = ''; // Clear the cover field in the profile model
                 // Persist the cleared cover information to the database
                 if (!$userProfileMapper->updateCover($userProfile)) {
                     // Handle error if database update fails for deletion
                     return $this->_createSimpleErrorResponse('ERROR_THERE_WAS_AN_ERROR');
+                }
                     // Upload, resize, and save the image
                     if (!$storage->uploadImageResize($source_filename, $target_filename, $target_width, $target_height)) {
                         return $this->_createSimpleErrorResponse('ERROR_THERE_WAS_AN_ERROR');
                     }
                     // If an old cover exists, delete it from storage
                     if ($userProfile->cover) {
                         if (!$storage->deleteFile($target_path, $user_uuid, $userProfile->cover)) {
                             // Decide if this is a critical error. Original code returns error.
                 } else {
                     // Form is invalid, return validation messages
                     return $this->_createFormErrorResponse($form);
+                }
             } // End of upload/delete specific logic
             // Successful operation (upload or delete has been handled and persisted)
             // Return success response with the current cover URL (new, or default after delete)
             // The $storage instance from the beginning of the POST block is still valid.
             return new JsonModel([
                 'success'   => true,
      */
     private function _createSimpleErrorResponse($errorMessageKey)
+    {
         return new JsonModel([
             'success' => false,
             'data'    => $errorMessageKey
         ]);
+    }
     /**

Proyectos de Subversion LeadersLinked - Services

(root)/module/LeadersLinked/src/Controller/MyProfilesController.php – Rev 558 → 596