123-lang 2.1.3 → 2.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "123-lang",
-  "version": "2.1.3",
+  "version": "2.1.4",
   "description": "",
   "main": "index.js",
   "scripts": {

package/source/electron.js

@@ -0,0 +1,312 @@
+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');
+
+function createWindow() {
+	// Create the browser window.
+	const win = new BrowserWindow({
+		...config.mainWindow,
+		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, () => {
+		const focusedWindow = BrowserWindow.getFocusedWindow();
+		log.info(`${config?.shortCuts?.devTools} is pressed`);
+		if (focusedWindow) {
+			const isOpen = focusedWindow.webContents.isDevToolsOpened();
+			if (isOpen) {
+				focusedWindow.webContents.closeDevTools();
+			} else {
+				focusedWindow.webContents.openDevTools({ mode: 'detach' });
+			}
+		} else {
+			log.warn('No focused window to toggle DevTools.');
+		}
+	});
+
+	// 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();
+});