123-lang 2.1.13 → 2.1.15

package/source/Customization/electron/last/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/last/electron-configuration/modules/WhiteLabelUpdater /342/200/223 default.js"

@@ -0,0 +1,259 @@
+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 axios = require('axios');
+
+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) {
+		console.log('[WL] Get White Label Data');
+		if (!serverUrl) return whiteLabelUpdaterConfiguration?.defaultResult;
+
+		const normalizedUrl = serverUrl.replace(/\/$/, '');
+		const cacheFilePath = this.getFilePath(normalizedUrl);
+		console.log('[WL] normalizedUrl', normalizedUrl);
+		console.log('[WL] chacheFilePath', cacheFilePath);
+
+		let localCache = null;
+		try {
+			const raw = await fsPromises.readFile(cacheFilePath, 'utf8');
+			localCache = JSON.parse(raw);
+		} catch (e) {
+			console.error('[WL] There is something wrong with the cache');
+		}
+		let remoteConfig = null;
+		try {
+			console.log(
+				'[WL] fetch data',
+				`${normalizedUrl}${whiteLabelUpdaterConfiguration?.internalAssetsDir}${whiteLabelUpdaterConfiguration?.configFileName}`,
+				{ timeout: 2000 },
+			);
+			const res = await axios.get(
+				`${normalizedUrl}${whiteLabelUpdaterConfiguration?.internalAssetsDir}${whiteLabelUpdaterConfiguration?.configFileName}`,
+				{ timeout: 2000 },
+			);
+			console.log('[WL] data response', res);
+			remoteConfig = res.data;
+			console.log('[WL] remote config', remoteConfig);
+		} catch (e) {
+			console.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
+		) {
+			console.info('[WL] Version match. Serving from cache.');
+
+			return { ...remoteConfig, assets: localCache.data.assets };
+		}
+
+		console.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 };
+
+		// Replace your existing Promise.all block with this:
+		const assetResults = await Promise.all(
+			whiteLabelUpdaterConfiguration?.assetFiles?.map(async file => {
+				try {
+					const res = await axios.get(
+						`${normalizedUrl}${whiteLabelUpdaterConfiguration?.internalAssetsDir}${file}`,
+						{ responseType: 'arraybuffer' },
+					);
+
+					const buffer = Buffer.from(res.data);
+					const ext = path.extname(file).toLowerCase().replace('.', '');
+
+					const mimeTypes = {
+						svg: 'image/svg+xml',
+						ico: 'image/x-icon',
+						png: 'image/png',
+						jpg: 'image/jpeg',
+						jpeg: 'image/jpeg',
+					};
+
+					const mime = mimeTypes[ext] || `image/${ext}`;
+					const b64 = buffer.toString('base64');
+
+					// Return an object representing this file's result
+					return { file, data: `data:${mime};base64,${b64}` };
+				} catch (err) {
+					console.error(`[WL] Failed to download asset: ${file}`, err.message);
+					return null; // Return null so we can filter it out
+				}
+			}),
+		);
+
+		// Map the results back into your assets object
+		assetResults.forEach(result => {
+			if (result) {
+				assets[result.file] = result.data;
+			}
+		});
+
+		const freshData = {
+			...whiteLabelUpdaterConfiguration?.defaultResult,
+			...remoteConfig,
+			assets: assets,
+		};
+		console.log(freshData);
+		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/last/electron-configuration/modules/WhiteLabelUpdater.js

@@ -0,0 +1,273 @@
+const fs = require('fs');
+const path = require('path');
+const { app, nativeImage, shell } = require('electron');
+const log = require('electron-log');
+const { localStorage } = require('electron-browser-storage');
+const os = require('os');
+const axios = require('axios');
+
+const { whiteLabelUpdaterConfiguration, config } = require('../configuration');
+
+class WhiteLabelUpdater {
+	constructor() {
+		this.initStore().then();
+	}
+
+	async initStore() {
+		try {
+			const { default: Store } = await import('electron-store');
+			let store = new Store();
+			if (!store?.has('cache')) {
+				store.set('cache.default', {
+					...whiteLabelUpdaterConfiguration?.defaultResult,
+				});
+			}
+			log.info('[WL] Store was created successful');
+			this.store = store;
+		} catch (err) {
+			log.error('[WL] There is some error on Store creation', err);
+		}
+	}
+
+	async checkLoginDomain() {
+		try {
+			const domainURL = await localStorage.getItem(config.storageNames.domain);
+			log.info('[WL] Domain checked', domainURL);
+			return domainURL;
+		} catch (err) {
+			log.error('[WL] There is an error on checking domain', err);
+			return null;
+		}
+	}
+
+	async getWhiteLabelStatus() {
+		const domain = await this.checkLoginDomain();
+		return this.readCache(domain);
+	}
+
+	async runWhiteLabelUpdater() {
+		const domain = await this.checkLoginDomain();
+		await this.cacheCheck(domain);
+	}
+
+	async cacheCheck(domain) {
+		try {
+			await this.writeCache(domain);
+		} catch (err) {
+			log.error('[WL] No information in cache', err);
+		}
+	}
+
+	async fetchConfig(domain) {
+		try {
+			log.info(
+				'[WL] fetch data',
+				`${domain}${whiteLabelUpdaterConfiguration?.internalAssetsDir}${whiteLabelUpdaterConfiguration?.configFileName}`,
+			);
+			const res = await axios.get(
+				`${domain}${whiteLabelUpdaterConfiguration?.internalAssetsDir}${whiteLabelUpdaterConfiguration?.configFileName}`,
+				{ timeout: whiteLabelUpdaterConfiguration?.timeOutMs },
+			);
+			if (res.status === 200) {
+				log.info('[WL] response', res.status);
+				const remoteConfig = res.data;
+				log.info('[WL] remote config', remoteConfig);
+				return remoteConfig;
+			}
+		} catch (err) {
+			log.error('[WL] Server unavailable, using cache fallback.', err);
+			return null;
+		}
+	}
+
+	async fetchAssetsData(domain) {
+		const assets = { ...this.store.get('cache.default.assets') };
+
+		const assetResults = await Promise.all(
+			whiteLabelUpdaterConfiguration?.assetFiles?.map(async file => {
+				try {
+					const res = await axios.get(
+						`${domain}${whiteLabelUpdaterConfiguration?.internalAssetsDir}${file}`,
+						{
+							responseType: 'arraybuffer',
+							timeout: whiteLabelUpdaterConfiguration?.timeOutMs,
+						},
+					);
+
+					const buffer = Buffer.from(res.data);
+					const ext = path.extname(file).toLowerCase().replace('.', '');
+
+					const mimeTypes = {
+						svg: 'image/svg+xml',
+						ico: 'image/x-icon',
+						png: 'image/png',
+						jpg: 'image/jpeg',
+						jpeg: 'image/jpeg',
+					};
+
+					const mime = mimeTypes[ext] || `image/${ext}`;
+					const b64 = buffer.toString('base64');
+
+					return { file, data: `data:${mime};base64,${b64}` };
+				} catch (err) {
+					log.error(`[WL] Failed to download asset: ${file}`, err.message);
+					return null;
+				}
+			}),
+		);
+
+		assetResults.forEach(result => {
+			if (result) {
+				assets[result.file] = result.data;
+			}
+		});
+
+		return assets;
+	}
+
+	async writeCache(domain) {
+		if (!this.isValidUrl(domain)) return;
+		log.info('writeCache', domain);
+
+		const encodedDomain = this.encodeUrl(domain);
+		const config = await this.fetchConfig(domain);
+
+		if (this.store.has(`cache.${encodedDomain}`)) {
+			log.info('[WL] cache exists');
+			const currentConfig = this.store.get(`cache.${encodedDomain}`);
+			log.info(
+				'[WL] compare caches: ',
+				currentConfig?.version,
+				config?.version,
+			);
+			if (config !== null && config?.version > currentConfig?.version) {
+				log.info('[WL] cache updating ...', domain);
+				const remoteAssets = await this.fetchAssetsData(domain);
+				this.store.set(`cache.${encodedDomain}`, {
+					...config,
+					assets: { ...remoteAssets },
+				});
+			}
+		} else {
+			log.info('[WL] cache not exists');
+			if (config !== null) {
+				log.info('[WL] cache creating ...', domain);
+				const remoteAssets = await this.fetchAssetsData(domain);
+				this.store.set(`cache.${encodedDomain}`, {
+					...config,
+					assets: { ...remoteAssets },
+				});
+			}
+		}
+	}
+
+	readCache(domain) {
+		const encodedDomain = this.encodeUrl(domain);
+		return this.store.has(`cache.${encodedDomain}`)
+			? this.store.get(`cache.${encodedDomain}`)
+			: this.store.get('cache.default');
+	}
+
+	encodeUrl(url) {
+		return Array.from(new TextEncoder().encode(url))
+			.map(byte => byte.toString(16).padStart(2, '0'))
+			.join('');
+	}
+
+	decodeUrl(hexString) {
+		const bytes = new Uint8Array(
+			hexString.match(/.{1,2}/g).map(byte => parseInt(byte, 16)),
+		);
+		return new TextDecoder().decode(bytes);
+	}
+
+	isValidUrl(string) {
+		try {
+			new URL(string);
+			return true;
+		} catch (err) {
+			return false;
+		}
+	}
+
+	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();