123-lang 2.1.11 → 2.1.13

package/source/Customization/electron/electron-configuration/messages.js

@@ -0,0 +1,41 @@
+const languages = ['en', 'ru', 'uk'];
+const messages = {
+	en: {
+		'Update is available': 'Update is available',
+		'Now application will start updating and restart.': 'Now application will start updating and restart.',
+		Ok: 'Ok',
+		Later: 'Later',
+		'There was a problem updating the application': 'There was a problem updating the application',
+		Cancel: 'Cancel',
+		'Download manual': 'Download manual',
+		'Download installer': 'Download installer',
+	},
+	ru: {
+		'Update is available': 'Доступно обновление',
+		'Now application will start updating and restart.': 'Сейчас будет произведено обновление и перезапуск приложения.',
+		Ok: 'Ок',
+		Later: 'Позже',
+		'There was a problem updating the application': 'Возникла проблема с обновлением приложения',
+		Cancel: 'Закрыть',
+		'Download manual': 'Скачать инструкцию',
+		'Download installer': 'Скачать установщик',
+	},
+	uk: {
+		'Update is available': 'Доступне оновлення',
+		'Now application will start updating and restart.': 'Зараз буде виконано оновлення та перезавантаження додатку.',
+		Ok: 'Ок',
+		Later: 'Пiзнiше',
+		'There was a problem updating the application': 'Під час оновлення програми виникла проблема',
+		Cancel: 'Закрити',
+		'Download manual': 'Завантажити інструкцію',
+		'Download installer': 'Завантажити інсталятор',
+	},
+};
+
+const t = (translation = '', lang = 'en') => messages[lang][translation];
+
+module.exports = {
+	languages,
+	messages,
+	t,
+};

package/source/Customization/electron/electron-configuration/modules/WhiteLabelUpdater.js

@@ -0,0 +1,248 @@
+const fs = require('fs');
+const fsPromises = require('fs/promises');
+const path = require('path');
+const crypto = require('crypto');
+const { app, nativeImage, shell } = require('electron');
+const log = require('electron-log');
+const { localStorage } = require('electron-browser-storage');
+const os = require('os');
+
+const { whiteLabelUpdaterConfiguration, config } = require('../configuration');
+
+class WhiteLabelUpdater {
+	constructor() {
+		this.cachePath = path.join(
+			app.getPath(whiteLabelUpdaterConfiguration?.systemDir),
+			whiteLabelUpdaterConfiguration?.cacheDirName
+		);
+		this.ensureDir();
+	}
+
+	ensureDir() {
+		if (!fs.existsSync(this.cachePath)) {
+			fs.mkdirSync(this.cachePath, { recursive: true });
+		}
+	}
+
+	getFilePath(serverUrl) {
+		const hash = crypto.createHash('md5').update(serverUrl).digest('hex');
+		return path.join(
+			this.cachePath,
+			`${hash}.${whiteLabelUpdaterConfiguration?.fileExtension?.json}`
+		);
+	}
+
+	async safeWrite(filePath, data) {
+		const tempPath = `${filePath}.${whiteLabelUpdaterConfiguration?.fileExtension?.tmp}`;
+		await fsPromises.writeFile(tempPath, JSON.stringify(data), 'utf8');
+		await fsPromises.rename(tempPath, filePath);
+	}
+
+	async fetchWithTimeout(url) {
+		const controller = new AbortController();
+		const id = setTimeout(
+			() => controller.abort(),
+			whiteLabelUpdaterConfiguration?.timeOutMs
+		);
+		try {
+			const response = await fetch(url, { signal: controller.signal });
+			clearTimeout(id);
+			return response;
+		} catch (error) {
+			clearTimeout(id);
+			throw error;
+		}
+	}
+
+	async getWhiteLabelData(serverUrl) {
+		if (!serverUrl) return whiteLabelUpdaterConfiguration?.defaultResult;
+
+		const normalizedUrl = serverUrl.replace(/\/$/, '');
+		const cacheFilePath = this.getFilePath(normalizedUrl);
+
+		let localCache = null;
+		try {
+			const raw = await fsPromises.readFile(cacheFilePath, 'utf8');
+			localCache = JSON.parse(raw);
+		} catch (e) {
+			log.error('[WL] There is something wrong with the cache');
+		}
+		let remoteConfig = null;
+		try {
+			const res = await this.fetchWithTimeout(
+				`${normalizedUrl}${whiteLabelUpdaterConfiguration?.internalAssetsDir}${whiteLabelUpdaterConfiguration?.configFileName}`
+			);
+			if (res.ok) {
+				remoteConfig = await res.json();
+			}
+		} catch (e) {
+			log.error('[WL] Server unavailable, using cache fallback.');
+		}
+
+		if (!remoteConfig) {
+			return localCache
+				? localCache.data
+				: whiteLabelUpdaterConfiguration?.defaultResult;
+		}
+
+		if (
+			localCache &&
+			localCache.data.version === remoteConfig.version &&
+			localCache.data.assets
+		) {
+			log.info('[WL] Version match. Serving from cache.');
+
+			return { ...remoteConfig, assets: localCache.data.assets };
+		}
+
+		log.info('[WL] New version detected or no cache. Downloading assets...');
+
+		if (remoteConfig.enabled === false) {
+			const cleanData = {
+				...whiteLabelUpdaterConfiguration?.defaultResult,
+				...remoteConfig,
+				assets: { ...whiteLabelUpdaterConfiguration?.defaultResult?.assets },
+			};
+			await this.safeWrite(cacheFilePath, {
+				timestamp: Date.now(),
+				data: cleanData,
+			});
+			return cleanData;
+		}
+		const assets = { ...whiteLabelUpdaterConfiguration?.defaultResult?.assets };
+
+		await Promise.all(
+			whiteLabelUpdaterConfiguration?.assetFiles?.map(async file => {
+				try {
+					const res = await this.fetchWithTimeout(
+						`${normalizedUrl}${whiteLabelUpdaterConfiguration?.internalAssetsDir}${file}`
+					);
+					if (res.ok) {
+						const buf = await res.arrayBuffer();
+						const buffer = Buffer.from(buf);
+						const ext = path.extname(file).toLowerCase().replace('.', '');
+
+						let mime;
+						switch (ext) {
+							case 'svg':
+								mime = 'image/svg+xml';
+								break;
+							case 'ico':
+								mime = 'image/x-icon';
+								break;
+							case 'png':
+								mime = 'image/png';
+								break;
+							case 'jpg':
+							case 'jpeg':
+								mime = 'image/jpeg';
+								break;
+							default:
+								mime = `image/${ext}`;
+						}
+
+						// Ensure the base64 string is clean
+						const b64 = buffer.toString('base64');
+						assets[file] = `data:${mime};base64,${b64}`;
+					}
+				} catch (err) {
+					log.error(`[WL] Failed to download asset: ${file}`);
+				}
+			})
+		);
+
+		const freshData = {
+			...whiteLabelUpdaterConfiguration?.defaultResult,
+			...remoteConfig,
+			assets: assets,
+		};
+
+		await this.safeWrite(cacheFilePath, {
+			timestamp: Date.now(),
+			data: freshData,
+		});
+
+		return freshData;
+	}
+
+	async sendWhiteLabelDataForWeb(whiteLabelData) {
+		try {
+			await localStorage.setItem(
+				whiteLabelUpdaterConfiguration?.localStorageConfigName,
+				JSON.stringify(whiteLabelData)
+			);
+			log.info('[WL] Info successful send to web localstorage');
+		} catch (e) {
+			log.error('[WL] Error of saving to web localstorage', e);
+		}
+	}
+
+	createAppIcon(iconBase64String) {
+		try {
+			if (iconBase64String) {
+				const image = nativeImage.createFromDataURL(iconBase64String);
+				return image.resize(whiteLabelUpdaterConfiguration?.imageSize);
+			}
+		} catch (e) {
+			log.error('[WL] Unable to generate app icon', e);
+		}
+		return null;
+	}
+
+	updateShortcutWithBase64(base64String) {
+		const cleanBase64 = base64String.replace(/^data:.*?;base64,/, '');
+		const userDataPath = app.getPath(whiteLabelUpdaterConfiguration?.systemDir);
+		const uniqueIconName = `${
+			whiteLabelUpdaterConfiguration?.tempIconPrefix
+		}${Date.now()}.${whiteLabelUpdaterConfiguration?.fileExtension?.ico}`;
+		const iconPath = path.join(userDataPath, uniqueIconName);
+
+		try {
+			const files = fs.readdirSync(userDataPath);
+			files.forEach(file => {
+				if (
+					file.startsWith(whiteLabelUpdaterConfiguration?.tempIconPrefix) &&
+					file.endsWith(
+						`.${whiteLabelUpdaterConfiguration?.fileExtension?.ico}`
+					)
+				) {
+					fs.unlinkSync(path.join(userDataPath, file));
+				}
+			});
+
+			fs.writeFileSync(
+				iconPath,
+				cleanBase64,
+				whiteLabelUpdaterConfiguration?.fileExtension?.base64
+			);
+
+			const desktopPath = path.join(
+				os.homedir(),
+				whiteLabelUpdaterConfiguration?.desktopDir,
+				`${config?.mainWindow?.title}.${whiteLabelUpdaterConfiguration?.fileExtension?.lnk}`
+			);
+
+			const success = shell.writeShortcutLink(desktopPath, 'replace', {
+				target: process.execPath,
+				icon: iconPath,
+				iconIndex: 0,
+				cwd: path.dirname(process.execPath),
+			});
+
+			if (success) {
+				const now = new Date();
+				fs.utimesSync(desktopPath, now, now);
+
+				log.info(
+					`[WL] Shortcut successfully replaced and redrawn with: ${uniqueIconName}`
+				);
+			} else {
+				log.info('[WL] Failed to replace the shortcut.');
+			}
+		} catch (e) {
+			log.error('[WL] Failed to update shortcut:', e);
+		}
+	}
+}
+
+module.exports = new WhiteLabelUpdater();

package/source/Customization/electron/electron.js

@@ -0,0 +1,336 @@
+const path = require('path');
+
+const {
+	app,
+	BrowserWindow,
+	shell,
+	dialog,
+	session,
+	globalShortcut,
+} = require('electron');
+const isDev = require('electron-is-dev');
+// Auto updater
+const fs = require('fs');
+const { localStorage } = require('electron-browser-storage');
+const { t } = require('./electron-configuration/messages');
+const {
+	config,
+	platforms,
+	platformsNames,
+} = require('./electron-configuration/configuration');
+const { autoUpdater } = require('electron-updater');
+const log = require('electron-log');
+const forge = require('node-forge');
+const os = require('os');
+
+const getLang = async () => localStorage.getItem(config.storageNames.lang);
+
+const { isEnableDevTools, isAvailableDomainInput, certificate } = config;
+
+const rootCertificatePath = path.join(
+	__dirname,
+	certificate.dir,
+	certificate.fileName,
+);
+const rootCertificatePathSecondary = path.join(
+	__dirname,
+	certificate.dir,
+	certificate.fileNameSecondary,
+);
+
+const currentPlatform = platformsNames[os.platform()];
+let updatesPath;
+
+log.info(`Current Platform: ${currentPlatform}`);
+
+// Disable downloading and installation updates for the MAC
+autoUpdater.autoDownload = currentPlatform !== platforms.MAC;
+autoUpdater.autoInstallOnAppQuit = currentPlatform !== platforms.MAC;
+
+// Enable usage of Portal's globalShortcuts. This is essential for cases when
+// the app runs in a Wayland session.
+app.commandLine.appendSwitch('enable-features', 'GlobalShortcutsPortal');
+
+const serverUrl = 'http://localhost:3100/';
+
+async function createWindow() {
+	let appIcon = null;
+	if (config.isEnableWhiteLabelUpdater && !!config.isEnableWhiteLabelUpdater) {
+		// White Labels
+		const whiteLabelUpdater = require('./electron-configuration/modules/WhiteLabelUpdater.js');
+
+		const wlConfig = await whiteLabelUpdater.getWhiteLabelData(serverUrl);
+		appIcon = whiteLabelUpdater.createAppIcon(wlConfig?.assets['icon.png']);
+
+		await whiteLabelUpdater.sendWhiteLabelDataForWeb(wlConfig);
+
+		if (process.platform === 'win32' && wlConfig?.assets['icon.ico']) {
+			whiteLabelUpdater?.updateShortcutWithBase64(wlConfig?.assets['icon.ico']);
+		}
+
+		try {
+			if (process.platform === 'darwin') {
+				app.dock.setIcon(appIcon);
+				log.info('[WL][MAC] Icon successfully changed');
+			}
+		} catch (e) {
+			log.error('[WL][MAC] Icon error', e);
+		}
+	}
+
+	// Create the browser window.
+	const win = new BrowserWindow({
+		...config.mainWindow,
+		icon: appIcon,
+		webPreferences: {
+			devTools: true,
+			nodeIntegration: true,
+		},
+	});
+
+	win.webContents.on('new-window', function (e, url) {
+		e.preventDefault();
+		shell.openExternal(url);
+	});
+	// Set Links Settings
+
+	win.webContents.setWindowOpenHandler(details => {
+		shell.openExternal(details.url); // Open URL in user's Browser
+		return { action: 'deny' };
+	});
+
+	if (!isEnableDevTools) {
+		win.removeMenu();
+	}
+
+	// Register a config?.shortCuts?.devTools shortcut listener.
+	const ret = globalShortcut.register(config?.shortCuts?.devTools, () => {
+		log.info(`${config?.shortCuts?.devTools} is pressed`);
+		if (win) {
+			const isOpen = win.webContents.isDevToolsOpened();
+			if (isOpen) {
+				win.webContents.closeDevTools();
+			} else {
+				win.webContents.openDevTools({ mode: 'detach' });
+			}
+		}
+	});
+
+	// and load the index.html of the app.
+	// win.loadFile("index.html");
+	win.loadURL(
+		isDev
+			? 'http://localhost:3000'
+			: `file://${path.join(__dirname, '../build/index.html')}`,
+	);
+
+	// Open the DevTools.
+	if (isEnableDevTools) {
+		win.webContents.openDevTools({ mode: 'detach' });
+	}
+
+	// Check up for updates
+	// Verify certificate for the autoUpdater
+	autoUpdater.netSession.setCertificateVerifyProc((request, callback) => {
+		const certStatuses = {
+			trusted: 0,
+			failed: -2,
+			browserChecked: -3,
+		};
+		const { hostname: hostName, verificationResult: e, certificate } = request;
+		let subjectName = certificate?.subjectName?.split('\n')[0];
+		subjectName = subjectName?.replace('*.', '');
+		const status = hostName?.includes(subjectName)
+			? certStatuses.trusted
+			: certStatuses.failed;
+		if (status === certStatuses.failed) {
+			log.error('Certificate validation error:');
+			log.error(e);
+		}
+		callback(status);
+	});
+
+	const generateUpdateConfig = async () => {
+		let status = true;
+		const domainURL = await localStorage.getItem(config.storageNames.domain);
+		// Test local server
+		// const domainURL = `http://localhost:3100/`;
+		if (!domainURL) {
+			status = false;
+			return status;
+		}
+		const platformPath =
+			config?.updatesPathForPlatform[currentPlatform] ??
+			config?.updatesPathForPlatform[platforms.WINDOWS];
+
+		updatesPath = `${domainURL}${platformPath}`;
+
+		try {
+			log.info('domain: ', domainURL);
+			log.info('updates path: ', updatesPath);
+			autoUpdater.setFeedURL({
+				url: updatesPath,
+				provider: config.provider,
+			});
+		} catch (err) {
+			log.error(err);
+			status = false;
+		}
+		return status;
+	};
+
+	if (app.isPackaged) {
+		if (isAvailableDomainInput) {
+			generateUpdateConfig()
+				.then(status => {
+					if (status) {
+						autoUpdater.logger = log;
+						autoUpdater.checkForUpdates();
+					}
+				})
+				.catch(e => log.error(e));
+			return;
+		}
+		autoUpdater.logger = log;
+		autoUpdater.checkForUpdates();
+	}
+}
+
+// This method will be called when Electron has finished
+// initialization and is ready to create browser windows.
+// Some APIs can only be used after this event occurs.
+app.whenReady().then(() => {
+	createWindow();
+
+	// MAC OS FIX: Re-create a window in the app when the dock icon is clicked
+	app.on('activate', () => {
+		if (BrowserWindow.getAllWindows().length === 0) createWindow();
+	});
+});
+
+// Quit when all windows are closed, except on macOS. There, it's common
+// for applications and their menu bar to stay active until the user quits
+// explicitly with Cmd + Q.
+app.on('window-all-closed', () => {
+	if (process.platform !== 'darwin') {
+		app.quit();
+	}
+});
+
+// Auto updater events
+// Check is auto update available
+autoUpdater.on('update-available', info => {
+	log.info('Update available:', info);
+	log.info('Updates path:', updatesPath);
+
+	const showInfoDialog = (lang = 'en') => {
+		log.info('showInfoDialog lang', lang);
+		const options = {
+			type: 'info',
+			buttons: [
+				t('Download installer', lang),
+				t('Download manual', lang),
+				t('Cancel', lang),
+			],
+			defaultId: 2,
+			title: t('Update is available', lang),
+			message: t('Update is available', lang),
+			detail: '',
+		};
+		dialog.showMessageBox(options).then(response => {
+			if (response.response === 0) {
+				shell.openExternal(
+					`${updatesPath}${config?.macUpdateConfig?.installerName}`,
+				);
+				showInfoDialog(lang);
+			} else if (response.response === 1) {
+				shell.openExternal(
+					`${updatesPath}${config?.macUpdateConfig?.manualMap[lang]}`,
+				);
+				showInfoDialog(lang);
+			}
+		});
+	};
+	if (currentPlatform === platforms.MAC) {
+		getLang()
+			.then(lang => {
+				showInfoDialog(lang);
+			})
+			.catch(() => {
+				log.error('Unable get language');
+				showInfoDialog();
+			});
+	}
+});
+autoUpdater.on('update-downloaded', (_event, releaseNotes, releaseName) => {
+	const showTranslatedDialog = lang => {
+		const dialogOpts = {
+			type: 'info',
+			buttons: [t('Ok', lang), t('Later', lang)],
+			title: t('Update is available', lang),
+			message: process.platform === 'win32' ? releaseNotes : releaseName,
+			detail: t('Now application will start updating and restart.', lang),
+		};
+		dialog.showMessageBox(dialogOpts).then(returnValue => {
+			if (returnValue.response === 0) autoUpdater.quitAndInstall();
+		});
+	};
+	getLang()
+		.then(lang => {
+			showTranslatedDialog(lang);
+		})
+		.catch(() => {
+			log.error('Unable get language');
+			showTranslatedDialog();
+		});
+});
+
+autoUpdater.on('error', message => {
+	log.error(t('There was a problem updating the application'));
+	log.error(message);
+});
+
+app.on(
+	'certificate-error',
+	(event, webContents, url, error, certificate, callback) => {
+		try {
+			const rootCertificateContent = fs.readFileSync(
+				rootCertificatePath,
+				'utf8',
+			);
+			const rootCertificateContentSecondary = fs.readFileSync(
+				rootCertificatePathSecondary,
+				'utf8',
+			);
+			const rootCert = forge.pki.certificateFromPem(rootCertificateContent);
+			const rootCertSecondary = forge.pki.certificateFromPem(
+				rootCertificateContentSecondary,
+			);
+			const clientCert = forge.pki.certificateFromPem(
+				certificate.data.toString(),
+			);
+			callback(
+				clientCert.isIssuer(rootCert) || clientCert.isIssuer(rootCertSecondary),
+			);
+		} catch (e) {
+			log.error('Certificate validation error:');
+			log.error(e);
+			callback(false);
+		}
+	},
+);
+
+// Clear Cache
+app.on('ready', () => {
+	session.defaultSession.clearCache().then(() => {
+		log.info('Cache cleared!');
+	});
+});
+
+app.on('will-quit', () => {
+	// Unregister a shortcut.
+	globalShortcut.unregister(config?.shortCuts?.devTools);
+
+	// Unregister all shortcuts.
+	globalShortcut.unregisterAll();
+});