akeyless-server-commons 1.0.200 → 1.0.204

package/dist/helpers/global_helpers.js

@@ -0,0 +1,147 @@
+import { readFileSync } from "fs";
+import { cache_manager, logger } from "../managers";
+import { LanguageOptions } from "akeyless-types-commons";
+import axios from "axios";
+import https from "https";
+export const init_env_variables = (required_vars = []) => {
+    required_vars.forEach((varName) => {
+        const env_val = process.env[varName];
+        if (!env_val) {
+            logger.error(`--- Error: Missing mandatory environment variable: ${varName}. ---`);
+            process.exit(1);
+        }
+    });
+    const env_vars = {};
+    Object.keys(process.env).forEach((var_name) => {
+        const env_val = process.env[var_name];
+        env_vars[var_name] = env_val;
+    });
+    return env_vars;
+};
+export const json_ok = (data) => {
+    return {
+        success: true,
+        data,
+    };
+};
+export const json_failed = (error, msg) => {
+    return {
+        success: false,
+        error: error.message || error || "general error: something happened ",
+        msg: msg,
+    };
+};
+export const parse_error = (error) => {
+    return error instanceof Error ? { name: error.name, message: error.message } : error;
+};
+export const get_version = (packageJsonPath) => {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    return packageJson.version;
+};
+export const sleep = (ms = 2500) => new Promise((resolve) => setTimeout(resolve, ms));
+const BASE_URLS = {
+    local: {
+        bi: "http://localhost:9002/api/bi",
+        call_center: "http://localhost:9003/api/call-center",
+        dashboard: "http://localhost",
+        devices: "http://localhost:9001/api/devices",
+        end_users: "http://10.100.102.9:9011/api/end-users",
+        notifications: "http://localhost:9006/api/notifications",
+        installer: "http://localhost",
+        ox_server: "http://localhost",
+        toolbox: "http://localhost",
+    },
+    prod: {
+        bi: "https://nx-api.info/api/bi",
+        call_center: "https://nx-api.info/api/call-center",
+        dashboard: "https://akeyless-dashboard.online",
+        devices: "https://nx-api.info/api/devices",
+        end_users: "https://nx-api.info/api/end-users",
+        notifications: "https://nx-api.info/api/notifications",
+        installer: "https://installerapp.online",
+        ox_server: "https://akeyless-online.info",
+        toolbox: "https://akeyless-toolbox.online",
+    },
+    qa: {
+        bi: "https://nx-api.xyz/api/bi",
+        call_center: "https://nx-api.xyz/api/call-center",
+        dashboard: "https://akeyless-dashboard.xyz",
+        devices: "https://nx-api.xyz/api/devices",
+        end_users: "https://nx-api.xyz/api/end-users",
+        notifications: "https://nx-api.xyz/api/notifications",
+        installer: "https://installerapp.xyz",
+        ox_server: "https://akeyless-online.xyz",
+        toolbox: "https://akeyless-toolbox.xyz",
+    },
+};
+export function get_nx_service_urls(env_name = "mode") {
+    const env_value = process.env[env_name]?.toLowerCase();
+    if (!env_value)
+        throw new Error(`missing [${env_name}] environment variable`);
+    const env_key = ["production", "prod"].includes(env_value) ? "prod" : env_value === "qa" ? "qa" : "local";
+    return BASE_URLS[env_key];
+}
+export const get_address_by_geo = async ({ lat, lng }, currentLanguage) => {
+    const address_not_found = "";
+    if (lat < -90 || lat > 90 || lng < -180 || lng > 180) {
+        return address_not_found;
+    }
+    const language = currentLanguage === LanguageOptions.He ? "iw" : "en";
+    const google_setting = cache_manager.getObjectData("nx-settings")["google"];
+    const geocode_api_key = google_setting["geocode_api_key"];
+    if (!geocode_api_key) {
+        throw new Error("missing env google api key");
+    }
+    const url = `https://maps.googleapis.com/maps/api/geocode/json?latlng=${lat},${lng}&key=${geocode_api_key}&language=${language}`;
+    try {
+        const response = await axios.get(url);
+        if (response?.data?.results[0]) {
+            return response.data.results[0].formatted_address.slice(0, 35);
+        }
+        else {
+            return address_not_found;
+        }
+    }
+    catch (error) {
+        logger.error("getAddressByGeo error:", error);
+        return address_not_found;
+    }
+};
+export const validate_and_cast = (variable, condition) => !!condition;
+export const get_or_default = (value, default_value) => {
+    if (value !== undefined) {
+        return value;
+    }
+    return typeof default_value === "function" ? default_value() : default_value;
+};
+export const trim_strings = (input) => {
+    if (typeof input === "string") {
+        return input.trim();
+    }
+    if (Array.isArray(input)) {
+        return input.map(trim_strings);
+    }
+    if (input instanceof Date || input instanceof RegExp || input instanceof Map || input instanceof Set) {
+        return input;
+    }
+    if (input !== null && typeof input === "object") {
+        const trimmed_object = {};
+        for (const key of Object.getOwnPropertyNames(input)) {
+            if (Object.prototype.hasOwnProperty.call(input, key)) {
+                trimmed_object[key] = trim_strings(input[key]);
+            }
+        }
+        return trimmed_object;
+    }
+    return input;
+};
+export const remove_nulls_and_undefined = (obj) => {
+    return Object.fromEntries(Object.entries(obj).filter(([_, value]) => value !== undefined && value !== null));
+};
+export const ignore_ssl_request = async (config) => {
+    const { mode } = init_env_variables(["mode"]);
+    if (mode === "qa") {
+        config.httpsAgent = new https.Agent({ rejectUnauthorized: false });
+    }
+    return await axios(config);
+};

package/dist/helpers/index.js

@@ -0,0 +1,12 @@
+export * from "./global_helpers";
+export * from "./firebase_helpers";
+export * from "./start";
+export * from "./time_helpers";
+export * from "./login_helpers";
+export * from "./notification_helpers";
+export * from "./email_helpers";
+export * from "./phone_number_helpers";
+export * from "./tasks_helpers";
+export * from "./boards_helpers";
+export * from "./redis";
+export * from "./location_helpers";

package/dist/helpers/location_helpers.js

@@ -0,0 +1,15 @@
+export const get_distance_in_meters_between_geo_points = (location1, location2) => {
+    const toRadians = (angle) => angle * (Math.PI / 180);
+    const R = 6371e3;
+    const φ1 = toRadians(location1.lat);
+    const φ2 = toRadians(location2.lat);
+    const Δφ = toRadians(location2.lat - location1.lat);
+    const Δλ = toRadians(location2.lng - location1.lng);
+    const a = Math.sin(Δφ / 2) * Math.sin(Δφ / 2) + Math.cos(φ1) * Math.cos(φ2) * Math.sin(Δλ / 2) * Math.sin(Δλ / 2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    // distance in meters
+    return R * c;
+};
+export const get_location_url = (location) => {
+    return `https://www.google.com/maps?q=${location.lat},${location.lng}`;
+};

package/dist/helpers/login_helpers.js

@@ -0,0 +1,18 @@
+import { query_document_optional } from "./firebase_helpers";
+export const convert_to_short_phone_number = (phone_number) => {
+    return `0${phone_number.split("+972")[1]}`;
+};
+/// nx user
+export const get_user_by_identifier = async (identifier, ignore_log = false) => {
+    if (identifier.includes("@") && identifier.includes(".")) {
+        const email_query = await query_document_optional("nx-users", "email", "==", identifier, ignore_log);
+        return email_query;
+    }
+    const phone_query = await query_document_optional("nx-users", "phone_number", "in", [convert_to_short_phone_number(identifier), identifier], ignore_log);
+    return phone_query;
+};
+/// mobile app user
+export const get_mobile_app_user_by_uid = async (uid, ignore_log = false) => {
+    const user = (await query_document_optional("mobile_users_app_pro", "uid", "==", uid, ignore_log));
+    return user;
+};

package/dist/helpers/notification_helpers.js

@@ -0,0 +1,248 @@
+import axios from "axios";
+import { cache_manager, logger, translation_manager } from "../managers";
+import { add_document, messaging, add_audit_record, get_nx_settings } from "./firebase_helpers";
+import { is_iccid, is_international_phone_number, is_israel_long_phone_number, is_thailand_long_phone_number } from "./phone_number_helpers";
+import { Twilio } from "twilio";
+import { Timestamp } from "firebase-admin/firestore";
+import { v4 as uniqId } from "uuid";
+import FormData from "form-data";
+const send_local_sms = async (recepient, text, details) => {
+    const { sms_provider: { multisend }, } = cache_manager.getObjectData("nx-settings");
+    const msgId = uniqId();
+    let data = new FormData();
+    data.append("user", multisend.user);
+    data.append("password", multisend.password);
+    data.append("from", multisend.from);
+    data.append("recipient", recepient);
+    data.append("message", text);
+    data.append("customermessageid", msgId);
+    if (is_international_phone_number(recepient)) {
+        data.append("international", "1");
+    }
+    const config = {
+        method: "post",
+        maxBodyLength: Infinity,
+        url: "https://api.multisend.co.il/v2/sendsms",
+        data: data,
+    };
+    const response = await axios(config);
+    if (response.status !== 200) {
+        throw `multisend request failed , status: ${response.status} , data: ${JSON.stringify(response.data)}`;
+    }
+    if (!response.data.success) {
+        throw `http request to multisend error ${JSON.stringify(response.data.error)}`;
+    }
+    await keep_outgoing_sms(recepient, text, "multisend", msgId, details);
+    logger.log("send_local_sms. message sent successfully", { number: recepient, text, response: response.data });
+    return "multisend";
+};
+const send_international_sms = async (recepient, text, details) => {
+    const { sms_provider: { twilio }, } = cache_manager.getObjectData("nx-settings");
+    const twilioClient = new Twilio(twilio.account_sid, twilio.token);
+    const message = await twilioClient.messages.create({
+        messagingServiceSid: twilio.messaging_service_sid,
+        body: text,
+        to: recepient,
+    });
+    logger.log("twilio response", message);
+    if (message.errorMessage) {
+        throw `twilioClient.messages.create failed: ${message.errorMessage} `;
+    }
+    await keep_outgoing_sms(recepient, text, "twilio", message.sid, details);
+    logger.log("send_international_sms. message sent successfully", { number: recepient, text, response: message });
+    return "twilio";
+};
+const login_to_monogoto = async () => {
+    try {
+        const { sms_provider: { monogoto }, } = cache_manager.getObjectData("nx-settings");
+        const data = { username: monogoto.user, password: monogoto.password };
+        const response = await axios({
+            method: "post",
+            url: `https://api.monogoto.io/api/v1/auth/login`,
+            data,
+        });
+        return response.data;
+    }
+    catch (error) {
+        logger.error("monogoto login error:", error);
+        throw `login_to_monogoto failed: ` + error;
+    }
+};
+const send_iccid_sms = async (recepient, text, details) => {
+    const { sms_provider: { monogoto }, } = cache_manager.getObjectData("nx-settings");
+    const monogoto_auth = await login_to_monogoto();
+    const data = { message: text, from: monogoto.from };
+    const response = await axios({
+        method: "post",
+        url: `https://api.monogoto.io/api/v1/things/sms/sendSMS/${recepient}`,
+        data: data,
+        headers: {
+            Authorization: `Bearer ${monogoto_auth.access_token}`,
+        },
+    });
+    if (response.status !== 200) {
+        throw `monogoto request failed , status: ${response.status} , data: ${JSON.stringify(response.data)}`;
+    }
+    await keep_outgoing_sms(recepient, text, "monogoto", response.data, details);
+    logger.log("send_iccid_sms. message sent successfully", { number: recepient, text, response: response.data });
+    return "monogoto";
+};
+export const send_sms = async (recepient, text, entity_for_audit, details) => {
+    try {
+        let sms_to_send = [];
+        const { sms_groups } = await get_nx_settings();
+        if (sms_groups && sms_groups.values[recepient]) {
+            sms_groups.values[recepient].forEach((number) => {
+                sms_to_send.push(number);
+            });
+        }
+        else {
+            sms_to_send.push(recepient);
+        }
+        sms_to_send = [...new Set(sms_to_send)];
+        const promises = sms_to_send.map(async (number) => {
+            let service = null;
+            const is_international = is_international_phone_number(number) && !is_thailand_long_phone_number(number) && !is_israel_long_phone_number(number);
+            if (is_iccid(number)) {
+                service = await send_iccid_sms(number, text, details);
+            }
+            else if (is_international) {
+                service = await send_international_sms(number, text, details);
+            }
+            else {
+                service = await send_local_sms(number, text, details);
+            }
+            await add_audit_record("send_sms", entity_for_audit || "general", {
+                recepient: number,
+                message: text,
+                service,
+            });
+        });
+        await Promise.all(promises);
+    }
+    catch (error) {
+        logger.error(`${entity_for_audit}, send_sms failed:`, error);
+        throw `${entity_for_audit}, send_sms failed: ` + error;
+    }
+};
+const keep_outgoing_sms = async (recepient, content, service, external_id, details) => {
+    const timestamp = Timestamp.now();
+    const data = {
+        external_id,
+        content,
+        recipient: recepient,
+        service,
+        timestamp,
+        status: "new",
+    };
+    if (details) {
+        data.details = details;
+    }
+    await add_document("nx-sms-out", data);
+};
+export const push_event_to_mobile_users = async (event) => {
+    const units = cache_manager.getArrayData("units");
+    const users_units = cache_manager.getArrayData("usersUnits");
+    const mobile_users_app_pro = cache_manager.getArrayData("mobile_users_app_pro");
+    const app_pro_extra_pushes = cache_manager.getArrayData("app_pro_extra_pushes");
+    console.log(`units: ${units.length}, users_units: ${users_units.length}, mobile_users_app_pro: ${mobile_users_app_pro.length}, app_pro_extra_pushes: ${app_pro_extra_pushes.length}`);
+    if (!units.length || !users_units.length || !mobile_users_app_pro.length) {
+        throw "push_event_to_mobile_users. missing cached data for any of the following: units, usersUnits, mobile_users_app_pro, app_pro_extra_pushes";
+    }
+    ///-- main driver
+    const unit = units.find((unit) => unit.carId == event.car_number);
+    const main_driver = mobile_users_app_pro.find((user) => user.short_phone_number == unit.userPhone);
+    ///-- secondary drivers
+    const secondary_units = users_units.filter((unit) => unit.carId == event.car_number);
+    const secondary_phone_numbers = secondary_units.map((unit) => unit.phone);
+    const secondary_drivers = mobile_users_app_pro.filter((user) => secondary_phone_numbers.includes(user.long_phone_number));
+    ///-- extra users
+    const extra_uids = app_pro_extra_pushes.filter((doc) => doc.car_number == event.car_number).map((doc) => doc.uid);
+    const extra_drivers = extra_uids.length > 0 ? mobile_users_app_pro.filter((user) => extra_uids.includes(user.uid)) : [];
+    const drivers = [main_driver, ...secondary_drivers, ...extra_drivers];
+    for (const mobile_user of drivers) {
+        const source = event.source == "erm" || event.source == "erm2" ? "erm" : event.source;
+        if (mobile_user.disabled_events?.[event.car_number]?.[source]?.includes(event.event_id)) {
+            logger.log(`push_event_to_mobile_users. event ${event.event_id} / ${event.event_name} is disabled for user ${mobile_user.uid} / ${mobile_user.short_phone_number}`);
+            continue;
+        }
+        const mobile_user_language = mobile_user.language;
+        const language = { heb: "he", en: "en", ru: "ru" }[mobile_user_language];
+        const message_title = translation_manager.get_translation("push_notifications", language, "title", "event_from_device");
+        const message_body = translation_manager.get_translation("events_from_device", language, "", event.event_name);
+        await send_fcm_message(message_title, message_body, [mobile_user.fcm_token], "");
+    }
+};
+export const send_fcm_message = async (title, body, fcm_tokens, custom_sound) => {
+    fcm_tokens = [...new Set(fcm_tokens)];
+    if (fcm_tokens.length == 0) {
+        return {
+            success: false,
+            response: "No recipients",
+        };
+    }
+    if (fcm_tokens.length == 0) {
+        return {
+            success: false,
+            response: "No recipients",
+            success_count: 0,
+            failure_count: 0,
+        };
+    }
+    const message = {
+        tokens: fcm_tokens,
+        notification: {
+            title: title,
+            body: body,
+        },
+        android: {
+            ttl: 3600 * 1000,
+            priority: "high",
+            notification: {
+                sound: custom_sound || "default",
+                channelId: custom_sound,
+                title: title,
+                body: body,
+            },
+        },
+        apns: {
+            payload: {
+                aps: {
+                    sound: custom_sound ? `${custom_sound}.wav` : "default",
+                    alert: {
+                        title: title,
+                        body: body,
+                    },
+                },
+            },
+        },
+    };
+    try {
+        const response = await messaging.sendEachForMulticast(message);
+        const { successCount: success_count, failureCount: failure_count, responses } = response;
+        if (success_count && !failure_count) {
+            logger.log(`send_fcm_message. Successfully sent to all ${success_count} recipients. `, { title, body });
+        }
+        else if (success_count && failure_count) {
+            logger.log(`send_fcm_message. Successfully sent to ${success_count} recipients, but failed to sent to ${failure_count} recipients`, {
+                title,
+                body,
+                responses,
+            });
+        }
+        else {
+            logger.log(`send_fcm_message. Failed to sent to ${failure_count} recipients`, { title, body, responses: response.responses });
+        }
+        return {
+            success: success_count > 0 && failure_count == 0,
+            response: JSON.stringify(response.responses),
+        };
+    }
+    catch (error) {
+        logger.error("Exception", error.message);
+        return {
+            success: false,
+            response: `Exception: ${error.message}`,
+        };
+    }
+};

package/dist/helpers/phone_number_helpers.js

@@ -0,0 +1,96 @@
+import { SimProvider } from "../types/enums";
+export const is_long_phone_number = (phone_number) => {
+    return phone_number.startsWith("+");
+};
+export const is_israel_long_phone_number = (phone_number) => {
+    return phone_number.startsWith("+972");
+};
+export const is_thailand_long_phone_number = (phone_number) => {
+    return phone_number.startsWith("+66");
+};
+export const is_international_phone_number = (phone_number) => {
+    return is_long_phone_number(phone_number) && !is_israel_long_phone_number(phone_number);
+};
+export const is_iccid = (number) => {
+    if (number.length < 19 || number.length > 22)
+        return false;
+    if (!/^\d+$/.test(number))
+        return false;
+    if (!number.startsWith("89"))
+        return false;
+    return true;
+};
+export const convert_to_short_israel_phone = (international_number) => {
+    const base = international_number.replace("+972", "");
+    return base.startsWith("130") ? base : `0${base}`;
+};
+export const is_sim_provider_partner = (phone_number) => {
+    const { short_phone_number } = long_short_phone_numbers(phone_number);
+    return short_phone_number.startsWith("054") || short_phone_number.startsWith("1302");
+};
+export const is_sim_provider_pelephone = (phone_number) => {
+    const { short_phone_number } = long_short_phone_numbers(phone_number);
+    return short_phone_number.startsWith("050");
+};
+export const is_sim_provider_celcom = (phone_number) => {
+    const { short_phone_number } = long_short_phone_numbers(phone_number);
+    return short_phone_number.startsWith("052") || short_phone_number.startsWith("1303");
+};
+export const is_sim_provider_monogoto = (phone_number) => {
+    return is_iccid(phone_number);
+};
+export const get_sim_provider = (phone_number) => {
+    if (is_sim_provider_partner(phone_number)) {
+        return SimProvider.partner;
+    }
+    if (is_sim_provider_pelephone(phone_number)) {
+        return SimProvider.pelephone;
+    }
+    if (is_sim_provider_celcom(phone_number)) {
+        return SimProvider.celcom;
+    }
+    if (is_sim_provider_monogoto(phone_number)) {
+        return SimProvider.monogoto;
+    }
+    return SimProvider.unknown;
+};
+export const long_short_phone_numbers = (phone_number) => {
+    phone_number = phone_number.trim();
+    if (!phone_number.length) {
+        return {
+            short_phone_number: phone_number,
+            long_phone_number: phone_number,
+            is_israeli: true,
+        };
+    }
+    if (is_iccid(phone_number)) {
+        return {
+            short_phone_number: phone_number,
+            long_phone_number: phone_number,
+            is_israeli: false,
+        };
+    }
+    let short_phone_number = phone_number;
+    let long_phone_number = phone_number;
+    if (phone_number.startsWith("05")) {
+        short_phone_number = phone_number;
+        long_phone_number = long_phone_number.replace("05", "+9725");
+    }
+    else if (phone_number.startsWith("103")) {
+        short_phone_number = phone_number;
+        long_phone_number = `+972${short_phone_number}`;
+    }
+    else if (phone_number.startsWith("+972")) {
+        long_phone_number = phone_number;
+        short_phone_number = long_phone_number.replace("+9725", "05");
+    }
+    else if (phone_number.startsWith("+1")) {
+        long_phone_number = phone_number;
+        short_phone_number = long_phone_number.replace("+1", "");
+    }
+    return {
+        short_phone_number,
+        long_phone_number,
+        is_israeli: long_phone_number.startsWith("+972"),
+    };
+};