From c7f140b38a3bb42da10b6b103a4d26c2c4e85b97 Mon Sep 17 00:00:00 2001 From: Nikolay Beketov Date: Thu, 5 Jun 2025 14:48:46 +0300 Subject: [PATCH 1/6] Added .DS_Store to .gitignore and updated module.json with release settings for publishing and changelog. --- .github/workflows/build.yml | 15 +++++++++++++++ .gitignore | 1 + module.json | 5 +++++ 3 files changed, 21 insertions(+) create mode 100644 .github/workflows/build.yml diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml new file mode 100644 index 0000000..1c1da71 --- /dev/null +++ b/.github/workflows/build.yml @@ -0,0 +1,15 @@ +name: Build and Publish + +on: + push: + branches: + - master + - develop + workflow_dispatch: + +jobs: + build: + uses: mikopbx/.github-workflows/.github/workflows/extension-publish.yml@master + with: + initial_version: "1.18" + secrets: inherit \ No newline at end of file diff --git a/.gitignore b/.gitignore index f7206fa..27a60ee 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,3 @@ .idea /.idea/ +.DS_Store diff --git a/module.json b/module.json index 04c70ea..a0b9c54 100644 --- a/module.json +++ b/module.json @@ -7,5 +7,10 @@ "wiki_links": { "ru": {"https://wiki.mikopbx.com/module-get-ssl": "https://docs.mikopbx.com/mikopbx/modules/miko/module-get-ssl-lets-encrypt"}, "en": {"https://wiki.mikopbx.com/module-get-ssl": "https://docs.mikopbx.com/mikopbx/v/english/modules/miko/module-get-ssl-lets-encrypt"} + }, + "release_settings": { + "publish_release": true, + "changelog_enabled": true, + "create_github_release": true } } \ No newline at end of file From 20b753577ec76b2d01e113d73eb5697edae4d045 Mon Sep 17 00:00:00 2001 From: Weblate Date: Mon, 29 Sep 2025 09:00:23 +0300 Subject: [PATCH 2/6] Added translation using Weblate (Hebrew) --- Messages/he.php | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 Messages/he.php diff --git a/Messages/he.php b/Messages/he.php new file mode 100644 index 0000000..b547ddb --- /dev/null +++ b/Messages/he.php @@ -0,0 +1,33 @@ +. + */ + 'repModuleGetSsl' => '', + 'mo_ModuleModuleGetSsl' => '', + 'BreadcrumbModuleGetSsl' => '', + 'SubHeaderModuleGetSsl' => '', + 'module_getssl_DomainNameLabel' => '', + 'module_getssl_autoUpdateLabel' => '', + 'module_getssl_getUpdateSSLButton' => '', + 'module_getssl_getUpdateLogHeader' => '', + 'module_getssl_DomainNameEmpty' => '', + 'module_getssl_ConfigStartsGenerating' => '', + 'module_getssl_ConfigGenerated' => '', + 'module_getssl_GetSSLProcessing' => '', + 'module_getssl_GetSSLProcessingTimeout' => '', +]; From ea1a7127a14ff92530e83ff97a2ed58b11c2837b Mon Sep 17 00:00:00 2001 From: Weblate Date: Tue, 30 Sep 2025 04:50:36 +0300 Subject: [PATCH 3/6] Added translation using Weblate (Persian) --- Messages/fa.php | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 Messages/fa.php diff --git a/Messages/fa.php b/Messages/fa.php new file mode 100644 index 0000000..b547ddb --- /dev/null +++ b/Messages/fa.php @@ -0,0 +1,33 @@ +. + */ + 'repModuleGetSsl' => '', + 'mo_ModuleModuleGetSsl' => '', + 'BreadcrumbModuleGetSsl' => '', + 'SubHeaderModuleGetSsl' => '', + 'module_getssl_DomainNameLabel' => '', + 'module_getssl_autoUpdateLabel' => '', + 'module_getssl_getUpdateSSLButton' => '', + 'module_getssl_getUpdateLogHeader' => '', + 'module_getssl_DomainNameEmpty' => '', + 'module_getssl_ConfigStartsGenerating' => '', + 'module_getssl_ConfigGenerated' => '', + 'module_getssl_GetSSLProcessing' => '', + 'module_getssl_GetSSLProcessingTimeout' => '', +]; From 87fbb069af5372e47c3003806d5fee747766280a Mon Sep 17 00:00:00 2001 From: Nikolay Beketov Date: Tue, 17 Feb 2026 11:53:03 +0700 Subject: [PATCH 4/6] docs: add README in English and Russian, add CLAUDE.md Replace template readme with module description for sysadmins. Add English README.md with cross-link to Russian version. Add CLAUDE.md with architecture and build instructions for Claude Code. --- CLAUDE.md | 80 ++++++++++++++++++++++++++++++++++++++++++++++++++++ README.md | 35 +++++++++++++++++++++++ readme.ru.md | 35 +++++++++++++++++++---- 3 files changed, 144 insertions(+), 6 deletions(-) create mode 100644 CLAUDE.md create mode 100644 README.md diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..a6398c5 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,80 @@ +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +## Overview + +MikoPBX extension module for automated SSL certificate management via Let's Encrypt (ACME v2). Uses the `getssl` bash script as the ACME client, supports 40+ DNS providers for DNS-01 validation, and provides real-time certificate request progress via nchan Pub/Sub or polling fallback. + +## Build Commands + +### JavaScript Compilation +Source files live in `public/assets/js/src/`, compiled output goes to `public/assets/js/`: +```bash +/Users/nb/PhpstormProjects/mikopbx/MikoPBXUtils/node_modules/.bin/babel \ + "public/assets/js/src/module-get-ssl-index.js" \ + --out-dir "public/assets/js/" \ + --source-maps inline \ + --presets airbnb +``` +Repeat for each source file (`module-get-ssl-index.js`, `module-get-ssl-status-worker.js`). + +### PHP Static Analysis +```bash +phpstan analyse +``` + +## Architecture + +### Module Lifecycle +1. **Installation** (`Setup/PbxExtensionSetup.php`): Creates DB table `m_ModuleGetSsl`, sets defaults, detects domain from internet interface +2. **Runtime** (`Lib/GetSslConf.php`): Registers REST API callbacks, cron tasks, reacts to model changes and PBX lifecycle events +3. **Certificate Request** (`Lib/GetSslMain.php`): Generates getssl config, launches async certificate request, streams progress to browser +4. **Uninstall**: Removes symlinks from `/usr/bin/getssl`, `/usr/share/getssl`, `/usr/www/sites/.well-known` + +### Key Classes + +- **`Lib/GetSslConf.php`** — Module configuration hook. Handles REST API routing (`GET-CERT`, `CHECK-RESULT`), cron task registration (1st/15th at 01:00), and PBX lifecycle events (`onAfterPbxStarted`, `onAfterModuleEnable`) +- **`Lib/GetSslMain.php`** — Core orchestrator. Manages directories, generates getssl config file, launches certificate requests, monitors process completion (120s timeout), pushes real-time updates via nchan, updates SSL keys in PbxSettings DB +- **`Lib/MikoPBXVersion.php`** — Compatibility layer for Phalcon 4 vs 5 class names. Version cutoff at PBX 2024.2.30 +- **`Models/ModuleGetSsl.php`** — Phalcon ORM model for `m_ModuleGetSsl` table (fields: `id`, `domainName`, `autoUpdate`) +- **`App/Controllers/ModuleGetSslController.php`** — Web UI controller: renders form, handles save, triggers certificate request on save +- **`App/Forms/ModuleGetSslForm.php`** — Phalcon form definition with Semantic UI integration + +### Frontend (ES6 → Babel → ES5) + +- **`public/assets/js/src/module-get-ssl-index.js`** — Form controller: validation, module status toggle, triggers API call to start certificate request, handles async response channel +- **`public/assets/js/src/module-get-ssl-status-worker.js`** — Real-time progress: EventSource (PBX ≥2024.2.30) or polling fallback, Ace editor for log display, 4-stage processing pipeline (STAGE_1–4) + +### REST API + +- `POST /pbxcore/api/modules/ModuleGetSsl/get-cert` — Start certificate request. Supports async via `X-Async-Response-Channel-Id` header +- `GET /pbxcore/api/modules/ModuleGetSsl/check-result` — Poll log file contents (fallback for older PBX versions) + +### Real-time Updates + +Pub/Sub channel `module-get-ssl-pub` pushes JSON messages with `moduleUniqueId`, `stage`, `stageDetails`, `pid`. Browser subscribes via EventSource on PBX ≥2024.2.30, falls back to polling `check-result` endpoint on older versions. + +### Symlinks Created at Runtime +- `/usr/bin/getssl` → `{moduleDir}/bin/getssl` +- `/usr/share/getssl` → `{moduleDir}/bin/utils` +- `/usr/www/sites/.well-known` → `{moduleDir}/db/getssl/.well-known` +- `/usr/bin/nslookup` → busybox + +### Cron Auto-Renewal +Runs `getssl -a -U -q -w {confDir}` on 1st and 15th of each month at 01:00. Cron is reloaded whenever module settings change. + +## Phalcon Version Compatibility + +Always use `MikoPBXVersion` for version-dependent class imports (Di, Validation, Uniqueness, Text, Logger). PBX versions ≥2024.2.30 use Phalcon 5; older versions use Phalcon 4. Do not hardcode Phalcon namespace paths. + +## Internationalization + +31 language files in `Messages/`. Translation keys prefixed with `module_getssl_`. English (`en.php`) is the reference file. + +## Dependencies + +- PHP 7.4+ / 8.0+, Phalcon 4 or 5 +- MikoPBX Core framework (`MikoPBX\Common`, `MikoPBX\Core`, `MikoPBX\Modules`, `MikoPBX\AdminCabinet`) +- jQuery, Semantic UI, Ace Editor (from MikoPBX core frontend) +- `getssl` ACME client (`bin/getssl`, embedded 142KB bash script) diff --git a/README.md b/README.md new file mode 100644 index 0000000..831ecce --- /dev/null +++ b/README.md @@ -0,0 +1,35 @@ +# ModuleGetSsl — Free SSL Certificates for MikoPBX + +[Русская версия](readme.ru.md) + +## What It Does + +This module automates obtaining and renewing free SSL certificates from [Let's Encrypt](https://letsencrypt.org/) for your MikoPBX web interface. After setup, the HTTPS certificate is issued automatically and renewed on schedule — no manual steps required. + +## How It Works + +1. You install the module from the MikoPBX module marketplace +2. Enter your domain name in the module settings and click save +3. The module requests a certificate from Let's Encrypt, and the progress is shown in real time +4. Once issued, the certificate is automatically applied to the MikoPBX web interface + +Auto-renewal runs on the 1st and 15th of each month. If the certificate is due for renewal, it will be updated automatically. + +## Requirements + +- MikoPBX **2024.1.114** or newer +- A domain name pointing to your PBX public IP address (A record) +- Port **80** accessible from the internet (required for Let's Encrypt HTTP-01 validation) + +## Documentation + +- [English documentation](https://docs.mikopbx.com/mikopbx/v/english/modules/miko/module-get-ssl-lets-encrypt) +- [Документация на русском](https://docs.mikopbx.com/mikopbx/modules/miko/module-get-ssl-lets-encrypt) + +## Support + +For questions and issues — [help@miko.ru](mailto:help@miko.ru) or the developer channel in Telegram: [@mikopbx_dev](https://t.me/joinchat/AAPn5xSqZIpQnNnCAa3bBw) + +## License + +GPL-3.0-or-later diff --git a/readme.ru.md b/readme.ru.md index 3e2892c..ebd9214 100644 --- a/readme.ru.md +++ b/readme.ru.md @@ -1,12 +1,35 @@ -# Шаблон модуля расширения для MikoPBX +# ModuleGetSsl — Бесплатные SSL-сертификаты для MikoPBX -_Read this in other languages:_ [_English_](./)_,_ [_Русский_](readme.ru.md)_._ +[English version](README.md) -## Описание модуля расширения +## Что делает модуль -Документацию по разработке и установке собственного модуля можно найти по ссылке [https://docs.mikopbx.com](https://docs.mikopbx.com/mikopbx-development/) +Модуль автоматически получает и обновляет бесплатные SSL-сертификаты от [Let's Encrypt](https://letsencrypt.org/) для веб-интерфейса MikoPBX. После настройки HTTPS-сертификат выпускается автоматически и продлевается по расписанию — никаких ручных действий не требуется. -### Вопросы +## Как это работает -Подключайтесь к каналу для разрабочиков в telegram [@mikopbx\_dev](https://t.me/joinchat/AAPn5xSqZIpQnNnCAa3bBw) +1. Установите модуль из маркетплейса модулей MikoPBX +2. Укажите доменное имя в настройках модуля и нажмите сохранить +3. Модуль запросит сертификат у Let's Encrypt, прогресс отображается в реальном времени +4. После выпуска сертификат автоматически применяется к веб-интерфейсу MikoPBX +Автоматическое продление запускается 1-го и 15-го числа каждого месяца. Если сертификат подлежит обновлению, он будет продлён автоматически. + +## Требования + +- MikoPBX версии **2024.1.114** или новее +- Доменное имя, указывающее на публичный IP-адрес АТС (A-запись) +- Порт **80**, доступный из интернета (необходим для HTTP-01 валидации Let's Encrypt) + +## Документация + +- [Документация на русском](https://docs.mikopbx.com/mikopbx/modules/miko/module-get-ssl-lets-encrypt) +- [English documentation](https://docs.mikopbx.com/mikopbx/v/english/modules/miko/module-get-ssl-lets-encrypt) + +## Поддержка + +По вопросам и проблемам — [help@miko.ru](mailto:help@miko.ru) или канал разработчиков в Telegram: [@mikopbx_dev](https://t.me/joinchat/AAPn5xSqZIpQnNnCAa3bBw) + +## Лицензия + +GPL-3.0-or-later From f17b5b099ef8c7a3ee47fb210c5189a44bccc2bf Mon Sep 17 00:00:00 2001 From: Nikolay Beketov Date: Tue, 17 Feb 2026 16:05:24 +0700 Subject: [PATCH 5/6] feat: temporarily open port 80 for ACME HTTP-01 validation Add AcmeHttpPort class that creates a dedicated nginx server block on port 80 serving only /.well-known/acme-challenge/ (returns 444 for everything else) and adds iptables rules when firewall is managed. Port 80 is opened before certificate request and guaranteed closed after via try/finally in all code paths: REST API GET-CERT handler, updateCert.php, and new cronRenewCert.php wrapper for cron renewal. Safety mechanisms: - Lock file with PID+timestamp in /var/run (tmpfs, survives no crash) - Watchdog cron (every minute) cleans up stale state after 5min/dead PID - Cleanup on PBX startup via onAfterPbxStarted Also adds timestamp wrapper for getssl output (ISO format matching syslog) and phpstan.neon config for the module. --- Lib/AcmeHttpPort.php | 241 ++++++++++++++++++++++++++++++++++++++++ Lib/GetSslConf.php | 22 +++- Lib/GetSslMain.php | 12 +- bin/cleanupPort80.php | 26 +++++ bin/cronRenewCert.php | 44 ++++++++ bin/timestampWrapper.sh | 5 + bin/updateCert.php | 14 ++- phpstan.neon | 26 +++++ 8 files changed, 376 insertions(+), 14 deletions(-) create mode 100644 Lib/AcmeHttpPort.php create mode 100644 bin/cleanupPort80.php create mode 100644 bin/cronRenewCert.php create mode 100644 bin/timestampWrapper.sh create mode 100644 phpstan.neon diff --git a/Lib/AcmeHttpPort.php b/Lib/AcmeHttpPort.php new file mode 100644 index 0000000..bfd3002 --- /dev/null +++ b/Lib/AcmeHttpPort.php @@ -0,0 +1,241 @@ +. + */ + +namespace Modules\ModuleGetSsl\Lib; + +use MikoPBX\Common\Models\PbxSettings; +use MikoPBX\Core\System\Processes; +use MikoPBX\Core\System\System; +use MikoPBX\Core\System\Util; +use Modules\ModuleGetSsl\Models\ModuleGetSsl; + +/** + * Manages temporary port 80 opening for ACME HTTP-01 validation. + * + * Creates a dedicated nginx server block on port 80 serving only + * /.well-known/acme-challenge/ and adds iptables rules when firewall is active. + */ +class AcmeHttpPort +{ + private const LOCK_FILE = '/var/run/custom_modules/ModuleGetSsl/acme_port80.lock'; + private const NGINX_ACME_CONF = '/etc/nginx/mikopbx/modules_servers/ModuleGetSsl_acme80.conf'; + private const MAX_OPEN_SECONDS = 300; + + /** + * Opens port 80 for ACME HTTP-01 validation. + * + * Creates a dedicated nginx server block and adds firewall rules if needed. + * + * @return bool true on success or if port is already open + */ + public function openPort(): bool + { + if ($this->isAlreadyOpen()) { + return true; + } + + $lockDir = dirname(self::LOCK_FILE); + Util::mwMkdir($lockDir); + $lockData = json_encode(['pid' => getmypid(), 'time' => time()]); + file_put_contents(self::LOCK_FILE, $lockData); + + $domainName = $this->getDomainName(); + if (empty($domainName)) { + unlink(self::LOCK_FILE); + return false; + } + + $this->createNginxConf($domainName); + $this->reloadNginx(); + $this->addFirewallRules(); + + return true; + } + + /** + * Closes port 80 after ACME validation completes. + * + * Removes the nginx config, reloads nginx, removes firewall rules, and cleans up the lock file. + */ + public function closePort(): void + { + if (file_exists(self::NGINX_ACME_CONF)) { + unlink(self::NGINX_ACME_CONF); + } + $this->reloadNginx(); + $this->removeFirewallRules(); + + if (file_exists(self::LOCK_FILE)) { + unlink(self::LOCK_FILE); + } + } + + /** + * Cleans up stale port 80 state from a previous crash or timeout. + */ + public static function cleanupStale(): void + { + if (!file_exists(self::LOCK_FILE)) { + return; + } + + $lockContent = file_get_contents(self::LOCK_FILE); + $lockData = json_decode($lockContent, true); + if (!is_array($lockData)) { + // Corrupted lock file, clean up + $instance = new self(); + $instance->closePort(); + Util::sysLogMsg(__CLASS__, 'Cleaned up corrupted ACME port 80 lock file'); + return; + } + + $pid = $lockData['pid'] ?? 0; + $lockTime = $lockData['time'] ?? 0; + $elapsed = time() - $lockTime; + $pidDead = ($pid > 0) ? !file_exists("/proc/$pid") : true; + + if ($elapsed > self::MAX_OPEN_SECONDS || $pidDead) { + $instance = new self(); + $instance->closePort(); + Util::sysLogMsg( + __CLASS__, + "Cleaned up stale ACME port 80 (elapsed: {$elapsed}s, pid: $pid, dead: " . ($pidDead ? 'yes' : 'no') . ')' + ); + } + } + + /** + * Checks if port 80 is already open by this module. + */ + private function isAlreadyOpen(): bool + { + if (!file_exists(self::LOCK_FILE)) { + return false; + } + + $lockContent = file_get_contents(self::LOCK_FILE); + $lockData = json_decode($lockContent, true); + if (!is_array($lockData)) { + return false; + } + + $pid = $lockData['pid'] ?? 0; + if ($pid > 0 && file_exists("/proc/$pid")) { + return true; + } + + return false; + } + + /** + * Gets domain name from module settings. + */ + private function getDomainName(): string + { + $settings = ModuleGetSsl::findFirst(); + if ($settings === null) { + return ''; + } + return $settings->domainName ?? ''; + } + + /** + * Creates a dedicated nginx server block for ACME validation on port 80. + */ + private function createNginxConf(string $domainName): void + { + $confDir = dirname(self::NGINX_ACME_CONF); + Util::mwMkdir($confDir); + + $conf = <<isFirewallManaged()) { + return; + } + + $iptablesPath = Util::which('iptables'); + Processes::mwExec("$iptablesPath -I INPUT -p tcp --dport 80 -j ACCEPT"); + + $ip6tablesPath = Util::which('ip6tables'); + Processes::mwExec("$ip6tablesPath -I INPUT -p tcp --dport 80 -j ACCEPT"); + } + + /** + * Removes iptables rules for port 80. + */ + private function removeFirewallRules(): void + { + if (!$this->isFirewallManaged()) { + return; + } + + $iptablesPath = Util::which('iptables'); + Processes::mwExec("$iptablesPath -D INPUT -p tcp --dport 80 -j ACCEPT"); + + $ip6tablesPath = Util::which('ip6tables'); + Processes::mwExec("$ip6tablesPath -D INPUT -p tcp --dport 80 -j ACCEPT"); + } + + /** + * Checks whether firewall rules need to be managed. + * + * Returns true only when PBX firewall is enabled AND system can manage iptables. + */ + private function isFirewallManaged(): bool + { + $firewallEnabled = PbxSettings::getValueByKey(PbxSettings::PBX_FIREWALL_ENABLED); + if ($firewallEnabled !== '1') { + return false; + } + return System::canManageFirewall(); + } +} diff --git a/Lib/GetSslConf.php b/Lib/GetSslConf.php index 945d46c..36e390e 100644 --- a/Lib/GetSslConf.php +++ b/Lib/GetSslConf.php @@ -25,6 +25,7 @@ use MikoPBX\Core\System\Util; use MikoPBX\Modules\Config\ConfigClass; use MikoPBX\PBXCoreREST\Lib\PBXApiResult; +use Modules\ModuleGetSsl\Lib\AcmeHttpPort; use Modules\ModuleGetSsl\Models\ModuleGetSsl; class GetSslConf extends ConfigClass @@ -65,11 +66,17 @@ public function moduleRestAPICallback(array $request): PBXApiResult } switch ($action) { case 'GET-CERT': - $moduleMain = new GetSslMain($asyncChannelId); - $moduleMain->createAclConf(); - $res = $moduleMain->startGetCertSsl(); - if (!empty($asyncChannelId)) { - $res = $moduleMain->checkResultAsync(); + $portManager = new AcmeHttpPort(); + $portManager->openPort(); + try { + $moduleMain = new GetSslMain($asyncChannelId); + $moduleMain->createAclConf(); + $res = $moduleMain->startGetCertSsl(); + if (!empty($asyncChannelId)) { + $res = $moduleMain->checkResultAsync(); + } + } finally { + $portManager->closePort(); } break; case 'CHECK-RESULT': @@ -92,6 +99,7 @@ public function moduleRestAPICallback(array $request): PBXApiResult */ public function onAfterPbxStarted(): void { + AcmeHttpPort::cleanupStale(); $moduleMain = new GetSslMain(); $moduleMain->createAclConf(); } @@ -123,5 +131,9 @@ public function createCronTasks(array &$tasks): void if (!empty($task)) { $tasks[] = $task; } + + // Watchdog: check every minute for stale port 80 state + $phpPath = Util::which('php'); + $tasks[] = "* * * * * $phpPath -f $this->moduleDir/bin/cleanupPort80.php > /dev/null 2>&1" . PHP_EOL; } } diff --git a/Lib/GetSslMain.php b/Lib/GetSslMain.php index b386e7f..d6d9f00 100644 --- a/Lib/GetSslMain.php +++ b/Lib/GetSslMain.php @@ -298,13 +298,15 @@ public function startGetCertSsl(bool $asynchronously = true): PBXApiResult $pid = Processes::getPidOfProcess("$getSsl $extHostname"); if ($pid === '') { $confDir = $this->dirs['confDir']; + $shPath = Util::which('sh'); + $tsWrapper = $this->dirs['binDir'] . '/timestampWrapper.sh'; if($asynchronously){ - Processes::mwExecBg("$getSsl $extHostname -w '$confDir'", $this->logFile); + Processes::mwExecBg("$shPath $tsWrapper $getSsl $extHostname -w '$confDir'", $this->logFile); $pid = Processes::getPidOfProcess("$getSsl $extHostname"); }else{ echo('starting'.PHP_EOL); passthru("cat '$confDir/getssl.cfg' "); - passthru("$getSsl $extHostname -w '$confDir'", $this->logFile); + passthru("$shPath $tsWrapper $getSsl $extHostname -w '$confDir'", $this->logFile); } } $result->data['result'] = $this->translation->_('module_getssl_GetSSLProcessing'); @@ -400,9 +402,9 @@ public function getCronTask(): string && intval($this->module_settings['autoUpdate']) === 1 && !empty($this->module_settings['domainName']) ) { - $workerPath = $this->dirs['moduleDir']. '/db/getssl'; - $getSslPath = $this->dirs['getSslPath']; - return "0 1 1,15 * * $getSslPath -a -U -q -w '$workerPath' > /dev/null 2> /dev/null" . PHP_EOL; + $phpPath = Util::which('php'); + $cronScript = $this->dirs['moduleDir'] . '/bin/cronRenewCert.php'; + return "0 1 1,15 * * $phpPath -f $cronScript > /dev/null 2>&1" . PHP_EOL; } return ''; } diff --git a/bin/cleanupPort80.php b/bin/cleanupPort80.php new file mode 100644 index 0000000..58d4127 --- /dev/null +++ b/bin/cleanupPort80.php @@ -0,0 +1,26 @@ +#!/usr/bin/php +. + */ + +use Modules\ModuleGetSsl\Lib\AcmeHttpPort; + +require_once('Globals.php'); + +AcmeHttpPort::cleanupStale(); diff --git a/bin/cronRenewCert.php b/bin/cronRenewCert.php new file mode 100644 index 0000000..a2ba18e --- /dev/null +++ b/bin/cronRenewCert.php @@ -0,0 +1,44 @@ +#!/usr/bin/php +. + */ + +use MikoPBX\Core\System\Processes; +use MikoPBX\Core\System\Util; +use Modules\ModuleGetSsl\Lib\AcmeHttpPort; +use Modules\ModuleGetSsl\Lib\GetSslMain; + +require_once('Globals.php'); + +$portManager = new AcmeHttpPort(); +$portManager->openPort(); +try { + $moduleMain = new GetSslMain(); + $moduleMain->createAclConf(); + + $getSslPath = $moduleMain->dirs['getSslPath']; + $confDir = $moduleMain->dirs['confDir']; + $shPath = Util::which('sh'); + $tsWrapper = $moduleMain->dirs['binDir'] . '/timestampWrapper.sh'; + Processes::mwExec("$shPath $tsWrapper $getSslPath -a -U -q -w '$confDir'"); + + $moduleMain->run(); +} finally { + $portManager->closePort(); +} diff --git a/bin/timestampWrapper.sh b/bin/timestampWrapper.sh new file mode 100644 index 0000000..80ae902 --- /dev/null +++ b/bin/timestampWrapper.sh @@ -0,0 +1,5 @@ +#!/bin/sh +# Wraps a command's output with ISO timestamps on each line +"$@" 2>&1 | while IFS= read -r line; do + printf "[%s] %s\n" "$(date '+%Y-%m-%d %H:%M:%S')" "$line" +done diff --git a/bin/updateCert.php b/bin/updateCert.php index f51c4da..2a5c6e5 100644 --- a/bin/updateCert.php +++ b/bin/updateCert.php @@ -19,11 +19,17 @@ * If not, see . */ -use MikoPBX\Core\System\Configs\NginxConf; +use Modules\ModuleGetSsl\Lib\AcmeHttpPort; use Modules\ModuleGetSsl\Lib\GetSslMain; require_once('Globals.php'); -$moduleMain = new GetSslMain(); -$moduleMain->createAclConf(); -$res = $moduleMain->startGetCertSsl(false); \ No newline at end of file +$portManager = new AcmeHttpPort(); +$portManager->openPort(); +try { + $moduleMain = new GetSslMain(); + $moduleMain->createAclConf(); + $res = $moduleMain->startGetCertSsl(false); +} finally { + $portManager->closePort(); +} \ No newline at end of file diff --git a/phpstan.neon b/phpstan.neon new file mode 100644 index 0000000..c7702cd --- /dev/null +++ b/phpstan.neon @@ -0,0 +1,26 @@ +parameters: + level: 0 + paths: + - Lib + - Models + - bin + - App + - Setup + scanDirectories: + - ../../Core/src + parallel: + jobSize: 20 + processTimeout: 300.0 + tmpDir: /tmp/phpstan-ModuleGetSsl + reportUnmatchedIgnoredErrors: false + ignoreErrors: + - + message: '#unknown class Phalcon\\Di#' + - + message: '#Class Phalcon\\Validation not found#' + - + message: '#Class Phalcon\\Validation\\Validator\\Uniqueness not found#' + - + message: '#Class Phalcon\\Text not found#' + - + message: '#Class Phalcon\\Logger not found#' From f8359c067ccd971f26e157966d84ff48f4f71b94 Mon Sep 17 00:00:00 2001 From: Nikolay Beketov Date: Wed, 18 Feb 2026 11:17:48 +0700 Subject: [PATCH 6/6] fix: button loading state, cert install from disk, log improvements - Disable submit button and show ACE editor immediately on cert request - Re-enable button on success/failure - Call run() after cert process to install existing cert files into PbxSettings (fixes case when cert exists on disk but was cleared from system settings) - Load last log into ACE editor on page open - Add link to system diagnostic for full log - Add timestamped logging for port 80 open/close and cert installation - Add translation keys for log link (en, ru) --- App/Views/ModuleGetSsl/index.volt | 3 ++ Lib/AcmeHttpPort.php | 31 ++++++++++++++++++- Lib/GetSslConf.php | 3 ++ Lib/GetSslMain.php | 12 +++++++ Messages/en.php | 1 + Messages/ru.php | 1 + public/assets/js/module-get-ssl-index.js | 11 +++++-- .../assets/js/module-get-ssl-status-worker.js | 23 +++++++++++++- public/assets/js/src/module-get-ssl-index.js | 9 ++++-- .../js/src/module-get-ssl-status-worker.js | 22 +++++++++++++ 10 files changed, 109 insertions(+), 7 deletions(-) diff --git a/App/Views/ModuleGetSsl/index.volt b/App/Views/ModuleGetSsl/index.volt index be257e3..71f0fe0 100644 --- a/App/Views/ModuleGetSsl/index.volt +++ b/App/Views/ModuleGetSsl/index.volt @@ -18,6 +18,9 @@ {{ partial("partials/submitbutton",['submitBtnIconClass':'exchange icon', 'submitBtnText': t._('module_getssl_getUpdateSSLButton')]) }} diff --git a/Lib/AcmeHttpPort.php b/Lib/AcmeHttpPort.php index bfd3002..76e6474 100644 --- a/Lib/AcmeHttpPort.php +++ b/Lib/AcmeHttpPort.php @@ -21,6 +21,7 @@ namespace Modules\ModuleGetSsl\Lib; use MikoPBX\Common\Models\PbxSettings; +use MikoPBX\Core\System\Directories; use MikoPBX\Core\System\Processes; use MikoPBX\Core\System\System; use MikoPBX\Core\System\Util; @@ -38,6 +39,14 @@ class AcmeHttpPort private const NGINX_ACME_CONF = '/etc/nginx/mikopbx/modules_servers/ModuleGetSsl_acme80.conf'; private const MAX_OPEN_SECONDS = 300; + private string $logFile; + + public function __construct() + { + $logDir = Directories::getDir(Directories::CORE_LOGS_DIR); + $this->logFile = "$logDir/ModuleGetSsl/last-result.log"; + } + /** * Opens port 80 for ACME HTTP-01 validation. * @@ -48,6 +57,7 @@ class AcmeHttpPort public function openPort(): bool { if ($this->isAlreadyOpen()) { + $this->log('Port 80 already open, skipping'); return true; } @@ -59,12 +69,20 @@ public function openPort(): bool $domainName = $this->getDomainName(); if (empty($domainName)) { unlink(self::LOCK_FILE); + $this->log('Port 80 open skipped: domain name is empty'); return false; } $this->createNginxConf($domainName); $this->reloadNginx(); - $this->addFirewallRules(); + + $firewallManaged = $this->isFirewallManaged(); + if ($firewallManaged) { + $this->addFirewallRules(); + $this->log("Port 80 opened for $domainName (nginx + iptables)"); + } else { + $this->log("Port 80 opened for $domainName (nginx only, firewall not managed)"); + } return true; } @@ -85,6 +103,8 @@ public function closePort(): void if (file_exists(self::LOCK_FILE)) { unlink(self::LOCK_FILE); } + + $this->log('Port 80 closed'); } /** @@ -238,4 +258,13 @@ private function isFirewallManaged(): bool } return System::canManageFirewall(); } + + /** + * Appends a timestamped message to the module log file. + */ + private function log(string $message): void + { + $timestamp = date('Y-m-d H:i:s'); + file_put_contents($this->logFile, "[$timestamp] $message" . PHP_EOL, FILE_APPEND); + } } diff --git a/Lib/GetSslConf.php b/Lib/GetSslConf.php index 36e390e..d958327 100644 --- a/Lib/GetSslConf.php +++ b/Lib/GetSslConf.php @@ -75,6 +75,9 @@ public function moduleRestAPICallback(array $request): PBXApiResult if (!empty($asyncChannelId)) { $res = $moduleMain->checkResultAsync(); } + // Install existing cert files into PbxSettings + // (handles case when cert exists on disk but was cleared from settings) + $moduleMain->run(); } finally { $portManager->closePort(); } diff --git a/Lib/GetSslMain.php b/Lib/GetSslMain.php index d6d9f00..137800e 100644 --- a/Lib/GetSslMain.php +++ b/Lib/GetSslMain.php @@ -341,6 +341,9 @@ public function run(): void if (file_exists($privateKeyPath) && file_exists($certPath)) { $this->updateKey('WEBHTTPSPublicKey', $certPath); $this->updateKey('WEBHTTPSPrivateKey', $privateKeyPath); + $this->appendLog('SSL certificate installed into PbxSettings'); + } else { + $this->appendLog('Certificate files not found, skipping PbxSettings update'); } } @@ -385,6 +388,15 @@ private function updateKey(string $name, string $path): void } } + /** + * Appends a timestamped message to the module log file. + */ + private function appendLog(string $message): void + { + $timestamp = date('Y-m-d H:i:s'); + file_put_contents($this->logFile, "[$timestamp] $message" . PHP_EOL, FILE_APPEND); + } + /** * Generates a cron task string for automatically updating SSL certificates. * diff --git a/Messages/en.php b/Messages/en.php index d854b3f..b0d826b 100644 --- a/Messages/en.php +++ b/Messages/en.php @@ -20,4 +20,5 @@ 'module_getssl_ConfigGenerated' => 'Configuration files created...', 'module_getssl_GetSSLProcessing' => 'Requesting data from Lets Encrypt...', 'module_getssl_GetSSLProcessingTimeout' => 'Error, Lets Encrypt service did not return a response within 2 minutes', + 'module_getssl_ViewFullLogLink' => 'View full log in system diagnostic', ]; diff --git a/Messages/ru.php b/Messages/ru.php index ad7f839..7ab2ee4 100644 --- a/Messages/ru.php +++ b/Messages/ru.php @@ -31,4 +31,5 @@ 'module_getssl_ConfigGenerated' => 'Конфигурационные файлы созданы...', 'module_getssl_GetSSLProcessing' => 'Выполняется запрос данных в Lets Encrypt...', 'module_getssl_GetSSLProcessingTimeout' => 'Ошибка, сервис Lets Encrypt не вернул ответа в течение 2 минут', + 'module_getssl_ViewFullLogLink' => 'Смотреть полный лог в системной диагностике', ]; diff --git a/public/assets/js/module-get-ssl-index.js b/public/assets/js/module-get-ssl-index.js index 7e7fae4..4f76ba4 100644 --- a/public/assets/js/module-get-ssl-index.js +++ b/public/assets/js/module-get-ssl-index.js @@ -15,6 +15,7 @@ var ModuleGetSsl = { $checkBoxes: $('#' + idForm + ' .ui.checkbox'), $disabilityFields: $('#' + idForm + ' .disability'), $statusToggle: $('#module-status-toggle'), + $submitButton: $('#submitbutton'), $moduleStatus: $('#status'), $intervalId: undefined, // To manage the interval for SSL status check @@ -59,6 +60,9 @@ var ModuleGetSsl = { return xhr; }, beforeSend: function beforeSend(settings) { + ModuleGetSsl.$submitButton.addClass('loading disabled'); + moduleGetSSLStatusLoopWorker.$resultBlock.show(); + moduleGetSSLStatusLoopWorker.editor.getSession().setValue(''); return settings; }, successTest: PbxApi.successTest, @@ -68,14 +72,15 @@ var ModuleGetSsl = { * @param {object} response - The response object. */ onSuccess: function onSuccess(response) { - moduleGetSSLStatusLoopWorker.editor.getSession().setValue(''); + ModuleGetSsl.$submitButton.removeClass('loading disabled'); }, /** - * Handles the failure response of the 'get-available-ldap-users' API request. + * Handles the failure response of the 'get-cert' API request. * @param {object} response - The response object. */ onFailure: function onFailure(response) { + ModuleGetSsl.$submitButton.removeClass('loading disabled'); UserMessage.showMultiString(response.message); moduleGetSSLStatusLoopWorker.$resultBlock.hide(); } @@ -138,4 +143,4 @@ var ModuleGetSsl = { $(document).ready(function () { ModuleGetSsl.initialize(); }); -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["src/module-get-ssl-index.js"],"names":["idUrl","idForm","className","ModuleGetSsl","$formObj","$","$checkBoxes","$disabilityFields","$statusToggle","$moduleStatus","$intervalId","undefined","validateRules","domainName","identifier","rules","type","prompt","globalTranslate","module_getssl_DomainNameEmpty","initialize","checkbox","checkStatusToggle","window","addEventListener","initializeForm","moduleGetSSLStatusLoopWorker","$resultBlock","hide","getSsl","api","url","Config","pbxUrl","on","method","beforeXHR","xhr","setRequestHeader","channelId","beforeSend","settings","successTest","PbxApi","onSuccess","response","editor","getSession","setValue","onFailure","UserMessage","showMultiString","message","removeClass","show","addClass","cbBeforeSendForm","result","data","form","cbAfterSendForm","Form","checkSuccess","globalRootUrl","enableDirrity","document","ready"],"mappings":"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","sourcesContent":["/* global globalRootUrl, globalTranslate, Form, Config, PbxApi */\n\n// Constants related to the form and module\nconst idUrl     = 'module-get-ssl';              // API endpoint for SSL module\nconst idForm    = 'module-get-ssl-form';         // Form element ID for SSL module\nconst className = 'ModuleGetSsl';                // Class name for this module\n\n// Main ModuleGetSsl class definition\nconst ModuleGetSsl = {\n\t// Cache commonly used jQuery objects\n\t$formObj: $('#' + idForm),\n\t$checkBoxes: $('#' + idForm + ' .ui.checkbox'),\n\t$disabilityFields: $('#' + idForm + ' .disability'),\n\t$statusToggle: $('#module-status-toggle'),\n\t$moduleStatus: $('#status'),\n\t$intervalId: undefined, // To manage the interval for SSL status check\n\n\t// Validation rules for the form\n\tvalidateRules: {\n\t\tdomainName: {\n\t\t\tidentifier: 'domainName',\n\t\t\trules: [\n\t\t\t\t{\n\t\t\t\t\ttype: 'empty',\n\t\t\t\t\tprompt: globalTranslate.module_getssl_DomainNameEmpty,\n\t\t\t\t},\n\t\t\t],\n\t\t},\n\t},\n\n\t/**\n\t * Initialize the module, bind event listeners, and setup the form.\n\t * This function is called when the document is ready.\n\t */\n\tinitialize() {\n\t\t// Initialize Semantic UI checkboxes\n\t\tthis.$checkBoxes.checkbox();\n\n\t\t// Check and set module status on load and when the status changes\n\t\tthis.checkStatusToggle();\n\t\twindow.addEventListener('ModuleStatusChanged', this.checkStatusToggle);\n\n\t\t// Initialize form with validation and submit handlers\n\t\tthis.initializeForm();\n\n\t\tmoduleGetSSLStatusLoopWorker.$resultBlock.hide();\n\t},\n\n\t/**\n\t * Request an SSL certificate by calling the server-side API.\n\t * This method sends a GET request to initiate the SSL process.\n\t */\n\tgetSsl() {\n\t\t$.api({\n\t\t\turl: `${Config.pbxUrl}/pbxcore/api/modules/${className}/get-cert`,\n\t\t\ton: 'now',\n\t\t\tmethod: 'POST',\n\t\t\tbeforeXHR(xhr) {\n\t\t\t\txhr.setRequestHeader ('X-Async-Response-Channel-Id', moduleGetSSLStatusLoopWorker.channelId);\n\t\t\t\txhr.setRequestHeader ('X-Processor-Timeout', '120');\n\t\t\t\treturn xhr;\n\t\t\t},\n\t\t\tbeforeSend(settings) {\n\t\t\t\treturn settings;\n\t\t\t},\n\t\t\tsuccessTest: PbxApi.successTest,\n\t\t\t/**\n\t\t\t * Handles the successful response of the 'get-cert' API request.\n\t\t\t * @param {object} response - The response object.\n\t\t\t */\n\t\t\tonSuccess: function (response) {\n\t\t\t\tmoduleGetSSLStatusLoopWorker.editor.getSession().setValue('');\n\t\t\t},\n\t\t\t/**\n\t\t\t * Handles the failure response of the 'get-available-ldap-users' API request.\n\t\t\t * @param {object} response - The response object.\n\t\t\t */\n\t\t\tonFailure: function(response) {\n\t\t\t\tUserMessage.showMultiString(response.message);\n\t\t\t\tmoduleGetSSLStatusLoopWorker.$resultBlock.hide();\n\t\t\t},\n\t\t})\n\t},\n\n\t/**\n\t * Toggles the form fields and status visibility based on the module's status.\n\t * Enables or disables form fields depending on whether the module is active.\n\t */\n\tcheckStatusToggle() {\n\t\t// If the module status is active, enable form fields and show status\n\t\tif (ModuleGetSsl.$statusToggle.checkbox('is checked')) {\n\t\t\tModuleGetSsl.$disabilityFields.removeClass('disabled');\n\t\t\tModuleGetSsl.$moduleStatus.show();\n\t\t} else {\n\t\t\t// If the module status is inactive, disable form fields and hide status\n\t\t\tModuleGetSsl.$disabilityFields.addClass('disabled');\n\t\t\tModuleGetSsl.$moduleStatus.hide();\n\t\t}\n\t},\n\n\t/**\n\t * Callback before sending the form.\n\t * @param {Object} settings - Ajax request settings.\n\t * @returns {Object} The modified Ajax request settings.\n\t */\n\tcbBeforeSendForm(settings) {\n\t\tconst result = settings;\n\t\tresult.data = ModuleGetSsl.$formObj.form('get values');\n\t\treturn result;\n\t},\n\n\t/**\n\t * Callback function after sending the form.\n\t */\n\tcbAfterSendForm(response) {\n\t\tif (Form.checkSuccess(response)){\n\t\t\tModuleGetSsl.getSsl();\n\t\t}\n\t},\n\n\n\t/**\n\t * Initializes the form validation and submission logic.\n\t * Sets up callbacks and validation rules for the form.\n\t */\n\tinitializeForm() {\n\t\t// Assign form-related settings to the Form object\n\t\tForm.$formObj = ModuleGetSsl.$formObj;\n\t\tForm.url = `${globalRootUrl}${idUrl}/${idUrl}/save`;\n\t\tForm.validateRules = ModuleGetSsl.validateRules;\n\t\tForm.enableDirrity = false;\n\t\tForm.cbAfterSendForm = ModuleGetSsl.cbAfterSendForm;\n\t\tForm.cbBeforeSendForm = ModuleGetSsl.cbBeforeSendForm;\n\t\t// Initialize the form with the specified parameters\n\t\tForm.initialize();\n\t},\n};\n\n// Initialize the ModuleGetSsl class when the document is ready\n$(document).ready(() => {\n\tModuleGetSsl.initialize();\n});"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["src/module-get-ssl-index.js"],"names":["idUrl","idForm","className","ModuleGetSsl","$formObj","$","$checkBoxes","$disabilityFields","$statusToggle","$submitButton","$moduleStatus","$intervalId","undefined","validateRules","domainName","identifier","rules","type","prompt","globalTranslate","module_getssl_DomainNameEmpty","initialize","checkbox","checkStatusToggle","window","addEventListener","initializeForm","moduleGetSSLStatusLoopWorker","$resultBlock","hide","getSsl","api","url","Config","pbxUrl","on","method","beforeXHR","xhr","setRequestHeader","channelId","beforeSend","settings","addClass","show","editor","getSession","setValue","successTest","PbxApi","onSuccess","response","removeClass","onFailure","UserMessage","showMultiString","message","cbBeforeSendForm","result","data","form","cbAfterSendForm","Form","checkSuccess","globalRootUrl","enableDirrity","document","ready"],"mappings":"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","sourcesContent":["/* global globalRootUrl, globalTranslate, Form, Config, PbxApi */\n\n// Constants related to the form and module\nconst idUrl     = 'module-get-ssl';              // API endpoint for SSL module\nconst idForm    = 'module-get-ssl-form';         // Form element ID for SSL module\nconst className = 'ModuleGetSsl';                // Class name for this module\n\n// Main ModuleGetSsl class definition\nconst ModuleGetSsl = {\n\t// Cache commonly used jQuery objects\n\t$formObj: $('#' + idForm),\n\t$checkBoxes: $('#' + idForm + ' .ui.checkbox'),\n\t$disabilityFields: $('#' + idForm + ' .disability'),\n\t$statusToggle: $('#module-status-toggle'),\n\t$submitButton: $('#submitbutton'),\n\t$moduleStatus: $('#status'),\n\t$intervalId: undefined, // To manage the interval for SSL status check\n\n\t// Validation rules for the form\n\tvalidateRules: {\n\t\tdomainName: {\n\t\t\tidentifier: 'domainName',\n\t\t\trules: [\n\t\t\t\t{\n\t\t\t\t\ttype: 'empty',\n\t\t\t\t\tprompt: globalTranslate.module_getssl_DomainNameEmpty,\n\t\t\t\t},\n\t\t\t],\n\t\t},\n\t},\n\n\t/**\n\t * Initialize the module, bind event listeners, and setup the form.\n\t * This function is called when the document is ready.\n\t */\n\tinitialize() {\n\t\t// Initialize Semantic UI checkboxes\n\t\tthis.$checkBoxes.checkbox();\n\n\t\t// Check and set module status on load and when the status changes\n\t\tthis.checkStatusToggle();\n\t\twindow.addEventListener('ModuleStatusChanged', this.checkStatusToggle);\n\n\t\t// Initialize form with validation and submit handlers\n\t\tthis.initializeForm();\n\n\t\tmoduleGetSSLStatusLoopWorker.$resultBlock.hide();\n\t},\n\n\t/**\n\t * Request an SSL certificate by calling the server-side API.\n\t * This method sends a GET request to initiate the SSL process.\n\t */\n\tgetSsl() {\n\t\t$.api({\n\t\t\turl: `${Config.pbxUrl}/pbxcore/api/modules/${className}/get-cert`,\n\t\t\ton: 'now',\n\t\t\tmethod: 'POST',\n\t\t\tbeforeXHR(xhr) {\n\t\t\t\txhr.setRequestHeader ('X-Async-Response-Channel-Id', moduleGetSSLStatusLoopWorker.channelId);\n\t\t\t\txhr.setRequestHeader ('X-Processor-Timeout', '120');\n\t\t\t\treturn xhr;\n\t\t\t},\n\t\t\tbeforeSend(settings) {\n\t\t\t\tModuleGetSsl.$submitButton.addClass('loading disabled');\n\t\t\t\tmoduleGetSSLStatusLoopWorker.$resultBlock.show();\n\t\t\t\tmoduleGetSSLStatusLoopWorker.editor.getSession().setValue('');\n\t\t\t\treturn settings;\n\t\t\t},\n\t\t\tsuccessTest: PbxApi.successTest,\n\t\t\t/**\n\t\t\t * Handles the successful response of the 'get-cert' API request.\n\t\t\t * @param {object} response - The response object.\n\t\t\t */\n\t\t\tonSuccess: function (response) {\n\t\t\t\tModuleGetSsl.$submitButton.removeClass('loading disabled');\n\t\t\t},\n\t\t\t/**\n\t\t\t * Handles the failure response of the 'get-cert' API request.\n\t\t\t * @param {object} response - The response object.\n\t\t\t */\n\t\t\tonFailure: function(response) {\n\t\t\t\tModuleGetSsl.$submitButton.removeClass('loading disabled');\n\t\t\t\tUserMessage.showMultiString(response.message);\n\t\t\t\tmoduleGetSSLStatusLoopWorker.$resultBlock.hide();\n\t\t\t},\n\t\t})\n\t},\n\n\t/**\n\t * Toggles the form fields and status visibility based on the module's status.\n\t * Enables or disables form fields depending on whether the module is active.\n\t */\n\tcheckStatusToggle() {\n\t\t// If the module status is active, enable form fields and show status\n\t\tif (ModuleGetSsl.$statusToggle.checkbox('is checked')) {\n\t\t\tModuleGetSsl.$disabilityFields.removeClass('disabled');\n\t\t\tModuleGetSsl.$moduleStatus.show();\n\t\t} else {\n\t\t\t// If the module status is inactive, disable form fields and hide status\n\t\t\tModuleGetSsl.$disabilityFields.addClass('disabled');\n\t\t\tModuleGetSsl.$moduleStatus.hide();\n\t\t}\n\t},\n\n\t/**\n\t * Callback before sending the form.\n\t * @param {Object} settings - Ajax request settings.\n\t * @returns {Object} The modified Ajax request settings.\n\t */\n\tcbBeforeSendForm(settings) {\n\t\tconst result = settings;\n\t\tresult.data = ModuleGetSsl.$formObj.form('get values');\n\t\treturn result;\n\t},\n\n\t/**\n\t * Callback function after sending the form.\n\t */\n\tcbAfterSendForm(response) {\n\t\tif (Form.checkSuccess(response)){\n\t\t\tModuleGetSsl.getSsl();\n\t\t}\n\t},\n\n\n\t/**\n\t * Initializes the form validation and submission logic.\n\t * Sets up callbacks and validation rules for the form.\n\t */\n\tinitializeForm() {\n\t\t// Assign form-related settings to the Form object\n\t\tForm.$formObj = ModuleGetSsl.$formObj;\n\t\tForm.url = `${globalRootUrl}${idUrl}/${idUrl}/save`;\n\t\tForm.validateRules = ModuleGetSsl.validateRules;\n\t\tForm.enableDirrity = false;\n\t\tForm.cbAfterSendForm = ModuleGetSsl.cbAfterSendForm;\n\t\tForm.cbBeforeSendForm = ModuleGetSsl.cbBeforeSendForm;\n\t\t// Initialize the form with the specified parameters\n\t\tForm.initialize();\n\t},\n};\n\n// Initialize the ModuleGetSsl class when the document is ready\n$(document).ready(() => {\n\tModuleGetSsl.initialize();\n});"]} \ No newline at end of file diff --git a/public/assets/js/module-get-ssl-status-worker.js b/public/assets/js/module-get-ssl-status-worker.js index 488a87d..1bec09b 100644 --- a/public/assets/js/module-get-ssl-status-worker.js +++ b/public/assets/js/module-get-ssl-status-worker.js @@ -59,6 +59,7 @@ var moduleGetSSLStatusLoopWorker = { */ initialize: function initialize() { moduleGetSSLStatusLoopWorker.initializeAce(); + moduleGetSSLStatusLoopWorker.loadLastLog(); if (moduleGetSSLStatusLoopWorker.versionCompare(globalPBXVersion, '2024.2.30') > 0) { moduleGetSSLStatusLoopWorker.startListenPushNotifications(); @@ -67,6 +68,26 @@ var moduleGetSSLStatusLoopWorker = { } }, + /** + * Loads the last log file content into the ACE editor on page load. + */ + loadLastLog: function loadLastLog() { + $.api({ + url: "".concat(Config.pbxUrl, "/pbxcore/api/modules/ModuleGetSsl/check-result"), + on: 'now', + method: 'GET', + successTest: PbxApi.successTest, + onSuccess: function onSuccess(response) { + if (response.data.result && response.data.result.length > 0) { + moduleGetSSLStatusLoopWorker.$resultBlock.show(); + moduleGetSSLStatusLoopWorker.editor.getSession().setValue(response.data.result); + } + }, + onFailure: function onFailure() {// Silently ignore - no log to show + } + }); + }, + /** * Restarts the moduleGetSSLStatus worker. */ @@ -243,4 +264,4 @@ var moduleGetSSLStatusLoopWorker = { $(document).ready(function () { moduleGetSSLStatusLoopWorker.initialize(); }); -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["src/module-get-ssl-status-worker.js"],"names":["moduleGetSSLStatusLoopWorker","timeOut","timeOutHandle","eventSource","channelId","$resultBlock","$","initialize","initializeAce","versionCompare","globalPBXVersion","startListenPushNotifications","restartWorker","window","clearTimeout","timeoutHandle","worker","api","url","Config","pbxUrl","on","method","successTest","PbxApi","onSuccess","response","data","result","length","show","editor","getSession","setValue","setTimeout","onFailure","UserMessage","showMultiString","message","hide","aceHeight","innerHeight","rowsCount","Math","round","load","css","ace","edit","NewMode","require","Mode","session","setMode","setTheme","resize","Form","dataChanged","setOptions","maxLines","showPrintMargin","showLineNumbers","lastEventIdKey","lastEventId","localStorage","getItem","subPath","EventSource","addEventListener","e","JSON","parse","console","debug","processStatusMessage","setItem","stageDetails","resultText","getValue","stage","messages","v1","v2","options","lexicographical","zeroExtend","v1parts","String","split","v2parts","isValidPart","x","test","every","NaN","push","map","Number","i","document","ready"],"mappings":"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","sourcesContent":["/*\n * MikoPBX - free phone system for small business\n * Copyright © 2017-2023 Alexey Portnov and Nikolay Beketov\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License along with this program.\n * If not, see <https://www.gnu.org/licenses/>.\n */\n\n/* global globalRootUrl, PbxApi, globalTranslate, UserMessage */\n\n/**\n * @module moduleGetSSLStatusLoopWorker\n */\nconst moduleGetSSLStatusLoopWorker = {\n\n    /**\n     * Time in milliseconds before fetching new status.\n     * @type {number}\n     */\n    timeOut: 10000,\n\n    /**\n     * The id of the timer function for status worker.\n     * @type {number}\n     */\n    timeOutHandle: 0,\n\n\n    /**.\n     * @type {EventSource}\n     */\n    eventSource: null,\n\n    /**\n     * The identifier for the PUB/SUB channel used to subscribe to module status updates.\n     * This ensures that the client is listening on the correct channel for relevant events.\n     */\n    channelId: 'module-get-ssl-pub',\n\n    /**\n     * jQuery selector for the result message element.\n     *\n     * This property stores a reference to the DOM element with the ID 'div-result' using jQuery.\n     */\n    $resultBlock: $('#div-result'),\n\n    /**\n     * Initializes the moduleGetSSLStatusLoopWorker module by setting up the connection to receive server-sent events.\n     */\n    initialize(){\n        moduleGetSSLStatusLoopWorker.initializeAce();\n        if (moduleGetSSLStatusLoopWorker.versionCompare(globalPBXVersion,'2024.2.30')>0){\n            moduleGetSSLStatusLoopWorker.startListenPushNotifications();\n        } else {\n            moduleGetSSLStatusLoopWorker.restartWorker();\n        }\n    },\n\n    /**\n     * Restarts the moduleGetSSLStatus worker.\n     */\n    restartWorker() {\n        window.clearTimeout(moduleGetSSLStatusLoopWorker.timeoutHandle);\n        moduleGetSSLStatusLoopWorker.worker();\n    },\n\n    /**\n     * Worker function for fetching status.\n     */\n    worker() {\n        $.api({\n            url: `${Config.pbxUrl}/pbxcore/api/modules/ModuleGetSsl/check-result`,\n            on: 'now',\n            method: 'GET',\n            successTest: PbxApi.successTest,\n            /**\n             * Handles the successful response of the 'check-result' API request.\n             * @param {object} response - The response object.\n             */\n            onSuccess: function (response) {\n                if (response.data.result.length > 0) {\n                    moduleGetSSLStatusLoopWorker.$resultBlock.show();\n                    moduleGetSSLStatusLoopWorker.editor.getSession().setValue(response.data.result);\n                }\n                moduleGetSSLStatusLoopWorker.timeoutHandle = window.setTimeout(\n                    moduleGetSSLStatusLoopWorker.worker,\n                    moduleGetSSLStatusLoopWorker.timeOut,\n                );\n            },\n            /**\n             * Handles the failure response of the 'get-available-ldap-users' API request.\n             * @param {object} response - The response object.\n             */\n            onFailure: function(response) {\n                UserMessage.showMultiString(response.message);\n                moduleGetSSLStatusLoopWorker.$resultBlock.hide();\n            },\n        })\n    },\n\n    /**\n     * Initializes the Ace editor instance.\n     * Sets up Ace editor with a monokai theme and custom options.\n     * Attaches change handler to the editor session.\n     */\n    initializeAce() {\n        const aceHeight = window.innerHeight - 480;\n        const rowsCount = Math.round(aceHeight / 16.3);\n        $(window).load(function () {\n            $('.application-code').css('min-height', `${aceHeight}px`);\n        });\n        moduleGetSSLStatusLoopWorker.editor = ace.edit('user-edit-config');\n        let NewMode = ace.require('ace/mode/julia').Mode;\n        moduleGetSSLStatusLoopWorker.editor.session.setMode(new NewMode());\n        moduleGetSSLStatusLoopWorker.editor.setTheme('ace/theme/monokai');\n        moduleGetSSLStatusLoopWorker.editor.resize();\n        moduleGetSSLStatusLoopWorker.editor.getSession().on('change', () => {\n            // Trigger change event to acknowledge the modification\n            Form.dataChanged();\n        });\n\n        moduleGetSSLStatusLoopWorker.editor.setOptions({\n            maxLines: rowsCount,\n            showPrintMargin: false,\n            showLineNumbers: false,\n        });\n    },\n    /**\n     * Establishes a connection to the server to start receiving real-time updates on module installation progress.\n     * Utilizes the EventSource API to listen for messages on a specified channel.\n     */\n    startListenPushNotifications() {\n        const lastEventIdKey = `${moduleGetSSLStatusLoopWorker.channelId}-lastEventId`;\n        let lastEventId = localStorage.getItem(lastEventIdKey);\n        const subPath = lastEventId ? `/pbxcore/api/nchan/sub/${moduleGetSSLStatusLoopWorker.channelId}?last_event_id=${lastEventId}` : `/pbxcore/api/nchan/sub/${moduleGetSSLStatusLoopWorker.channelId}`;\n        moduleGetSSLStatusLoopWorker.eventSource = new EventSource(subPath);\n\n        moduleGetSSLStatusLoopWorker.eventSource.addEventListener('message', e => {\n            const response = JSON.parse(e.data);\n            console.debug(response);\n            moduleGetSSLStatusLoopWorker.processStatusMessage(response);\n            localStorage.setItem(lastEventIdKey, e.lastEventId);\n        });\n    },\n\n    /**\n     *\n     * @param {Object} response - The data payload of the server-sent event, containing details about the installation stage and progress.\n     */\n    processStatusMessage(response){\n        if (response.stageDetails.result){\n            moduleGetSSLStatusLoopWorker.$resultBlock.show();\n            let resultText = moduleGetSSLStatusLoopWorker.editor.getSession().getValue();\n            if (response.stage === 'STAGE_1_GENERATE_CONFIG'){\n                resultText += '\\n' + response.stageDetails.data.result;\n            } else if(response.stage === 'STAGE_2_REQUEST_CERT') {\n                resultText += '\\n' + response.stageDetails.data.result;\n            } else if(response.stage === 'STAGE_3_PARSE_RESPONSE' && response.stageDetails.data.result.length > 0) {\n                resultText = response.stageDetails.data.result;\n            } else if(response.stage === 'STAGE_4_FINAL_RESULT' && response.stageDetails.data.result.length > 0 ) {\n                resultText = response.stageDetails.data.result;\n            }\n            moduleGetSSLStatusLoopWorker.editor.getSession().setValue(resultText);\n        } else {\n            UserMessage.showMultiString(response.stageDetails.messages);\n            moduleGetSSLStatusLoopWorker.$resultBlock.hide();\n        }\n    },\n\n    /**\n     * Compare versions of modules.\n     * @param {string} v1 - The first version to compare.\n     * @param {string} v2 - The second version to compare.\n     * @param {object} [options] - Optional configuration options.\n     * @param {boolean} [options.lexicographical] - Whether to perform lexicographical comparison (default: false).\n     * @param {boolean} [options.zeroExtend] - Weather to zero-extend the shorter version (default: false).\n     * @returns {number} - A number indicating the comparison result: 0 if versions are equal, 1 if v1 is greater, -1 if v2 is greater, or NaN if the versions are invalid.\n     */\n    versionCompare(v1, v2, options) {\n        const lexicographical = options && options.lexicographical;\n        const zeroExtend = options && options.zeroExtend;\n        let v1parts = String(v1).split('.');\n        let v2parts = String(v2).split('.');\n\n        function isValidPart(x) {\n            return (lexicographical ? /^\\d+[A-Za-z]*$/ : /^\\d+$/).test(x);\n        }\n\n        if (!v1parts.every(isValidPart) || !v2parts.every(isValidPart)) {\n            return NaN;\n        }\n\n        if (zeroExtend) {\n            while (v1parts.length < v2parts.length) v1parts.push('0');\n            while (v2parts.length < v1parts.length) v2parts.push('0');\n        }\n\n        if (!lexicographical) {\n            v1parts = v1parts.map(Number);\n            v2parts = v2parts.map(Number);\n        }\n\n        for (let i = 0; i < v1parts.length; i += 1) {\n            if (v2parts.length === i) {\n                return 1;\n            }\n            if (v1parts[i] === v2parts[i]) {\n                //\n            } else if (v1parts[i] > v2parts[i]) {\n                return 1;\n            } else {\n                return -1;\n            }\n        }\n\n        if (v1parts.length !== v2parts.length) {\n            return -1;\n        }\n\n        return 0;\n    },\n\n};\n\n// Initializes the moduleGetSSLStatusLoopWorker module when the DOM is fully loaded.\n$(document).ready(() => {\n    moduleGetSSLStatusLoopWorker.initialize();\n});"]} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["src/module-get-ssl-status-worker.js"],"names":["moduleGetSSLStatusLoopWorker","timeOut","timeOutHandle","eventSource","channelId","$resultBlock","$","initialize","initializeAce","loadLastLog","versionCompare","globalPBXVersion","startListenPushNotifications","restartWorker","api","url","Config","pbxUrl","on","method","successTest","PbxApi","onSuccess","response","data","result","length","show","editor","getSession","setValue","onFailure","window","clearTimeout","timeoutHandle","worker","setTimeout","UserMessage","showMultiString","message","hide","aceHeight","innerHeight","rowsCount","Math","round","load","css","ace","edit","NewMode","require","Mode","session","setMode","setTheme","resize","Form","dataChanged","setOptions","maxLines","showPrintMargin","showLineNumbers","lastEventIdKey","lastEventId","localStorage","getItem","subPath","EventSource","addEventListener","e","JSON","parse","console","debug","processStatusMessage","setItem","stageDetails","resultText","getValue","stage","messages","v1","v2","options","lexicographical","zeroExtend","v1parts","String","split","v2parts","isValidPart","x","test","every","NaN","push","map","Number","i","document","ready"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,IAAMA,4BAA4B,GAAG;AAEjC;AACJ;AACA;AACA;AACIC,EAAAA,OAAO,EAAE,KANwB;;AAQjC;AACJ;AACA;AACA;AACIC,EAAAA,aAAa,EAAE,CAZkB;;AAejC;AACJ;AACA;AACIC,EAAAA,WAAW,EAAE,IAlBoB;;AAoBjC;AACJ;AACA;AACA;AACIC,EAAAA,SAAS,EAAE,oBAxBsB;;AA0BjC;AACJ;AACA;AACA;AACA;AACIC,EAAAA,YAAY,EAAEC,CAAC,CAAC,aAAD,CA/BkB;;AAiCjC;AACJ;AACA;AACIC,EAAAA,UApCiC,wBAoCrB;AACRP,IAAAA,4BAA4B,CAACQ,aAA7B;AACAR,IAAAA,4BAA4B,CAACS,WAA7B;;AACA,QAAIT,4BAA4B,CAACU,cAA7B,CAA4CC,gBAA5C,EAA6D,WAA7D,IAA0E,CAA9E,EAAgF;AAC5EX,MAAAA,4BAA4B,CAACY,4BAA7B;AACH,KAFD,MAEO;AACHZ,MAAAA,4BAA4B,CAACa,aAA7B;AACH;AACJ,GA5CgC;;AA8CjC;AACJ;AACA;AACIJ,EAAAA,WAjDiC,yBAiDnB;AACVH,IAAAA,CAAC,CAACQ,GAAF,CAAM;AACFC,MAAAA,GAAG,YAAKC,MAAM,CAACC,MAAZ,mDADD;AAEFC,MAAAA,EAAE,EAAE,KAFF;AAGFC,MAAAA,MAAM,EAAE,KAHN;AAIFC,MAAAA,WAAW,EAAEC,MAAM,CAACD,WAJlB;AAKFE,MAAAA,SAAS,EAAE,mBAAUC,QAAV,EAAoB;AAC3B,YAAIA,QAAQ,CAACC,IAAT,CAAcC,MAAd,IAAwBF,QAAQ,CAACC,IAAT,CAAcC,MAAd,CAAqBC,MAArB,GAA8B,CAA1D,EAA6D;AACzD1B,UAAAA,4BAA4B,CAACK,YAA7B,CAA0CsB,IAA1C;AACA3B,UAAAA,4BAA4B,CAAC4B,MAA7B,CAAoCC,UAApC,GAAiDC,QAAjD,CAA0DP,QAAQ,CAACC,IAAT,CAAcC,MAAxE;AACH;AACJ,OAVC;AAWFM,MAAAA,SAAS,EAAE,qBAAW,CAClB;AACH;AAbC,KAAN;AAeH,GAjEgC;;AAmEjC;AACJ;AACA;AACIlB,EAAAA,aAtEiC,2BAsEjB;AACZmB,IAAAA,MAAM,CAACC,YAAP,CAAoBjC,4BAA4B,CAACkC,aAAjD;AACAlC,IAAAA,4BAA4B,CAACmC,MAA7B;AACH,GAzEgC;;AA2EjC;AACJ;AACA;AACIA,EAAAA,MA9EiC,oBA8ExB;AACL7B,IAAAA,CAAC,CAACQ,GAAF,CAAM;AACFC,MAAAA,GAAG,YAAKC,MAAM,CAACC,MAAZ,mDADD;AAEFC,MAAAA,EAAE,EAAE,KAFF;AAGFC,MAAAA,MAAM,EAAE,KAHN;AAIFC,MAAAA,WAAW,EAAEC,MAAM,CAACD,WAJlB;;AAKF;AACZ;AACA;AACA;AACYE,MAAAA,SAAS,EAAE,mBAAUC,QAAV,EAAoB;AAC3B,YAAIA,QAAQ,CAACC,IAAT,CAAcC,MAAd,CAAqBC,MAArB,GAA8B,CAAlC,EAAqC;AACjC1B,UAAAA,4BAA4B,CAACK,YAA7B,CAA0CsB,IAA1C;AACA3B,UAAAA,4BAA4B,CAAC4B,MAA7B,CAAoCC,UAApC,GAAiDC,QAAjD,CAA0DP,QAAQ,CAACC,IAAT,CAAcC,MAAxE;AACH;;AACDzB,QAAAA,4BAA4B,CAACkC,aAA7B,GAA6CF,MAAM,CAACI,UAAP,CACzCpC,4BAA4B,CAACmC,MADY,EAEzCnC,4BAA4B,CAACC,OAFY,CAA7C;AAIH,OAlBC;;AAmBF;AACZ;AACA;AACA;AACY8B,MAAAA,SAAS,EAAE,mBAASR,QAAT,EAAmB;AAC1Bc,QAAAA,WAAW,CAACC,eAAZ,CAA4Bf,QAAQ,CAACgB,OAArC;AACAvC,QAAAA,4BAA4B,CAACK,YAA7B,CAA0CmC,IAA1C;AACH;AA1BC,KAAN;AA4BH,GA3GgC;;AA6GjC;AACJ;AACA;AACA;AACA;AACIhC,EAAAA,aAlHiC,2BAkHjB;AACZ,QAAMiC,SAAS,GAAGT,MAAM,CAACU,WAAP,GAAqB,GAAvC;AACA,QAAMC,SAAS,GAAGC,IAAI,CAACC,KAAL,CAAWJ,SAAS,GAAG,IAAvB,CAAlB;AACAnC,IAAAA,CAAC,CAAC0B,MAAD,CAAD,CAAUc,IAAV,CAAe,YAAY;AACvBxC,MAAAA,CAAC,CAAC,mBAAD,CAAD,CAAuByC,GAAvB,CAA2B,YAA3B,YAA4CN,SAA5C;AACH,KAFD;AAGAzC,IAAAA,4BAA4B,CAAC4B,MAA7B,GAAsCoB,GAAG,CAACC,IAAJ,CAAS,kBAAT,CAAtC;;AACA,QAAIC,OAAO,GAAGF,GAAG,CAACG,OAAJ,CAAY,gBAAZ,EAA8BC,IAA5C;;AACApD,IAAAA,4BAA4B,CAAC4B,MAA7B,CAAoCyB,OAApC,CAA4CC,OAA5C,CAAoD,IAAIJ,OAAJ,EAApD;AACAlD,IAAAA,4BAA4B,CAAC4B,MAA7B,CAAoC2B,QAApC,CAA6C,mBAA7C;AACAvD,IAAAA,4BAA4B,CAAC4B,MAA7B,CAAoC4B,MAApC;AACAxD,IAAAA,4BAA4B,CAAC4B,MAA7B,CAAoCC,UAApC,GAAiDX,EAAjD,CAAoD,QAApD,EAA8D,YAAM;AAChE;AACAuC,MAAAA,IAAI,CAACC,WAAL;AACH,KAHD;AAKA1D,IAAAA,4BAA4B,CAAC4B,MAA7B,CAAoC+B,UAApC,CAA+C;AAC3CC,MAAAA,QAAQ,EAAEjB,SADiC;AAE3CkB,MAAAA,eAAe,EAAE,KAF0B;AAG3CC,MAAAA,eAAe,EAAE;AAH0B,KAA/C;AAKH,GAvIgC;;AAwIjC;AACJ;AACA;AACA;AACIlD,EAAAA,4BA5IiC,0CA4IF;AAC3B,QAAMmD,cAAc,aAAM/D,4BAA4B,CAACI,SAAnC,iBAApB;AACA,QAAI4D,WAAW,GAAGC,YAAY,CAACC,OAAb,CAAqBH,cAArB,CAAlB;AACA,QAAMI,OAAO,GAAGH,WAAW,oCAA6BhE,4BAA4B,CAACI,SAA1D,4BAAqF4D,WAArF,qCAA+HhE,4BAA4B,CAACI,SAA5J,CAA3B;AACAJ,IAAAA,4BAA4B,CAACG,WAA7B,GAA2C,IAAIiE,WAAJ,CAAgBD,OAAhB,CAA3C;AAEAnE,IAAAA,4BAA4B,CAACG,WAA7B,CAAyCkE,gBAAzC,CAA0D,SAA1D,EAAqE,UAAAC,CAAC,EAAI;AACtE,UAAM/C,QAAQ,GAAGgD,IAAI,CAACC,KAAL,CAAWF,CAAC,CAAC9C,IAAb,CAAjB;AACAiD,MAAAA,OAAO,CAACC,KAAR,CAAcnD,QAAd;AACAvB,MAAAA,4BAA4B,CAAC2E,oBAA7B,CAAkDpD,QAAlD;AACA0C,MAAAA,YAAY,CAACW,OAAb,CAAqBb,cAArB,EAAqCO,CAAC,CAACN,WAAvC;AACH,KALD;AAMH,GAxJgC;;AA0JjC;AACJ;AACA;AACA;AACIW,EAAAA,oBA9JiC,gCA8JZpD,QA9JY,EA8JH;AAC1B,QAAIA,QAAQ,CAACsD,YAAT,CAAsBpD,MAA1B,EAAiC;AAC7BzB,MAAAA,4BAA4B,CAACK,YAA7B,CAA0CsB,IAA1C;AACA,UAAImD,UAAU,GAAG9E,4BAA4B,CAAC4B,MAA7B,CAAoCC,UAApC,GAAiDkD,QAAjD,EAAjB;;AACA,UAAIxD,QAAQ,CAACyD,KAAT,KAAmB,yBAAvB,EAAiD;AAC7CF,QAAAA,UAAU,IAAI,OAAOvD,QAAQ,CAACsD,YAAT,CAAsBrD,IAAtB,CAA2BC,MAAhD;AACH,OAFD,MAEO,IAAGF,QAAQ,CAACyD,KAAT,KAAmB,sBAAtB,EAA8C;AACjDF,QAAAA,UAAU,IAAI,OAAOvD,QAAQ,CAACsD,YAAT,CAAsBrD,IAAtB,CAA2BC,MAAhD;AACH,OAFM,MAEA,IAAGF,QAAQ,CAACyD,KAAT,KAAmB,wBAAnB,IAA+CzD,QAAQ,CAACsD,YAAT,CAAsBrD,IAAtB,CAA2BC,MAA3B,CAAkCC,MAAlC,GAA2C,CAA7F,EAAgG;AACnGoD,QAAAA,UAAU,GAAGvD,QAAQ,CAACsD,YAAT,CAAsBrD,IAAtB,CAA2BC,MAAxC;AACH,OAFM,MAEA,IAAGF,QAAQ,CAACyD,KAAT,KAAmB,sBAAnB,IAA6CzD,QAAQ,CAACsD,YAAT,CAAsBrD,IAAtB,CAA2BC,MAA3B,CAAkCC,MAAlC,GAA2C,CAA3F,EAA+F;AAClGoD,QAAAA,UAAU,GAAGvD,QAAQ,CAACsD,YAAT,CAAsBrD,IAAtB,CAA2BC,MAAxC;AACH;;AACDzB,MAAAA,4BAA4B,CAAC4B,MAA7B,CAAoCC,UAApC,GAAiDC,QAAjD,CAA0DgD,UAA1D;AACH,KAbD,MAaO;AACHzC,MAAAA,WAAW,CAACC,eAAZ,CAA4Bf,QAAQ,CAACsD,YAAT,CAAsBI,QAAlD;AACAjF,MAAAA,4BAA4B,CAACK,YAA7B,CAA0CmC,IAA1C;AACH;AACJ,GAhLgC;;AAkLjC;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACI9B,EAAAA,cA3LiC,0BA2LlBwE,EA3LkB,EA2LdC,EA3Lc,EA2LVC,OA3LU,EA2LD;AAC5B,QAAMC,eAAe,GAAGD,OAAO,IAAIA,OAAO,CAACC,eAA3C;AACA,QAAMC,UAAU,GAAGF,OAAO,IAAIA,OAAO,CAACE,UAAtC;AACA,QAAIC,OAAO,GAAGC,MAAM,CAACN,EAAD,CAAN,CAAWO,KAAX,CAAiB,GAAjB,CAAd;AACA,QAAIC,OAAO,GAAGF,MAAM,CAACL,EAAD,CAAN,CAAWM,KAAX,CAAiB,GAAjB,CAAd;;AAEA,aAASE,WAAT,CAAqBC,CAArB,EAAwB;AACpB,aAAO,CAACP,eAAe,GAAG,gBAAH,GAAsB,OAAtC,EAA+CQ,IAA/C,CAAoDD,CAApD,CAAP;AACH;;AAED,QAAI,CAACL,OAAO,CAACO,KAAR,CAAcH,WAAd,CAAD,IAA+B,CAACD,OAAO,CAACI,KAAR,CAAcH,WAAd,CAApC,EAAgE;AAC5D,aAAOI,GAAP;AACH;;AAED,QAAIT,UAAJ,EAAgB;AACZ,aAAOC,OAAO,CAAC7D,MAAR,GAAiBgE,OAAO,CAAChE,MAAhC;AAAwC6D,QAAAA,OAAO,CAACS,IAAR,CAAa,GAAb;AAAxC;;AACA,aAAON,OAAO,CAAChE,MAAR,GAAiB6D,OAAO,CAAC7D,MAAhC;AAAwCgE,QAAAA,OAAO,CAACM,IAAR,CAAa,GAAb;AAAxC;AACH;;AAED,QAAI,CAACX,eAAL,EAAsB;AAClBE,MAAAA,OAAO,GAAGA,OAAO,CAACU,GAAR,CAAYC,MAAZ,CAAV;AACAR,MAAAA,OAAO,GAAGA,OAAO,CAACO,GAAR,CAAYC,MAAZ,CAAV;AACH;;AAED,SAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGZ,OAAO,CAAC7D,MAA5B,EAAoCyE,CAAC,IAAI,CAAzC,EAA4C;AACxC,UAAIT,OAAO,CAAChE,MAAR,KAAmByE,CAAvB,EAA0B;AACtB,eAAO,CAAP;AACH;;AACD,UAAIZ,OAAO,CAACY,CAAD,CAAP,KAAeT,OAAO,CAACS,CAAD,CAA1B,EAA+B,CAC3B;AACH,OAFD,MAEO,IAAIZ,OAAO,CAACY,CAAD,CAAP,GAAaT,OAAO,CAACS,CAAD,CAAxB,EAA6B;AAChC,eAAO,CAAP;AACH,OAFM,MAEA;AACH,eAAO,CAAC,CAAR;AACH;AACJ;;AAED,QAAIZ,OAAO,CAAC7D,MAAR,KAAmBgE,OAAO,CAAChE,MAA/B,EAAuC;AACnC,aAAO,CAAC,CAAR;AACH;;AAED,WAAO,CAAP;AACH;AArOgC,CAArC,C,CAyOA;;AACApB,CAAC,CAAC8F,QAAD,CAAD,CAAYC,KAAZ,CAAkB,YAAM;AACpBrG,EAAAA,4BAA4B,CAACO,UAA7B;AACH,CAFD","sourcesContent":["/*\n * MikoPBX - free phone system for small business\n * Copyright © 2017-2023 Alexey Portnov and Nikolay Beketov\n *\n * This program is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License along with this program.\n * If not, see <https://www.gnu.org/licenses/>.\n */\n\n/* global globalRootUrl, PbxApi, globalTranslate, UserMessage */\n\n/**\n * @module moduleGetSSLStatusLoopWorker\n */\nconst moduleGetSSLStatusLoopWorker = {\n\n    /**\n     * Time in milliseconds before fetching new status.\n     * @type {number}\n     */\n    timeOut: 10000,\n\n    /**\n     * The id of the timer function for status worker.\n     * @type {number}\n     */\n    timeOutHandle: 0,\n\n\n    /**.\n     * @type {EventSource}\n     */\n    eventSource: null,\n\n    /**\n     * The identifier for the PUB/SUB channel used to subscribe to module status updates.\n     * This ensures that the client is listening on the correct channel for relevant events.\n     */\n    channelId: 'module-get-ssl-pub',\n\n    /**\n     * jQuery selector for the result message element.\n     *\n     * This property stores a reference to the DOM element with the ID 'div-result' using jQuery.\n     */\n    $resultBlock: $('#div-result'),\n\n    /**\n     * Initializes the moduleGetSSLStatusLoopWorker module by setting up the connection to receive server-sent events.\n     */\n    initialize(){\n        moduleGetSSLStatusLoopWorker.initializeAce();\n        moduleGetSSLStatusLoopWorker.loadLastLog();\n        if (moduleGetSSLStatusLoopWorker.versionCompare(globalPBXVersion,'2024.2.30')>0){\n            moduleGetSSLStatusLoopWorker.startListenPushNotifications();\n        } else {\n            moduleGetSSLStatusLoopWorker.restartWorker();\n        }\n    },\n\n    /**\n     * Loads the last log file content into the ACE editor on page load.\n     */\n    loadLastLog() {\n        $.api({\n            url: `${Config.pbxUrl}/pbxcore/api/modules/ModuleGetSsl/check-result`,\n            on: 'now',\n            method: 'GET',\n            successTest: PbxApi.successTest,\n            onSuccess: function (response) {\n                if (response.data.result && response.data.result.length > 0) {\n                    moduleGetSSLStatusLoopWorker.$resultBlock.show();\n                    moduleGetSSLStatusLoopWorker.editor.getSession().setValue(response.data.result);\n                }\n            },\n            onFailure: function() {\n                // Silently ignore - no log to show\n            },\n        })\n    },\n\n    /**\n     * Restarts the moduleGetSSLStatus worker.\n     */\n    restartWorker() {\n        window.clearTimeout(moduleGetSSLStatusLoopWorker.timeoutHandle);\n        moduleGetSSLStatusLoopWorker.worker();\n    },\n\n    /**\n     * Worker function for fetching status.\n     */\n    worker() {\n        $.api({\n            url: `${Config.pbxUrl}/pbxcore/api/modules/ModuleGetSsl/check-result`,\n            on: 'now',\n            method: 'GET',\n            successTest: PbxApi.successTest,\n            /**\n             * Handles the successful response of the 'check-result' API request.\n             * @param {object} response - The response object.\n             */\n            onSuccess: function (response) {\n                if (response.data.result.length > 0) {\n                    moduleGetSSLStatusLoopWorker.$resultBlock.show();\n                    moduleGetSSLStatusLoopWorker.editor.getSession().setValue(response.data.result);\n                }\n                moduleGetSSLStatusLoopWorker.timeoutHandle = window.setTimeout(\n                    moduleGetSSLStatusLoopWorker.worker,\n                    moduleGetSSLStatusLoopWorker.timeOut,\n                );\n            },\n            /**\n             * Handles the failure response of the 'get-available-ldap-users' API request.\n             * @param {object} response - The response object.\n             */\n            onFailure: function(response) {\n                UserMessage.showMultiString(response.message);\n                moduleGetSSLStatusLoopWorker.$resultBlock.hide();\n            },\n        })\n    },\n\n    /**\n     * Initializes the Ace editor instance.\n     * Sets up Ace editor with a monokai theme and custom options.\n     * Attaches change handler to the editor session.\n     */\n    initializeAce() {\n        const aceHeight = window.innerHeight - 480;\n        const rowsCount = Math.round(aceHeight / 16.3);\n        $(window).load(function () {\n            $('.application-code').css('min-height', `${aceHeight}px`);\n        });\n        moduleGetSSLStatusLoopWorker.editor = ace.edit('user-edit-config');\n        let NewMode = ace.require('ace/mode/julia').Mode;\n        moduleGetSSLStatusLoopWorker.editor.session.setMode(new NewMode());\n        moduleGetSSLStatusLoopWorker.editor.setTheme('ace/theme/monokai');\n        moduleGetSSLStatusLoopWorker.editor.resize();\n        moduleGetSSLStatusLoopWorker.editor.getSession().on('change', () => {\n            // Trigger change event to acknowledge the modification\n            Form.dataChanged();\n        });\n\n        moduleGetSSLStatusLoopWorker.editor.setOptions({\n            maxLines: rowsCount,\n            showPrintMargin: false,\n            showLineNumbers: false,\n        });\n    },\n    /**\n     * Establishes a connection to the server to start receiving real-time updates on module installation progress.\n     * Utilizes the EventSource API to listen for messages on a specified channel.\n     */\n    startListenPushNotifications() {\n        const lastEventIdKey = `${moduleGetSSLStatusLoopWorker.channelId}-lastEventId`;\n        let lastEventId = localStorage.getItem(lastEventIdKey);\n        const subPath = lastEventId ? `/pbxcore/api/nchan/sub/${moduleGetSSLStatusLoopWorker.channelId}?last_event_id=${lastEventId}` : `/pbxcore/api/nchan/sub/${moduleGetSSLStatusLoopWorker.channelId}`;\n        moduleGetSSLStatusLoopWorker.eventSource = new EventSource(subPath);\n\n        moduleGetSSLStatusLoopWorker.eventSource.addEventListener('message', e => {\n            const response = JSON.parse(e.data);\n            console.debug(response);\n            moduleGetSSLStatusLoopWorker.processStatusMessage(response);\n            localStorage.setItem(lastEventIdKey, e.lastEventId);\n        });\n    },\n\n    /**\n     *\n     * @param {Object} response - The data payload of the server-sent event, containing details about the installation stage and progress.\n     */\n    processStatusMessage(response){\n        if (response.stageDetails.result){\n            moduleGetSSLStatusLoopWorker.$resultBlock.show();\n            let resultText = moduleGetSSLStatusLoopWorker.editor.getSession().getValue();\n            if (response.stage === 'STAGE_1_GENERATE_CONFIG'){\n                resultText += '\\n' + response.stageDetails.data.result;\n            } else if(response.stage === 'STAGE_2_REQUEST_CERT') {\n                resultText += '\\n' + response.stageDetails.data.result;\n            } else if(response.stage === 'STAGE_3_PARSE_RESPONSE' && response.stageDetails.data.result.length > 0) {\n                resultText = response.stageDetails.data.result;\n            } else if(response.stage === 'STAGE_4_FINAL_RESULT' && response.stageDetails.data.result.length > 0 ) {\n                resultText = response.stageDetails.data.result;\n            }\n            moduleGetSSLStatusLoopWorker.editor.getSession().setValue(resultText);\n        } else {\n            UserMessage.showMultiString(response.stageDetails.messages);\n            moduleGetSSLStatusLoopWorker.$resultBlock.hide();\n        }\n    },\n\n    /**\n     * Compare versions of modules.\n     * @param {string} v1 - The first version to compare.\n     * @param {string} v2 - The second version to compare.\n     * @param {object} [options] - Optional configuration options.\n     * @param {boolean} [options.lexicographical] - Whether to perform lexicographical comparison (default: false).\n     * @param {boolean} [options.zeroExtend] - Weather to zero-extend the shorter version (default: false).\n     * @returns {number} - A number indicating the comparison result: 0 if versions are equal, 1 if v1 is greater, -1 if v2 is greater, or NaN if the versions are invalid.\n     */\n    versionCompare(v1, v2, options) {\n        const lexicographical = options && options.lexicographical;\n        const zeroExtend = options && options.zeroExtend;\n        let v1parts = String(v1).split('.');\n        let v2parts = String(v2).split('.');\n\n        function isValidPart(x) {\n            return (lexicographical ? /^\\d+[A-Za-z]*$/ : /^\\d+$/).test(x);\n        }\n\n        if (!v1parts.every(isValidPart) || !v2parts.every(isValidPart)) {\n            return NaN;\n        }\n\n        if (zeroExtend) {\n            while (v1parts.length < v2parts.length) v1parts.push('0');\n            while (v2parts.length < v1parts.length) v2parts.push('0');\n        }\n\n        if (!lexicographical) {\n            v1parts = v1parts.map(Number);\n            v2parts = v2parts.map(Number);\n        }\n\n        for (let i = 0; i < v1parts.length; i += 1) {\n            if (v2parts.length === i) {\n                return 1;\n            }\n            if (v1parts[i] === v2parts[i]) {\n                //\n            } else if (v1parts[i] > v2parts[i]) {\n                return 1;\n            } else {\n                return -1;\n            }\n        }\n\n        if (v1parts.length !== v2parts.length) {\n            return -1;\n        }\n\n        return 0;\n    },\n\n};\n\n// Initializes the moduleGetSSLStatusLoopWorker module when the DOM is fully loaded.\n$(document).ready(() => {\n    moduleGetSSLStatusLoopWorker.initialize();\n});"]} \ No newline at end of file diff --git a/public/assets/js/src/module-get-ssl-index.js b/public/assets/js/src/module-get-ssl-index.js index 72c6b17..cb9b556 100644 --- a/public/assets/js/src/module-get-ssl-index.js +++ b/public/assets/js/src/module-get-ssl-index.js @@ -12,6 +12,7 @@ const ModuleGetSsl = { $checkBoxes: $('#' + idForm + ' .ui.checkbox'), $disabilityFields: $('#' + idForm + ' .disability'), $statusToggle: $('#module-status-toggle'), + $submitButton: $('#submitbutton'), $moduleStatus: $('#status'), $intervalId: undefined, // To manage the interval for SSL status check @@ -61,6 +62,9 @@ const ModuleGetSsl = { return xhr; }, beforeSend(settings) { + ModuleGetSsl.$submitButton.addClass('loading disabled'); + moduleGetSSLStatusLoopWorker.$resultBlock.show(); + moduleGetSSLStatusLoopWorker.editor.getSession().setValue(''); return settings; }, successTest: PbxApi.successTest, @@ -69,13 +73,14 @@ const ModuleGetSsl = { * @param {object} response - The response object. */ onSuccess: function (response) { - moduleGetSSLStatusLoopWorker.editor.getSession().setValue(''); + ModuleGetSsl.$submitButton.removeClass('loading disabled'); }, /** - * Handles the failure response of the 'get-available-ldap-users' API request. + * Handles the failure response of the 'get-cert' API request. * @param {object} response - The response object. */ onFailure: function(response) { + ModuleGetSsl.$submitButton.removeClass('loading disabled'); UserMessage.showMultiString(response.message); moduleGetSSLStatusLoopWorker.$resultBlock.hide(); }, diff --git a/public/assets/js/src/module-get-ssl-status-worker.js b/public/assets/js/src/module-get-ssl-status-worker.js index ed08463..9ef7a3a 100644 --- a/public/assets/js/src/module-get-ssl-status-worker.js +++ b/public/assets/js/src/module-get-ssl-status-worker.js @@ -59,6 +59,7 @@ const moduleGetSSLStatusLoopWorker = { */ initialize(){ moduleGetSSLStatusLoopWorker.initializeAce(); + moduleGetSSLStatusLoopWorker.loadLastLog(); if (moduleGetSSLStatusLoopWorker.versionCompare(globalPBXVersion,'2024.2.30')>0){ moduleGetSSLStatusLoopWorker.startListenPushNotifications(); } else { @@ -66,6 +67,27 @@ const moduleGetSSLStatusLoopWorker = { } }, + /** + * Loads the last log file content into the ACE editor on page load. + */ + loadLastLog() { + $.api({ + url: `${Config.pbxUrl}/pbxcore/api/modules/ModuleGetSsl/check-result`, + on: 'now', + method: 'GET', + successTest: PbxApi.successTest, + onSuccess: function (response) { + if (response.data.result && response.data.result.length > 0) { + moduleGetSSLStatusLoopWorker.$resultBlock.show(); + moduleGetSSLStatusLoopWorker.editor.getSession().setValue(response.data.result); + } + }, + onFailure: function() { + // Silently ignore - no log to show + }, + }) + }, + /** * Restarts the moduleGetSSLStatus worker. */