ztechno_core 0.0.1

package/LICENSE

@@ -0,0 +1 @@
+MIT

package/README.md

@@ -0,0 +1,81 @@
+# ztech_jquery_ext
+#### Extends JQuery library for more compact code base
+
+[![npm version](https://badge.fury.io/js/ztech_jquery_ext.svg)](https://www.npmjs.com/package/ztech_jquery_ext)
+
+Requirements
+-----
+  + [jQuery](http://jquery.com/)
+
+
+Installation
+-----
+
+### [NPM](https://www.npmjs.com/package/ztech_jquery_ext)
+```bash
+npm install ztech_jquery_ext
+```
+
+### [Yarn](https://yarn.pm/ztech_jquery_ext)
+```bash
+yarn add ztech_jquery_ext
+```
+
+### [CDN - jsDelivr](https://www.jsdelivr.com/package/npm/ztech_jquery_ext)
+```html
+<link href="https://cdn.jsdelivr.net/npm/ztech_jquery_ext/dist/css/ztech_jquery_ext.min.css" rel="stylesheet" type="text/css" />
+<script src="https://cdn.jsdelivr.net/npm/ztech_jquery_ext/dist/js/ztech_jquery_ext.min.js" type="text/javascript"></script>
+```    
+
+### [CDN - UNPKG](https://unpkg.com/browse/ztech_jquery_ext/)
+```html
+<link href="https://unpkg.com/ztech_jquery_ext/dist/css/ztech_jquery_ext.min.css" rel="stylesheet" type="text/css" />
+<script src="https://unpkg.com/ztech_jquery_ext/dist/js/ztech_jquery_ext.min.js" type="text/javascript"></script>
+```
+
+TypeScript Support
+-----
+In order to include types add the following in tsconfig.json
+```json
+{
+  "compilerOptions": {
+    "types": ["ztech_jquery_ext"]
+  }
+}
+```
+
+Alternatively Add the following reference at the top of the javascript/typescript file
+```js
+/// <reference types="ztech_jquery_ext" />
+```
+
+Usage
+-----
+
+Include jQuery
+```html
+<script src="https://code.jquery.com/jquery-3.3.1.min.js"></script>
+```
+
+Include Plugin JS
+```html
+<script src="https://cdn.jsdelivr.net/npm/ztech_jquery_ext/dist/js/ztech_jquery_ext.min.js" type="text/javascript"></script>
+```
+
+Usage
+```js
+// [JQuery, JQuery, JQuery, ...]
+var rows = $('.row').$arr();
+
+// [number, number, number, ...]
+var userids = $('.user').$map(function ($ele) {
+  return $ele.attr('id');
+});
+```
+
+License
+----
+MIT
+
+
+Created with :heart: [create-jquery-plugin](https://www.npmjs.com/package/create-jquery-plugin)

package/lib/crypto_service.d.ts

@@ -0,0 +1,10 @@
+declare type HashStruct = {
+    iv: string;
+    encryptedData: string;
+};
+export declare class ZCryptoService {
+    static encrypt(text: string): HashStruct;
+    static decrypt(data: HashStruct): string;
+    static decryptJSON(data: HashStruct): any;
+}
+export {};

package/lib/crypto_service.js

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZCryptoService = void 0;
+const crypto = __importStar(require("crypto"));
+const algorithm = 'aes-256-cbc';
+const key = Buffer.from([
+    253, 144, 73, 128, 71, 94, 34, 3, 28, 128, 194, 166, 132, 154, 14, 87, 221, 202, 92, 56, 139, 10, 38, 122, 120, 7,
+    149, 40, 211, 218, 217, 3,
+]);
+const iv = Buffer.from([0, 209, 223, 20, 147, 45, 14, 107, 93, 6, 76, 206, 176, 55, 245, 134]);
+class ZCryptoService {
+    static encrypt(text) {
+        const cipher = crypto.createCipheriv(algorithm, Buffer.from(key), iv);
+        let encrypted = cipher.update(text);
+        encrypted = Buffer.concat([encrypted, cipher.final()]);
+        return { iv: iv.toString('hex'), encryptedData: encrypted.toString('hex') };
+    }
+    static decrypt(data) {
+        const niv = Buffer.from(data.iv, 'hex');
+        const encryptedText = Buffer.from(data.encryptedData, 'hex');
+        const decipher = crypto.createDecipheriv(algorithm, Buffer.from(key), niv);
+        let decrypted = decipher.update(encryptedText);
+        decrypted = Buffer.concat([decrypted, decipher.final()]);
+        return decrypted.toString();
+    }
+    static decryptJSON(data) {
+        try {
+            const decrypted = ZCryptoService.decrypt(data);
+            return JSON.parse(decrypted);
+        }
+        catch (err) {
+            throw new Error(`Couldn't decrypt JSON ${JSON.stringify(data)}`);
+        }
+    }
+}
+exports.ZCryptoService = ZCryptoService;

package/lib/mail_service.d.ts

@@ -0,0 +1,19 @@
+declare type MailServiceOptions = {
+    auth: {
+        user: string;
+        pass: string;
+    };
+    mailSender: string;
+};
+declare type MailOptions = {
+    recipient: string;
+    subject: string;
+    body: string;
+};
+export declare class ZMailService {
+    private opt;
+    constructor(opt: MailServiceOptions);
+    send(mailOpts: MailOptions): Promise<any>;
+    static get(opt: MailServiceOptions): ZMailService;
+}
+export {};

package/lib/mail_service.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZMailService = void 0;
+const nodemailer = require('nodemailer');
+let instance = null;
+class ZMailService {
+    constructor(opt) {
+        this.opt = opt;
+    }
+    send(mailOpts) {
+        const mailTransporter = nodemailer.createTransport({
+            service: 'gmail',
+            auth: this.opt.auth,
+        });
+        const mailDetails = {
+            from: this.opt.mailSender,
+            to: mailOpts.recipient,
+            subject: mailOpts.subject,
+            text: mailOpts.body,
+        };
+        return new Promise((resolve, reject) => {
+            mailTransporter.sendMail(mailDetails, function (err, data) {
+                return err ? reject(err) : resolve('success'); // data)
+            });
+        });
+    }
+    static get(opt) {
+        if (instance == null) {
+            instance = new ZMailService(opt);
+        }
+        return instance;
+    }
+}
+exports.ZMailService = ZMailService;

package/lib/sql_service.d.ts

@@ -0,0 +1,7 @@
+import * as mysql from 'mysql';
+export declare class ZSqlService {
+    static init(credentials: mysql.ConnectionConfig): void;
+    connect(): Promise<mysql.Connection>;
+    query(sql: string, escaped?: any[]): Promise<any>;
+    static get(): ZSqlService;
+}

package/lib/sql_service.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZSqlService = void 0;
+const mysql = __importStar(require("mysql"));
+let instance = null;
+const logError = (err) => {
+    if (err)
+        throw err;
+};
+let creds;
+class ZSqlService {
+    static init(credentials) {
+        creds = credentials;
+    }
+    connect() {
+        return new Promise((resolve, reject) => {
+            const con = mysql.createConnection(creds);
+            con.connect((err) => {
+                if (err)
+                    return reject(err);
+                resolve(con);
+            });
+        });
+    }
+    query(sql, escaped = []) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const con = yield this.connect();
+            const output = yield new Promise((resolve, reject) => {
+                con.query(sql, escaped, (err, result) => {
+                    if (err)
+                        return reject(err);
+                    resolve(result);
+                });
+            });
+            con.end(logError);
+            return output;
+        });
+    }
+    static get() {
+        if (instance == null) {
+            instance = new ZSqlService();
+        }
+        return instance;
+    }
+}
+exports.ZSqlService = ZSqlService;

package/lib/translate_service.d.ts

@@ -0,0 +1,46 @@
+declare type TranslateData = {
+    value: string;
+    meta?: {
+        prefix: string;
+        suffix: string;
+    };
+};
+declare type dbTranslationRow = {
+    lang: string;
+    key: string;
+    value: string;
+};
+export declare class TranslateService {
+    private localCache;
+    surpressErrors: boolean;
+    getLanguages(): string[];
+    getSourceLang(): string;
+    getDefaultLang(): string;
+    constructor();
+    static init(opt: {
+        key: string;
+    }): void;
+    private codes;
+    getLang(cookies: {
+        [key: string]: string;
+    }): string;
+    translateText(langOrReq: string | any, text: string): Promise<string>;
+    translateHtml(html: string, cookies: {
+        lang: string;
+        [key: string]: string;
+    }): Promise<string>;
+    private translateHtmlRec;
+    update(key: string, lang: string, data: TranslateData): Promise<any>;
+    private checkLocalCache;
+    private insertLocalCache;
+    private clearLocalCache;
+    private fetch;
+    private insert;
+    private fetchLang;
+    fetchAllGrouped(): Promise<{
+        [key: string]: dbTranslationRow[];
+    }>;
+    private fetchAll;
+    static get(): TranslateService;
+}
+export {};

package/lib/translate_service.js

@@ -0,0 +1,243 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TranslateService = void 0;
+const sql_service_1 = require("./sql_service");
+const DomParser = require('dom-parser');
+const translate = require('translate');
+const htmlParser = new DomParser();
+const sql = sql_service_1.ZSqlService.get();
+let instance = null;
+class TranslateService {
+    constructor() {
+        this.localCache = {};
+        this.surpressErrors = true;
+        this.codes = {
+            [`'`]: `'`,
+            [`"`]: `"`,
+            [`“`]: `“`,
+            [`”`]: `”`,
+            [`©`]: `©`,
+            [`®`]: `®`,
+            [`€`]: `€`,
+            [`£`]: `£`,
+            [`™`]: `™`,
+        };
+        this.getLanguages().map((lang) => (this.localCache[lang] = {}));
+        setInterval(() => this.clearLocalCache(), 1000 * 60 * 60); // Every Hour
+    }
+    getLanguages() {
+        return ['en', 'nl'];
+    }
+    getSourceLang() {
+        return 'nl';
+    }
+    getDefaultLang() {
+        return 'nl';
+    }
+    static init(opt) {
+        translate.key = opt.key;
+    }
+    getLang(cookies) {
+        const defaultLang = this.getDefaultLang();
+        const langKey = (cookies.lang || defaultLang).toLowerCase();
+        const langs = this.getLanguages();
+        if (!langs.includes(langKey)) {
+            return defaultLang;
+        }
+        return langKey;
+    }
+    translateText(langOrReq, text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lang = typeof langOrReq === 'string' ? langOrReq : this.getLang(langOrReq.cookies);
+            text = text.trim();
+            if (text.length === 1) {
+                return text;
+            }
+            let replaceCount = 0;
+            while (text.includes('&#')) {
+                const codeIndexStart = text.indexOf('&#');
+                const first = text.substring(codeIndexStart);
+                const codeLength = first.indexOf(';') + 1;
+                const code = first.substring(0, codeLength);
+                if (this.codes[code] === undefined) {
+                    throw new Error(`Cant recognize character code="${code}"\n for text=${text}\n\n`);
+                    // return text
+                }
+                text = text.substring(0, codeIndexStart) + this.codes[text] + text.substring(codeIndexStart + codeLength);
+                // text = text.replace(code, codes[text])
+                if (replaceCount++ > 1000) {
+                    throw new Error(`Replace Count > 1000!!! character code="${code}"\n for text=${text}\n\n`);
+                    // return text
+                }
+            }
+            const localCached = this.checkLocalCache(text, lang);
+            if (localCached !== false) {
+                return localCached.value;
+            }
+            const remoteCached = yield this.fetch(text, lang);
+            if (remoteCached !== false) {
+                return remoteCached.value;
+            }
+            let result;
+            try {
+                result = yield translate(text, {
+                    from: this.getSourceLang(),
+                    to: lang,
+                });
+            }
+            catch (err) {
+                result = '?';
+            }
+            yield this.insert(text, lang, { value: result });
+            return result;
+        });
+    }
+    translateHtml(html, cookies) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lang = this.getLang(cookies);
+            const defaultLang = this.getDefaultLang();
+            const dom = htmlParser.parseFromString(html);
+            const htmlNodes = dom.getElementsByTagName('html');
+            const mainNodes = dom.getElementsByTagName('main');
+            const isView = htmlNodes.length === 0;
+            const domNode = isView ? mainNodes[0] : htmlNodes[0];
+            if (lang !== defaultLang) {
+                const node = isView ? domNode : domNode.getElementsByTagName('body')[0];
+                const promises = [];
+                this.translateHtmlRec(lang, node, promises);
+                yield Promise.all(promises);
+            }
+            const output = domNode ? domNode.outerHTML : html;
+            return output.startsWith(`<!DOCTYPE html>`) ? output : `<!DOCTYPE html>\r\n${output}`;
+        });
+    }
+    translateHtmlRec(lang, node, promises, skipTranslate = false) {
+        if (node.getAttribute('notranslate') != null) {
+            skipTranslate = true;
+        }
+        if (node.nodeName === '#text') {
+            const nodeText = node;
+            const text = nodeText.text.replace(/[\r|\n|\r\n]+/g, ' ').replace(/\s\s+/g, ' ');
+            const value = text.trim();
+            const meta = {
+                prefix: genSpaces(text.length - text.trimStart().length),
+                suffix: genSpaces(text.length - text.trimEnd().length),
+            };
+            if (skipTranslate === true || text.length === 0 || !strContainsLetters(text)) {
+                node.text = meta.prefix + text + meta.suffix;
+                return;
+            }
+            promises.push(this.translateText(lang, value)
+                .then((translatedText) => {
+                node.text = meta.prefix + translatedText + meta.suffix;
+            })
+                .catch((err) => {
+                node.text = text;
+                if (!this.surpressErrors) {
+                    throw err; // TODO: Find out if surpressing is better
+                }
+            }));
+            return;
+        }
+        // const hasChildren = node.childNodes !== undefined
+        for (const child of node.childNodes || []) {
+            this.translateHtmlRec(lang, child, promises, skipTranslate);
+        }
+    }
+    update(key, lang, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield sql.query(`
+      INSERT INTO translations
+        (\`key\`, \`lang\`, \`value\`)
+      VALUES
+        (?, ?, ?)
+      ON DUPLICATE KEY UPDATE value=?
+    `, [key, lang, data.value, data.value]);
+        });
+    }
+    checkLocalCache(key, lang) {
+        const hasLocal = !this.localCache[lang].hasOwnProperty(key);
+        return hasLocal ? false : this.localCache[lang][key];
+    }
+    insertLocalCache(key, lang, data) {
+        if (this.localCache[lang].hasOwnProperty(key)) {
+            // console.warn(`Translations already cached!`, { key, lang, data})
+            return;
+        }
+        this.localCache[lang][key] = data;
+    }
+    clearLocalCache() {
+        Object.keys(this.localCache).map((k) => {
+            this.localCache[k] = {};
+        });
+    }
+    fetch(key, lang) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = yield sql.query(`SELECT \`value\` FROM translations WHERE \`lang\`=? AND \`key\`=?`, [lang, key]);
+            if (results.length > 0) {
+                // api.query(`UPDATE translations SET last_used=CURRENT_TIMESTAMP WHERE \`lang\`=? AND \`key\`=?`, [lang, key])
+                //   .catch(err => console.error(err))
+                const { value } = results[0];
+                this.insertLocalCache(key, lang, { value });
+                return { value };
+            }
+            return false;
+        });
+    }
+    insert(key, lang, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield sql.query(`INSERT IGNORE INTO translations (\`key\`, \`lang\`, \`value\`) VALUES (?, ?, ?)`, [
+                key,
+                lang,
+                data.value,
+            ]);
+        });
+    }
+    fetchLang(lang) {
+        return sql.query(`SELECT \`key\`, \`lang\`, \`value\`, \`verified\`, \`created_at\` FROM translations WHERE \`lang\`=?`, [lang]);
+    }
+    fetchAllGrouped() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const output = {};
+            const allTranslations = yield this.fetchAll();
+            allTranslations.map((translation) => {
+                const { key } = translation;
+                if (!output.hasOwnProperty(key)) {
+                    output[key] = [];
+                }
+                output[key].push(translation);
+            });
+            return output;
+        });
+    }
+    fetchAll() {
+        return sql.query(`SELECT \`key\`, \`lang\`, \`value\`, \`verified\`, \`created_at\` FROM translations`);
+    }
+    static get() {
+        if (instance == null) {
+            instance = new TranslateService();
+        }
+        return instance;
+    }
+}
+exports.TranslateService = TranslateService;
+function strContainsLetters(text) {
+    const regExp = /[a-zA-Z]/g;
+    return regExp.test(text);
+}
+function genSpaces(length) {
+    let output = '';
+    for (let i = 0; i < length; i++) {
+        output += ' ';
+    }
+    return output;
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "ztechno_core",
+  "version": "0.0.1",
+  "description": "Core files for ztechno framework",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "license": "MIT",
+  "author": "Ivan Auda (ZTechnologies International)",
+  "typings": "index.d.ts",
+  "files": [
+    "lib/**/*"
+  ],
+  "scripts": {
+    "test": "jest --config jestconfig.json",
+    "build": "tsc",
+    "format": "prettier --write \"src/**/*.ts\" \"src/**/*.js\"",
+    "lint": "tslint -p tsconfig.json",
+    "preversion" : "npm run lint",
+    "version" : "npm run format && git add -A src",
+    "postversion" : "git push && git push --tags"
+  },
+  "keywords": [
+    "ztechno",
+    "core",
+    "utils",
+    "service"
+  ],
+  "devDependencies": {
+    "@types/jest": "^29.2.3",
+    "@types/mysql": "^2.15.21",
+    "jest": "^29.3.1",
+    "prettier": "^2.7.1",
+    "ts-jest": "^29.0.3",
+    "tslint": "^6.1.3",
+    "tslint-config-prettier": "^1.18.0",
+    "typescript": "^4.9.3"
+  },
+  "dependencies": {
+    "dom-parser": "^0.1.6",
+    "mysql": "^2.18.1",
+    "nodemailer": "^6.8.0",
+    "translate": "^1.4.1"
+  }
+}