akeyless-server-commons 1.0.191 → 1.0.193

package/dist/helpers/redis/keys.js

@@ -1,23 +0,0 @@
-import { REDIS_UPDATES_PREFIX } from "akeyless-types-commons";
-const get_key = (...args) => {
-    return args.join(":");
-};
-export const get_doc_key = (collection, doc_id) => {
-    return get_key(collection, doc_id);
-};
-export const get_collection_keys = (collection) => {
-    return get_key(collection, "*");
-};
-export const get_channel = (...args) => {
-    return get_key(REDIS_UPDATES_PREFIX, ...args);
-};
-export const scan_redis_keys = async (pattern, redis_publisher) => {
-    const found_keys = [];
-    let cursor = "0";
-    do {
-        const [next_cursor, keys] = await redis_publisher.scan(cursor, "MATCH", pattern, "COUNT", 100);
-        cursor = next_cursor;
-        found_keys.push(...keys);
-    } while (cursor !== "0");
-    return found_keys;
-};

package/dist/helpers/redis/snapshot.js

@@ -1,163 +0,0 @@
-import { get_redis_commander, get_redis_listener, redis_commander_connected, redis_listener_connected } from "./initialize";
-import { get_nx_settings, parse_add_update_as_array, parse_add_update_as_object, parse_delete_as_array, parse_delete_as_object, snapshot, } from "../firebase_helpers";
-import { get_collection_keys, scan_redis_keys } from "./keys";
-import { Timestamp } from "firebase-admin/firestore";
-import { logger } from "../../managers";
-const subscription_collections = new Set();
-export const redis_snapshots_bulk = async (configs) => {
-    /// on first time
-    for (const config of configs) {
-        const validation = await validate_config(config);
-        if (!validation.success) {
-            logger.warn(validation.message, config);
-            if (validation.trigger_firebase_snapshot) {
-                await snapshot(config);
-            }
-            continue;
-        }
-        await parse_redis_snapshot(config);
-    }
-    /// on update
-    get_redis_listener().on("pmessage", async (pattern, channel, message) => {
-        const { collection_name, update_type, data: doc } = JSON.parse(message);
-        const update = [convert_object_timestamps(doc)];
-        const relevant_configs = configs.filter((config) => config.collection_name === collection_name);
-        for (const config of relevant_configs) {
-            await parse_redis_snapshot(config, { update_type, update });
-        }
-    });
-};
-const validate_config = async (config) => {
-    const nx_settings = await get_nx_settings();
-    const cache_collections_config = nx_settings.cache_collections_config || {};
-    const { collection_name, cache_name = collection_name, subscription_type = "firebase" } = config;
-    if (!redis_commander_connected || !redis_listener_connected) {
-        return {
-            success: false,
-            trigger_firebase_snapshot: true,
-            message: `⚠️ Redis commander or listener not connected, triggered firebase snapshot for collection: "${collection_name}"`,
-        };
-    }
-    if (subscription_type === "firebase") {
-        return {
-            success: false,
-            trigger_firebase_snapshot: true,
-            message: `⚠️ subscription type is "firebase", triggered firebase snapshot for collection: "${collection_name}"`,
-        };
-    }
-    if (!cache_collections_config[collection_name] || cache_collections_config[collection_name].sync_direction === "redis_to_firebase") {
-        return {
-            success: false,
-            trigger_firebase_snapshot: true,
-            message: `⚠️ collection: "${collection_name}" not found in cache_collections_config in "nx-settings" or sync_direction is "redis_to_firebase", triggered firebase snapshot for collection: "${collection_name}"`,
-        };
-    }
-    if (subscription_collections.has(cache_name)) {
-        return {
-            success: false,
-            trigger_firebase_snapshot: false,
-            message: `⚠️ collection: "${collection_name}" already has a subscription, skipped redis snapshot for collection: "${collection_name}"`,
-        };
-    }
-    subscription_collections.add(cache_name);
-    return { success: true };
-};
-const parse_redis_snapshot = async (config, redis_update) => {
-    const { collection_name: config_collection_name, cache_name = config_collection_name, extra_parsers, parse_as, debug, on_add, on_remove, on_modify, } = config;
-    if (!redis_update) {
-        const init_data = await get_collection_data(config_collection_name);
-        default_parsers(parse_as, init_data, config);
-        if (debug?.on_first_time) {
-            logger.log(`${cache_name} => Redis snapshot on first time: `, debug.on_first_time === "documents" ? init_data : { length: init_data.length });
-        }
-        config.on_first_time?.(init_data, config);
-        extra_parsers?.forEach((parser) => {
-            if (debug?.extra_parsers?.on_first_time) {
-                logger.log(`${cache_name} => Redis snapshot extra parsers on first time: `, debug.extra_parsers.on_first_time === "documents" ? init_data : { length: init_data.length });
-            }
-            parser?.on_first_time?.(init_data, config);
-        });
-        return;
-    }
-    if (!subscription_collections.has(cache_name)) {
-        return;
-    }
-    const { update_type, update } = redis_update;
-    switch (update_type) {
-        case "add":
-            if (debug?.on_add) {
-                logger.log(`${cache_name} => Redis snapshot on add: `, update);
-            }
-            default_parsers(parse_as, update, config);
-            on_add?.(update, config);
-            extra_parsers?.forEach((parser) => {
-                if (debug?.extra_parsers?.on_add) {
-                    logger.log(`${cache_name} => Redis snapshot extra parsers on add: `, update);
-                }
-                parser?.on_add?.(update, config);
-            });
-            return;
-        case "update":
-            if (debug?.on_modify) {
-                logger.log(`${cache_name} => Redis snapshot on modify: `, update);
-            }
-            default_parsers(parse_as, update, config);
-            on_modify?.(update, config);
-            extra_parsers?.forEach((parser) => {
-                if (debug?.extra_parsers?.on_modify) {
-                    logger.log(`${cache_name} => Redis snapshot extra parsers on modify: `, update);
-                }
-                parser?.on_modify?.(update, config);
-            });
-            return;
-        case "delete":
-            if (debug?.on_remove) {
-                logger.log(`${cache_name} => Redis snapshot on remove: `, update);
-            }
-            if (parse_as === "object") {
-                parse_delete_as_object(update, config);
-            }
-            if (parse_as === "array") {
-                parse_delete_as_array(update, config);
-            }
-            on_remove?.(update, config);
-            extra_parsers?.forEach((parser) => {
-                if (debug?.extra_parsers?.on_remove) {
-                    logger.log(`${cache_name} => Redis snapshot extra parsers on remove: `, update);
-                }
-                parser?.on_remove?.(update, config);
-            });
-            return;
-        default:
-            return;
-    }
-};
-const default_parsers = (parse_as, update, config) => {
-    if (parse_as === "object") {
-        parse_add_update_as_object(update, config);
-    }
-    if (parse_as === "array") {
-        parse_add_update_as_array(update, config);
-    }
-};
-const get_collection_data = async (collection_name) => {
-    const redis_commander = get_redis_commander();
-    const keys = await scan_redis_keys(get_collection_keys(collection_name), redis_commander);
-    let collection_data = [];
-    if (keys.length > 0) {
-        const values = await redis_commander.mget(keys);
-        collection_data = values.filter(Boolean).map((v) => JSON.parse(v).data);
-    }
-    return collection_data.map((data) => convert_object_timestamps(data));
-};
-const convert_object_timestamps = (data) => {
-    Object.entries(data).forEach(([key, value]) => {
-        if (typeof value === "object" && value && value._seconds !== undefined) {
-            data[key] = new Timestamp(value._seconds, value._nanoseconds);
-        }
-        if (typeof value === "object" && value && value._seconds === undefined) {
-            convert_object_timestamps(value);
-        }
-    });
-    return data;
-};

package/dist/helpers/start.js

@@ -1,43 +0,0 @@
-import express from "express";
-import cors from "cors";
-import { logger } from "../managers";
-import { init_env_variables, init_snapshots } from "./";
-import { error_handler } from "../middlewares/error_handling";
-import { request_logger, trim_body_middleware } from "../middlewares";
-import { init_redis } from "./redis/initialize";
-export const start_server = async (main_router, project_name, version, { port, log_requests } = {}) => {
-    const app = express();
-    let env_data = init_env_variables(["mode"]);
-    port = port || Number(env_data.port);
-    app.use(cors());
-    app.use(express.json({ limit: "10mb" }));
-    app.use(express.urlencoded({ limit: "10mb", extended: true }));
-    app.use(trim_body_middleware());
-    app.use(request_logger(log_requests || {}));
-    main_router(app);
-    app.use(error_handler);
-    return new Promise((resolve) => {
-        app.listen(port, async () => {
-            logger.log(`Server is running at http://localhost:${port}`);
-            logger.log("project status", { project_name, version, environment: env_data.mode });
-            try {
-                await init_redis();
-            }
-            catch (err) {
-                logger.warn("Redis unavailable, continuing without it", { err });
-            }
-            resolve(app);
-        });
-    });
-};
-export const basic_init = async (main_router, project_name, version, { port, log_requests, init_snapshot_options } = {}) => {
-    try {
-        const app = await start_server(main_router, project_name, version, { port, log_requests });
-        await init_snapshots(init_snapshot_options);
-        return app;
-    }
-    catch (error) {
-        logger.error("Error from init function: ", error);
-        process.exit(1);
-    }
-};

package/dist/helpers/tasks_helpers.js

@@ -1,136 +0,0 @@
-import { cache_manager, logger } from "../managers";
-import { get_document_by_id_optional, set_document } from "./firebase_helpers";
-import admin from "firebase-admin";
-export var TaskName;
-(function (TaskName) {
-    TaskName["send_reset_sms"] = "send_reset_sms";
-    TaskName["collect_devices_health"] = "collect_devices_health";
-    TaskName["collect_charge_locations"] = "collect_charge_locations";
-    TaskName["collect_charge_cdrs"] = "collect_charge_cdrs";
-})(TaskName || (TaskName = {}));
-export var TaskStatus;
-(function (TaskStatus) {
-    TaskStatus["running"] = "running";
-    TaskStatus["completed"] = "completed";
-    TaskStatus["failed"] = "failed";
-    TaskStatus["suspeneded"] = "suspeneded";
-})(TaskStatus || (TaskStatus = {}));
-const save_task_data_in_cache = (task_name, data) => {
-    if (Array.isArray(data)) {
-        cache_manager.setArrayData(task_name, data);
-    }
-    else {
-        cache_manager.setObjectData(task_name, data);
-    }
-};
-export const execute_task = async (source, task_name, task, options) => {
-    const { debug_logs = true, save_in } = options || {};
-    try {
-        await set_document("nx-tasks", task_name, {
-            source,
-            status: TaskStatus.running,
-            started: new Date(),
-            timestamp: new Date(),
-            error: "",
-        }, false);
-        if (debug_logs) {
-            logger.log(`Task [${task_name}] started`);
-        }
-        const start = performance.now();
-        const data = await task();
-        const update = {
-            status: TaskStatus.completed,
-            completed: new Date(),
-            timestamp: new Date(),
-        };
-        if (data) {
-            if (save_in === "none") {
-                update.data = "no data to save";
-            }
-            else if (save_in === "storage" && typeof data === "object") {
-                save_task_data_in_cache(task_name, data);
-                const url = await keep_task_data_in_storage(task_name, data);
-                update.data = url;
-            }
-            else {
-                save_task_data_in_cache(task_name, data);
-                update.data = data;
-            }
-        }
-        else {
-            update.data = "no data to save";
-        }
-        await set_document("nx-tasks", task_name, update);
-        if (debug_logs) {
-            logger.log(`Task [${task_name}] ended. It took ${Math.round(performance.now() - start)} ms`);
-        }
-    }
-    catch (exception) {
-        const error_for_db = exception instanceof Error ? exception.message : exception;
-        logger.error(`Task [${task_name}] error`, error_for_db);
-        await set_document("nx-tasks", task_name, {
-            status: TaskStatus.failed,
-            completed: new Date(),
-            timestamp: new Date(),
-            error: error_for_db,
-        });
-    }
-};
-export const get_task_data = async (task_name) => {
-    const cached_data = cache_manager.getArrayData(task_name);
-    const cached_data_object = cache_manager.getObjectData(task_name, null);
-    if (cached_data.length > 0) {
-        return cached_data;
-    }
-    if (cached_data_object) {
-        return cached_data;
-    }
-    const task_data = await get_document_by_id_optional("nx-tasks", task_name);
-    if (typeof task_data?.data === "string" && task_data.data.startsWith("http")) {
-        const storage_data = await get_task_data_from_storage(task_name);
-        if (storage_data) {
-            const value = storage_data;
-            save_task_data_in_cache(task_name, storage_data);
-            return value;
-        }
-    }
-    const value = typeof task_data?.data === "object" ? task_data.data : null;
-    if (value) {
-        save_task_data_in_cache(task_name, value);
-    }
-    return value || [];
-};
-export const get_task_data_from_storage = async (task_name) => {
-    const bucket = admin.storage().bucket();
-    const file = bucket.file(`tasks_data/${task_name}.json`);
-    try {
-        const [contents] = await file.download();
-        return JSON.parse(contents.toString("utf-8"));
-    }
-    catch (error) {
-        logger.error("Task error reading file from Firebase Storage:", error);
-        return null;
-    }
-};
-export const keep_task_data_in_storage = async (task_name, data) => {
-    const bucket = admin.storage().bucket();
-    const file = bucket.file(`tasks_data/${task_name}.json`);
-    try {
-        if (typeof data !== "object") {
-            throw new Error("Only arrays or objects can be written");
-        }
-        const json_string = JSON.stringify(data, null);
-        await file.save(json_string, {
-            contentType: "application/json",
-        });
-        const [signed_url] = await file.getSignedUrl({
-            action: "read",
-            expires: Date.now() + 1000 * 60 * 60 * 24 * 7,
-        });
-        return signed_url;
-    }
-    catch (error) {
-        logger.error("Error writing file to Firebase Storage:", error);
-        return "";
-    }
-};

package/dist/helpers/time_helpers.js

@@ -1,167 +0,0 @@
-import { Timestamp } from "firebase-admin/firestore";
-import moment from "moment";
-export function sort_by_timestamp(a, b, reverse = false) {
-    return reverse ? any_datetime_to_millis(b) - any_datetime_to_millis(a) : any_datetime_to_millis(a) - any_datetime_to_millis(b);
-}
-export const calculate_time_passed = (datetime) => {
-    const now = new Date();
-    const diff_in_milliseconds = Math.max(0, now.getTime() - datetime.getTime());
-    const seconds_passed = Math.floor(diff_in_milliseconds / 1000);
-    const minutes_passed = Math.floor(seconds_passed / 60);
-    const hours_passed = Math.floor(minutes_passed / 60);
-    const days_passed = Math.floor(hours_passed / 24);
-    const remaining_hours = hours_passed % 24;
-    const remaining_minutes = minutes_passed % 60;
-    const remaining_seconds = seconds_passed % 60;
-    const pad_zero = (value) => (value < 10 ? `0${value}` : `${value}`);
-    let parts = [];
-    if (days_passed > 0)
-        parts.push(days_passed);
-    if (remaining_hours > 0 || days_passed > 0)
-        parts.push(pad_zero(remaining_hours));
-    parts.push(pad_zero(remaining_minutes));
-    parts.push(pad_zero(remaining_seconds));
-    const time_passed_formatted_short = parts.join(":");
-    parts = [];
-    if (days_passed > 0)
-        parts.push(`${days_passed} d`);
-    if (days_passed > 0 || remaining_hours > 0)
-        parts.push(`${remaining_hours} h`);
-    if (days_passed > 0 || remaining_hours > 0 || remaining_minutes > 0)
-        parts.push(`${remaining_minutes} min`);
-    parts.push(`${remaining_seconds} sec`);
-    const time_passed_formatted_long = parts.join(" ");
-    return {
-        seconds_passed,
-        minutes_passed,
-        hours_passed,
-        days_passed,
-        time_passed_formatted_short,
-        time_passed_formatted_long,
-    };
-};
-export function any_datetime_to_string(firebaseTimestamp, options) {
-    const { defaultReturnedValue, format, fromFormat, tz, debug } = {
-        defaultReturnedValue: options?.defaultReturnedValue ?? "-",
-        format: options?.format ?? "DD/MM/YYYY HH:mm:ss",
-        fromFormat: options?.fromFormat ?? "DD/MM/YYYY HH:mm:ss",
-        tz: options?.tz,
-        debug: options?.debug ?? false,
-    };
-    let date;
-    switch (true) {
-        case !firebaseTimestamp: {
-            return defaultReturnedValue;
-        }
-        case firebaseTimestamp instanceof Timestamp: {
-            date = firebaseTimestamp.toDate();
-            break;
-        }
-        case firebaseTimestamp instanceof Date: {
-            date = firebaseTimestamp;
-            break;
-        }
-        case typeof firebaseTimestamp === "string" || typeof firebaseTimestamp === "number": {
-            const m = moment.utc(firebaseTimestamp, fromFormat);
-            switch (m.isValid()) {
-                case true:
-                    date = m.toDate();
-                    break;
-                default:
-                    return defaultReturnedValue;
-            }
-            break;
-        }
-        case !!firebaseTimestamp._seconds: {
-            const ft = firebaseTimestamp;
-            date = new Date(ft._seconds * 1000 + (ft._nanoseconds ?? 0) / 1000000);
-            break;
-        }
-        case !!firebaseTimestamp.seconds: {
-            const ft = firebaseTimestamp;
-            date = new Date(ft.seconds * 1000 + ft.nanoseconds / 1000000);
-            break;
-        }
-        default: {
-            if (debug) {
-                console.error("Invalid timestamp format: ", firebaseTimestamp);
-            }
-            return defaultReturnedValue;
-        }
-    }
-    switch (Boolean(tz)) {
-        case true:
-            return moment(date)
-                .tz(tz)
-                .format(format);
-        default:
-            return moment.utc(date).format(format);
-    }
-}
-export function any_datetime_to_millis(firebaseTimestamp, options) {
-    const { defaultReturnedValue, fromFormat, tz, debug } = {
-        defaultReturnedValue: options?.defaultReturnedValue ?? 0,
-        fromFormat: options?.fromFormat ?? "DD/MM/YYYY HH:mm:ss",
-        tz: options?.tz,
-        debug: options?.debug ?? false,
-    };
-    switch (true) {
-        case !firebaseTimestamp: {
-            return defaultReturnedValue;
-        }
-        case firebaseTimestamp instanceof Timestamp: {
-            return firebaseTimestamp.toMillis();
-        }
-        case firebaseTimestamp instanceof Date: {
-            const ms = firebaseTimestamp.getTime();
-            return isNaN(ms) ? defaultReturnedValue : ms;
-        }
-        case typeof firebaseTimestamp === "string" || typeof firebaseTimestamp === "number": {
-            const m = moment.utc(firebaseTimestamp, fromFormat);
-            switch (m.isValid()) {
-                case true:
-                    return m.valueOf();
-                default:
-                    return defaultReturnedValue;
-            }
-        }
-        case !!firebaseTimestamp._seconds: {
-            const seconds = firebaseTimestamp._seconds;
-            const nanos = firebaseTimestamp._nanoseconds ?? 0;
-            return seconds * 1000 + Math.floor(nanos / 1000000);
-        }
-        case !!firebaseTimestamp.seconds: {
-            const seconds = firebaseTimestamp.seconds;
-            const nanos = firebaseTimestamp.nanoseconds ?? 0;
-            return seconds * 1000 + Math.floor(nanos / 1000000);
-        }
-        default: {
-            if (debug) {
-                console.error("Invalid timestamp format: ", firebaseTimestamp);
-            }
-            return defaultReturnedValue;
-        }
-    }
-}
-// old versions of the functions kept for backward compatibility
-/**
- * Converts a Firebase Timestamp object into a formatted string.
- *
- * @param {firebase_timestamp} firebaseTimestamp - The Firebase timestamp object containing _seconds and _nanoseconds.
- * @param {string} [format="DD-MM-YYYY HH:mm:ss"] - Optional the format string used to format the date. Default is "DD-MM-YYYY HH:mm:ss".
- * @returns {string} - A formatted date string according to the specified format or the default format.
- */
-export function timestamp_to_string(firebaseTimestamp, format = "DD-MM-YYYY HH:mm:ss") {
-    const timestamp = new Timestamp(firebaseTimestamp._seconds, firebaseTimestamp._nanoseconds);
-    return moment(timestamp.toDate()).utc().format(format);
-}
-/**
- * Converts a Firebase Timestamp object into milliseconds since the Unix epoch.
- *
- * @param {firebase_timestamp} firebaseTimestamp - The Firebase timestamp object containing _seconds and _nanoseconds.
- * @returns {number} - Time in milliseconds
- */
-export function timestamp_to_millis(firebaseTimestamp) {
-    const timestamp = new Timestamp(firebaseTimestamp._seconds, firebaseTimestamp._nanoseconds);
-    return timestamp.toMillis();
-}

package/dist/index.js

@@ -1,5 +0,0 @@
-import * as helpers from "./helpers";
-import * as managers from "./managers";
-import * as middlewares from "./middlewares";
-import * as types from "./types";
-export { helpers, managers, middlewares, types };

package/dist/managers/cache_manager.js

@@ -1,27 +0,0 @@
-export class CacheManager {
-    constructor() {
-        this.data = {};
-    }
-    static getInstance() {
-        if (!CacheManager.instance) {
-            CacheManager.instance = new CacheManager();
-        }
-        return CacheManager.instance;
-    }
-    setArrayData(key, data) {
-        this.data[key] = data;
-    }
-    getArrayData(key) {
-        if (!this.data[key]) {
-            return [];
-        }
-        return this.data[key];
-    }
-    setObjectData(key, data) {
-        this.data[key] = data;
-    }
-    getObjectData(key, default_value = null) {
-        return this.data[key] || default_value;
-    }
-}
-export const cache_manager = CacheManager.getInstance();

package/dist/managers/index.js

@@ -1,3 +0,0 @@
-export * from "./cache_manager";
-export * from "./translation_manager";
-export * from "./logger_manager";

package/dist/managers/logger_manager.js

@@ -1,51 +0,0 @@
-import moment_timezone from "moment-timezone";
-import axios from "axios";
-import { isObject } from "lodash";
-import { parse_error } from "../helpers";
-class LoggerManager {
-    constructor() { }
-    static getInstance() {
-        if (!LoggerManager.instance) {
-            LoggerManager.instance = new LoggerManager();
-        }
-        return LoggerManager.instance;
-    }
-    get_date() {
-        return moment_timezone().tz("Asia/Jerusalem").format("DD/MM/YYYY HH:mm:ss.SS");
-    }
-    log(msg, data) {
-        const is_table = !process.env.KUBERNETES_SERVICE_HOST &&
-            Array.isArray(data) &&
-            data.length > 1 &&
-            data.every((val) => {
-                if (typeof val === "object" && !Array.isArray(val)) {
-                    return Object.values(val).every((v) => ["string", "number", "boolean"].includes(typeof v) || v === null);
-                }
-                return false;
-            }) &&
-            data.some((val) => Object.values(val).length > 1);
-        if (is_table) {
-            console.log(`${this.get_date()} - `, msg, ": ");
-            console.table(data);
-            return;
-        }
-        console.log(`${this.get_date()} - ${msg}`, data === undefined ? "" : `: ${isObject(data) || Array.isArray(data) ? JSON.stringify(data) : data}`);
-    }
-    error(msg, data) {
-        if (axios.isAxiosError(data)) {
-            if (!!data.response?.data) {
-                console.error(`${this.get_date()} - ${msg}, axios error: ${data.message}, data: ${JSON.stringify(data)}`);
-            }
-            else {
-                console.error(`${this.get_date()} - ${msg}, axios error: ${data.message}`);
-            }
-        }
-        else {
-            console.error(`${this.get_date()} - ${msg}`, data === undefined ? "" : `: ${JSON.stringify(parse_error(data))}`);
-        }
-    }
-    warn(msg, data) {
-        console.warn(`${this.get_date()} - ${msg}`, data === undefined ? "" : `: ${JSON.stringify(data)}`);
-    }
-}
-export const logger = LoggerManager.getInstance();

package/dist/managers/translation_manager.js

@@ -1,38 +0,0 @@
-export class TranslationManager {
-    constructor() {
-        this.data = {};
-    }
-    static getInstance() {
-        if (!TranslationManager.instance) {
-            TranslationManager.instance = new TranslationManager();
-        }
-        return TranslationManager.instance;
-    }
-    setTranslationData(data) {
-        this.data = data;
-    }
-    getTranslationData() {
-        return this.data;
-    }
-    get_translation(scope, lang, entity, key) {
-        key = entity + (entity === "" ? "" : "__") + key;
-        return this.data[scope][lang][key] || key;
-    }
-    get_sms(lang, entity, key) {
-        try {
-            return this.data["sms"][lang][entity + "__" + key];
-        }
-        catch (error) {
-            return "N/A";
-        }
-    }
-    get_email(lang, entity, key) {
-        try {
-            return this.data["email"][lang][entity + "__" + key];
-        }
-        catch (error) {
-            return "N/A";
-        }
-    }
-}
-export const translation_manager = TranslationManager.getInstance();