class.action.quickPick.php

Go to the documentation of this file.

<?php
/*
 *
 *  * Copyright (c) 2022-2025 Bearsampp
 *  * License: GNU General Public License version 3 or later; see LICENSE.txt
 *  * Website: https://bearsampp.com
 *  * Github: https://github.com/Bearsampp
 *
 */

class QuickPick
{
    public $modules = [
        'Apache'      => ['type' => 'binary'],
        'Bruno'       => ['type' => 'tools'],
        'Composer'    => ['type' => 'tools'],
        'Ghostscript' => ['type' => 'tools'],
        'Git'         => ['type' => 'tools'],
        'Mailpit'     => ['type' => 'binary'],
        'MariaDB'     => ['type' => 'binary'],
        'Memcached'   => ['type' => 'binary'],
        'MySQL'       => ['type' => 'binary'],
        'Ngrok'       => ['type' => 'tools'],
        'NodeJS'      => ['type' => 'binary'],
        'Perl'        => ['type' => 'tools'],
        'PHP'         => ['type' => 'binary'],
        'PhpMyAdmin'  => ['type' => 'application'],
        'PhpPgAdmin'  => ['type' => 'application'],
        'PostgreSQL'  => ['type' => 'binary'],
        'PowerShell'  => ['type' => 'tools'],
        'Python'      => ['type' => 'tools'],
        'Ruby'        => ['type' => 'tools'],
        'Xlight'      => ['type' => 'binary']
    ];

    private $versions = [];

    private $jsonFilePath;

    public function __construct()
    {
        global $bearsamppCore;
        $this->jsonFilePath = $bearsamppCore->getResourcesPath() . '/quickpick-releases.json';
    }

    private function formatVersionLabel($version, $isPrerelease = false) {
        global $bearsamppConfig;
        $includePr = $bearsamppConfig->getIncludePr();
 
        if ($isPrerelease && $includePr == 1) {
            return '<span class="text-danger">' . htmlspecialchars($version) . ' PR</span>';
        }
 
        return htmlspecialchars($version);
    }

    public function normalizeModuleName(string $moduleName): ?string
    {
        // Remove 'module-' prefix if present
        $moduleName = str_replace('module-', '', $moduleName);
        
        // Find the correct module key by searching through the modules array
        // This handles proper capitalization for all module types
        foreach ($this->modules as $key => $moduleInfo) {
            if (strtolower($key) === strtolower($moduleName)) {
                return $key;
            }
        }
        
        return null;
    }

    public function getModules(): array
    {
        return array_keys( $this->modules );
    }

    public function loadQuickpick(string $imagesPath): string
    {
        global $bearsamppConfig;
 
        // Validate EnhancedQuickPick parameter
        $validation = $bearsamppConfig->validateEnhancedQuickPick();
        if (!$validation['valid']) {
            return $this->getErrorModal($validation['error']);
        }
 
        $this->checkQuickpickJson();
 
        $modules  = $this->getModules();
        $versions = $this->getVersions();
 
        return $this->getQuickpickMenu( $modules, $versions, $imagesPath );
    }

    public function checkQuickpickJson()
    {
        global $bearsamppConfig;
 
        // Determine local file creation time or rebuild if missing
        $localFileCreationTime = $this->getLocalFileCreationTime();
 
        // Attempt to retrieve remote file headers
        $headers = get_headers(QUICKPICK_JSON_URL, 1);
        if (!$this->isValidHeaderResponse($headers)) {
            // If headers or Date are invalid, assume no update needed
            return false;
        }
 
        // Optionally log headers for verbose output
        $this->logHeaders($headers);
 
        // Compare the creation times (remote vs. local)
        $remoteFileCreationTime = strtotime(isset($headers['Date']) ? $headers['Date'] : '');
        if ($remoteFileCreationTime > $localFileCreationTime) { return $this->rebuildQuickpickJson(); }
 
        // Return false if local file is already up-to-date
        return false;
    }

    private function getLocalFileCreationTime()
    {
        if (!file_exists($this->jsonFilePath)) {
            // If local file is missing, rebuild it immediately
            $this->rebuildQuickpickJson();
            return 0;
        }
        return filectime($this->jsonFilePath);
    }

    private function isValidHeaderResponse($headers): bool
    {
        // If headers retrieval failed or Date is not set, return false
        if ($headers === false || !isset($headers['Date'])) {
            return false;
        }
        return true;
    }

    private function logHeaders(array $headers): void
    {
        global $bearsamppConfig;
 
        if ($bearsamppConfig->getLogsVerbose() === 2) {
            Util::logDebug('Headers: ' . print_r($headers, true));
        }
    }

    public function getQuickpickJson(): array
    {
        $content = @file_get_contents( $this->jsonFilePath );
        if ( $content === false ) {
            Util::logError( 'Error fetching content from JSON file: ' . $this->jsonFilePath );
 
            return ['error' => 'Error fetching JSON file'];
        }
 
        $data = json_decode( $content, true );
        if ( json_last_error() !== JSON_ERROR_NONE ) {
            Util::logError( 'Error decoding JSON content: ' . json_last_error_msg() );
 
            return ['error' => 'Error decoding JSON content'];
        }
 
        return $data;
    }

    public function rebuildQuickpickJson(): array
    {
        Util::logDebug( 'Fetching JSON file: ' . $this->jsonFilePath );
 
        // Fetch the JSON content from the URL
        $jsonContent = file_get_contents( QUICKPICK_JSON_URL );
 
        if ( $jsonContent === false ) {
            // Handle error if the file could not be fetched
            throw new Exception( 'Failed to fetch JSON content from the URL.' );
        }
 
        // Save the JSON content to the specified path
        $result = file_put_contents( $this->jsonFilePath, $jsonContent );
 
        if ( $result === false ) {
            // Handle error if the file could not be saved
            throw new Exception( 'Failed to save JSON content to the specified path.' );
        }
 
        // Return success message
        return ['success' => 'JSON content fetched and saved successfully'];
    }

    public function getVersions(): array
    {
        Util::logDebug( 'Versions called' );
 
        $versions = [];
 
        $jsonData = $this->getQuickpickJson();
 
        foreach ( $jsonData as $entry ) {
            if ( is_array( $entry ) ) {
                if ( isset( $entry['module'] ) && is_string( $entry['module'] ) ) {
                    if ( isset( $entry['versions'] ) && is_array( $entry['versions'] ) ) {
                        $versions[$entry['module']] = array_column( $entry['versions'], null, 'version' );
                    }
                }
            }
            else {
                Util::logError( 'Invalid entry format in JSON data' );
            }
        }
 
        if ( empty( $versions ) ) {
            Util::logError( 'No versions found' );
 
            return ['error' => 'No versions found'];
        }
 
        Util::logDebug( 'Found versions' );
 
        $this->versions = $versions;
 
        return $versions;
    }

    public function getModuleUrl(string $module, string $version)
    {
        $this->getVersions();
        Util::logDebug( 'getModuleUrl called for module: ' . $module . ' version: ' . $version );
        $url = trim( $this->versions['module-' . strtolower( $module )][$version]['url'] );
        if ( $url <> '' ) {
            Util::logDebug( 'Found URL for version: ' . $version . ' URL: ' . $url );
 
            return $url;
        }
        else {
            Util::logError( 'Version not found: ' . $version );
 
            return ['error' => 'Version not found'];
        }
    }

    public function checkDownloadId(): bool
    {
        global $bearsamppConfig;
 
        Util::logDebug( 'checkDownloadId method called.' );
 
        // Ensure the global config is available
        if ( !isset( $bearsamppConfig ) ) {
            Util::logError( 'Global configuration is not set.' );
 
            return false;
        }
 
        $DownloadId = $bearsamppConfig->getDownloadId();
        Util::logDebug( 'DownloadId is: ' . $DownloadId );
 
        // Ensure the license key is not empty
        if ( empty( $DownloadId ) ) {
            Util::logError( 'License key is empty.' );
 
            return false;
        }
 
        $url = QUICKPICK_API_URL . QUICKPICK_API_KEY . '&download_id=' . $DownloadId;
        Util::logDebug( 'API URL: ' . $url );
 
        // Attempt to fetch the API response
        // Note: If this fails, PHP will generate a warning which will be logged by the error handler
        // This is expected behavior when the API server is unavailable
        $response = file_get_contents( $url );
 
        // Check if the response is false
        if ( $response === false ) {
            Util::logError( 'Failed to validate QuickPick license - API server unavailable' );
            return false;
        }
 
        Util::logDebug( 'API response: ' . $response );
 
        $data = json_decode( $response, true );
 
        // Check if the JSON decoding was successful
        if ( json_last_error() !== JSON_ERROR_NONE ) {
            Util::logError( 'Error decoding JSON response: ' . json_last_error_msg() );
 
            return false;
        }
 
        // Validate the response data
        if ( isset( $data['success'] ) && $data['success'] === true && isset( $data['data'] ) && is_array( $data['data'] ) && count( $data['data'] ) > 0 ) {
            Util::logDebug( 'License key valid: ' . $DownloadId );
 
            return true;
        }
 
        Util::logError( 'Invalid license key: ' . $DownloadId );
 
        return false;
    }

    public function installModule(string $module, string $version): array
    {
        // Find the module URL and module name from the data
        $moduleUrl = $this->getModuleUrl( $module, $version );
 
        if ( is_array( $moduleUrl ) && isset( $moduleUrl['error'] ) ) {
            Util::logError( 'Module URL not found for module: ' . $module . ' version: ' . $version );
 
            return ['error' => 'Module URL not found'];
        }
 
        if ( empty( $moduleUrl ) ) {
            Util::logError( 'Module URL not found for module: ' . $module . ' version: ' . $version );
 
            return ['error' => 'Module URL not found'];
        }
 
        $state = Util::checkInternetState();
        if ( $state ) {
            $response = $this->fetchAndUnzipModule( $moduleUrl, $module );
            Util::logDebug( 'Response is: ' . print_r( $response, true ) );
 
            // Check if enhanced mode is enabled
            global $bearsamppConfig;
            $enhancedMode = $bearsamppConfig->getEnhancedQuickPick();
            
            Util::logDebug('Enhanced mode: ' . ($enhancedMode ? 'enabled' : 'disabled'));
            
            // If installation was successful and enhanced mode is enabled, update config
            if (isset($response['success']) && $enhancedMode == 1) {
                // Step 1: Update config FIRST (so reload can pick up the new version)
                Util::logDebug('Enhanced mode enabled - Updating config for module: ' . $module . ' version: ' . $version);
                $configUpdated = $this->updateModuleConfig($module, $version);
                
                if ($configUpdated) {
                    // Step 2: Trigger reload AFTER config update (reload will apply the new version)
                    Util::logDebug('Config updated successfully, triggering reload to apply changes...');
                    
                    // Send progress update to user - temporarily stop output buffering
                    $obLevel = ob_get_level();
                    while (ob_get_level() > 0) {
                        ob_end_flush();
                    }
                    
                    echo json_encode(['phase' => 'updating', 'message' => 'Updating system configuration...']);
                    flush();
                    
                    // Restart output buffering
                    for ($i = 0; $i < $obLevel; $i++) {
                        ob_start();
                    }
                    
                    // Note: User must manually reload from tray menu to activate the new version
                    Util::logDebug('Installation complete - user must manually reload from tray menu');
                    $response['reload_required'] = true;
                } else {
                    Util::logError('Config update failed for module: ' . $module);
                    $response['reload_triggered'] = false;
                }
            } else if (isset($response['success']) && $enhancedMode == 0) {
                Util::logDebug('Enhanced mode disabled - skipping config update');
            }
 
            return $response;
        }
        else {
            Util::logError( 'No internet connection available.' );
 
            return ['error' => 'No internet connection'];
        }
    }

    public function fetchAndUnzipModule(string $moduleUrl, string $module): array
{
    Util::logDebug("$module is: " . $module);
 
    global $bearsamppRoot, $bearsamppCore;
    $tmpDir = $bearsamppRoot->getTmpPath();
    Util::logDebug('Temporary Directory: ' . $tmpDir);
 
    $fileName = basename($moduleUrl);
    Util::logDebug('File Name: ' . $fileName);
 
    $tmpFilePath = $tmpDir . '/' . $fileName;
    Util::logDebug('File Path: ' . $tmpFilePath);
 
    $moduleName = str_replace('module-', '', $module);
    Util::logDebug('Module Name: ' . $moduleName);
 
    // Find the correct module key by searching through the modules array
    // This handles proper capitalization for all module types
    $moduleKey = null;
    foreach ($this->modules as $key => $moduleInfo) {
        if (strtolower($key) === strtolower($moduleName)) {
            $moduleKey = $key;
            break;
        }
    }
    
    if (!$moduleKey) {
        Util::logError("Module not found in modules array: $moduleName");
        return ['error' => 'Module configuration not found'];
    }
    
    $moduleType = $this->modules[$moduleKey]['type'];
    Util::logDebug('Module Type: ' . $moduleType);
 
    // Get module type
    $destination = $this->getModuleDestinationPath($moduleType, $moduleName);
    Util::logDebug('Destination: ' . $destination);
 
    // Retrieve the file path from the URL using the bearsamppCore module,
    // passing the module URL and temporary file path, with the use Progress Bar parameter set to true.
    $result = $bearsamppCore->getFileFromUrl($moduleUrl, $tmpFilePath, true);
 
    // Check if $result is false
    if ($result === false) {
        Util::logError('Failed to retrieve file from URL: ' . $moduleUrl);
        return ['error' => 'Failed to retrieve file from URL'];
    }
 
    // Determine the file extension and call the appropriate unzipping function
    $fileExtension = pathinfo($tmpFilePath, PATHINFO_EXTENSION);
    Util::logDebug('File extension: ' . $fileExtension);
 
    if ($fileExtension === '7z' || $fileExtension === 'zip') {
        // Send phase indicator for extraction
        echo json_encode(['phase' => 'extracting']);
        if (ob_get_length()) {
            ob_flush();
        }
        flush();
 
        $unzipResult = $bearsamppCore->unzipFile($tmpFilePath, $destination, function ($currentPercentage) {
            echo json_encode(['progress' => "$currentPercentage%"]);
            if (ob_get_length()) {
                ob_flush();
            }
            flush();
        });
 
        if ($unzipResult === false) {
            return ['error' => 'Failed to unzip file. File: ' . $tmpFilePath . ' could not be unzipped', 'Destination: ' . $destination];
        }
    } else {
        Util::logError('Unsupported file extension: ' . $fileExtension);
        return ['error' => 'Unsupported file extension'];
    }
 
    return ['success' => 'Module installed successfully'];
}

    public function getModuleDestinationPath(string $moduleType, string $moduleName)
    {
        global $bearsamppRoot;
        if ( $moduleType === 'application' ) {
            $destination = $bearsamppRoot->getAppsPath() . '/' . strtolower( $moduleName ) . '/';
        }
        elseif ( $moduleType === 'binary' ) {
            $destination = $bearsamppRoot->getBinPath() . '/' . strtolower( $moduleName ) . '/';
        }
        elseif ( $moduleType === 'tools' ) {
            $destination = $bearsamppRoot->getToolsPath() . '/' . strtolower( $moduleName ) . '/';
        }
        else {
            $destination = '';
        }
 
        return $destination;
    }

    private function regenerateMenuSafe(): string
    {
        Util::logDebug('Regenerating menu (AJAX-safe mode)...');
        
        // Suppress errors temporarily during menu generation
        $oldErrorReporting = error_reporting();
        error_reporting($oldErrorReporting & ~E_WARNING);
        
        try {
            // Generate the menu content
            $menuContent = TplApp::process();
            
            // Restore error reporting
            error_reporting($oldErrorReporting);
            
            Util::logDebug('Menu regenerated successfully');
            return $menuContent;
            
        } catch (Exception $e) {
            // Restore error reporting
            error_reporting($oldErrorReporting);
            
            Util::logWarning('Error during menu regeneration: ' . $e->getMessage());
            throw $e;
        }
    }

    private function updateModuleConfig(string $module, string $version): bool
    {
        try {
            $bearsamppConfig = new Config();
            
            // Remove 'module-' prefix if present and normalize the module name
            $moduleName = str_replace('module-', '', $module);
            
            // Find the correct module key by searching through the modules array
            // This handles proper capitalization for all module types
            $moduleKey = null;
            foreach ($this->modules as $key => $moduleInfo) {
                if (strtolower($key) === strtolower($moduleName)) {
                    $moduleKey = $key;
                    break;
                }
            }
            
            if (!$moduleKey) {
                Util::logError("Module not found in modules array: $moduleName");
                return false;
            }
            
            $moduleType = $this->modules[$moduleKey]['type'];
            
            // Map module names to their config section names
            // For all types, use the lowercase name for the config key
            $configSection = strtolower($moduleKey);
            
            Util::logDebug("Updating config for module: $module (key: $moduleKey, type: $moduleType) to version: $version");
            Util::logDebug("Config section: $configSection");
            
            // Update the configuration file
            // The Config class expects a flat key like "nodejsVersion" not a section
            $configKey = $configSection . 'Version';
            $bearsamppConfig->replace($configKey, $version);
            
            Util::logInfo("Successfully updated $configSection version to $version in bearsampp.conf");
            
            return true;
            
        } catch (Exception $e) {
            Util::logError("Failed to update module config: " . $e->getMessage());
            return false;
        }
    }

    public function getErrorModal(string $errorMessage): string
    {
        ob_start();
        ?>
        <div id="configErrorContainer" class="text-center mt-3 pe-3">
            <div class="alert alert-danger d-inline-block" role="alert" style="max-width: 500px;">
                <h4 class="alert-heading">
                    <i class="fas fa-exclamation-circle"></i> Configuration Error
                </h4>
                <hr>
                <p class="mb-0">
                    <?php echo htmlspecialchars($errorMessage); ?>
                </p>
                <hr>
                <small class="text-muted">
                    Please add the missing parameter to the <code>bearsampp.conf</code> file in the Bearsampp root directory.
                </small>
            </div>
        </div>
        <?php
        return ob_get_clean();
    }

    public function getQuickpickMenu(array $modules, array $versions, string $imagesPath): string
    {
        global $bearsamppConfig;
        $includePr = $bearsamppConfig->getIncludePr();
        $enhancedMode = $bearsamppConfig->getEnhancedQuickPick();
 
        ob_start();
        if ( Util::checkInternetState() ) {
 
            // Check if the license key is valid
            if ( $this->checkDownloadId() ): ?>
                <div id = 'quickPickContainer'>
                    <div class = 'quickpick'>
 
                        <div class = "custom-select">
                            <button class = "select-button" role = "combobox"
                                    aria-label = "select button"
                                    aria-haspopup = "listbox"
                                    aria-expanded = "false"
                                    aria-controls = "select-dropdown">
                                <span class = "selected-value">Select a module and version</span>
                                <span class = "arrow"></span>
                            </button>
                            <ul class = "select-dropdown" role = "listbox" id = "select-dropdown">
 
                                <?php
                                foreach ( $modules as $module ): ?>
                                    <?php if ( is_string( $module ) ): ?>
                                        <li role = "option" class = "moduleheader">
                                            <?php echo htmlspecialchars( $module ); ?>
                                        </li>
 
                                        <?php
                                        foreach ( $versions['module-' . strtolower( $module )] as $version_array ):
                                            // Skip prerelease versions if includePr is not enabled
                                            if (isset($version_array['prerelease']) && $version_array['prerelease'] === true && $includePr != 1) {
                                                continue;
                                            }
                                        ?>
                                            <li role = "option" class = "moduleoption"
                                                id = "<?php echo htmlspecialchars( $module ); ?>-version-<?php echo htmlspecialchars( $version_array['version'] ); ?>-li">
                                                <input type = "radio"
                                                       id = "<?php echo htmlspecialchars( $module ); ?>-version-<?php echo htmlspecialchars( $version_array['version'] ); ?>"
                                                       name = "module" data-module = "<?php echo htmlspecialchars( $module ); ?>"
                                                       data-value = "<?php echo htmlspecialchars( $version_array['version'] ); ?>">
                                                <label
                                                    for = "<?php echo htmlspecialchars( $module ); ?>-version-<?php echo htmlspecialchars( $version_array['version'] ); ?>"><?php echo $this->formatVersionLabel( $version_array['version'], isset($version_array['prerelease']) && $version_array['prerelease'] === true ); ?></label>
                                            </li>
                                        <?php endforeach; ?>
                                    <?php endif; ?>
                                <?php endforeach; ?>
                            </ul>
                        </div>
                    </div>
                    <div class = "progress " id = "progress" tabindex = "-1" style = "width:260px;display:none"
                         aria-labelledby = "progressbar" aria-hidden = "true">
                        <div class = "progress-bar progress-bar-striped progress-bar-animated" id = "progress-bar" role = "progressbar" aria-valuenow = "0" aria-valuemin = "0"
                             aria-valuemax = "100" data-module = "Module"
                             data-version = "0.0.0">0%
                        </div>
                        <div id = "download-module" style = "display: none">ModuleName</div>
                        <div id = "download-version" style = "display: none">Version</div>
                    </div>
                </div>
            <?php else: ?>
                <div id = "subscribeContainer" class = "text-center mt-3 pe-3">
                    <a href = "<?php echo Util::getWebsiteUrl( 'subscribe' ); ?>" class = "btn btn-dark d-inline-flex align-items-center">
                        <img src = "<?php echo $imagesPath . 'subscribe.svg'; ?>" alt = "Subscribe Icon" class = "me-2">
                        Subscribe to QuickPick now
                    </a>
                </div>
            <?php endif;
        }
        else {
            ?>
            <div id = "InternetState" class = "text-center mt-3 pe-3">
                <img src = "<?php echo $imagesPath . 'no-wifi-icon.svg'; ?>" alt = "No Wifi Icon" class = "me-2">
                <span>No internet present</span>
            </div>
            <?php
        }
 
        return ob_get_clean();
    }
}