@diagramers/cli 1.0.23 → 1.0.24

package/templates/api/src/helpers/cronHelper.ts

@@ -0,0 +1,170 @@
+import * as cron from 'node-cron';
+import { AuditMessageType, ResponseCode, ScheduleSlot } from '../helpers/enums';
+import { Result } from '../helpers/result';
+import { ObjectId } from 'bson';
+import { Config } from '../config';
+
+interface ScheduleData {
+    cronExpression: string;
+    startTime?: Date;
+    timeZone?: string;
+    frequency?: number; // Frequency in milliseconds for repetition
+}
+
+interface ScheduleOptions {
+    _id: ObjectId;
+    name: String;
+    _taskScheduleId: ObjectId;
+    slot: ScheduleSlot,
+    _taskRunId: ObjectId;
+    startAt: Date,
+    onExecutionScript: String,
+    onSuccessScript: String,
+    onFailureScript: String,
+    onFinalizeScript: String,
+    className: String,
+    methodName: String,
+    taskType: Number
+}
+
+class CronHelper {
+    private static instance: CronHelper;
+    private scheduledJobs: Map<string, cron.ScheduledTask> = new Map();
+    result: Result;
+    className: 'CronHelper';
+    private constructor(
+        result: Result
+    ) {
+        this.result = result;
+    }
+
+    public static getInstance(): CronHelper {
+        if (!CronHelper.instance) {
+            CronHelper.instance = new CronHelper(new Result(null, ResponseCode.Incompelete, [], [], new ObjectId().toString(), {}, {}));
+        }
+        return CronHelper.instance;
+    }
+
+    public async scheduleTask(taskId): Promise<Result> {
+        // const { slot, scheduleData, taskScript, onSuccess, onFailure, onFinish } = options //task-schedule-entity;
+        try {
+            this.result.addMessage(AuditMessageType.info, this.className, 'scheduleTask', `Started`);
+            var taskService = null;//new TaskService(this.result);
+            var scheduleTaskForRun = Object.assign({}, await taskService.StartTaskSchedule(taskId));
+            if (scheduleTaskForRun.Status != ResponseCode.Ok) {
+
+            }
+            else {
+                this.result.addMessage(AuditMessageType.info, this.className, 'scheduleTask', `Task {${scheduleTaskForRun.Data._id} - ${scheduleTaskForRun.Data.name}} scheduled for execution`);
+                let cronExpression = '';
+                var scheduleData: ScheduleOptions = scheduleTaskForRun.Data;
+                if (scheduleData.slot === ScheduleSlot.CUSTOM) {
+                    cronExpression = scheduleData.slot;
+                } else if (scheduleData.slot === ScheduleSlot.EVERY_DAY_AT) {
+                    cronExpression = `0 ${scheduleData.startAt?.getMinutes()} ${scheduleData.startAt?.getHours()} * * *`;
+                } else if (scheduleData.slot === ScheduleSlot.EVERY_WEEK_AT) {
+                    cronExpression = `0 ${scheduleData.startAt?.getMinutes()} ${scheduleData.startAt?.getHours()} * * ${scheduleData.startAt?.getDay()}`;
+                } else if (scheduleData.slot === ScheduleSlot.EVERY_MONTH_AT) {
+                    cronExpression = `0 ${scheduleData.startAt?.getMinutes()} ${scheduleData.startAt?.getHours()} ${scheduleData.startAt?.getDate()} * *`;
+                } else {
+                    cronExpression = ScheduleSlot[scheduleData.slot];
+                }
+
+                // cronExpression = `*/1 * * * *`;
+                const job = cron.schedule(
+                    cronExpression,
+                    async () => {
+                        try {
+                            await taskService.StartTaskExecution(scheduleData._taskRunId);
+                            if (scheduleData.onExecutionScript) {
+                                console.log(`Running scheduled task with ID: ${taskId}`);
+                                // var executionScript = new Function('result', `${scheduleData.onExecutionScript}`);
+                                var sandboxContext = {
+                                    companyService: null,// new CompanyService(this.result),
+                                    fireStoreService: null, //new FirestoreService(this.result),
+                                    whatsappProviderService: null,//new WhatsappProviderService(this.result),
+                                    enums: { ResponseCode: ResponseCode, AuditMessageType: AuditMessageType }
+                                }
+                                var result = null;//await processUserScript(scheduleData.onExecutionScript.toString(), sandboxContext, this.result)
+                                // var result = await executionScript(this.result);
+                                if (result.Status == ResponseCode.Error) {
+                                    throw (this.result.Errors)
+                                }
+                                console.log(result);
+                            }
+                            if (scheduleData.onSuccessScript) {
+                                console.log(`On Success script started for task with ID: ${taskId}`);
+                                var successScript = new Function(null, scheduleData.onSuccessScript.toString());
+                                result = await successScript(this.result);
+                                console.log(result);
+                            }
+                            await taskService.StartTaskOnSuccess(scheduleData._taskRunId);
+                        } catch (error) {
+                            if (scheduleData.onFailureScript) {
+                                console.log(`Failure script started for task with ID: ${taskId}`);
+                                var failureScript = new Function(null, scheduleData.onFailureScript.toString());
+                                result = await failureScript(this.result);
+                                console.log(result);
+                            }
+                            await taskService.StartTaskOnFailure(scheduleData._taskRunId);
+                        } finally {
+                            if (scheduleData.onFinalizeScript) {
+                                console.log(`Finalizing script started for task with ID: ${taskId}`);
+                                var finalizeScirpt = new Function(null, scheduleData.onFinalizeScript.toString());
+                                result = await finalizeScirpt(this.result);
+                                console.log(result);
+                            }
+                            await taskService.StartTaskOnFinalize(scheduleData._taskRunId);
+                        }
+                    },
+                    {
+                        scheduled: scheduleData?.startAt !== undefined,
+                        timezone: 'utc',
+                    }
+                );
+
+                if (scheduleData?.startAt && Config.props.load_scheduled_tasks) {
+                    job.start();
+                }
+
+                // if (scheduleData?.frequency) {
+                //     setInterval(() => job.fireOnTick(), scheduleData.frequency);
+                // }
+
+                this.scheduledJobs.set(taskId, job);
+                this.result.addMessage(AuditMessageType.info, this.className, 'scheduleTask', `Finished`);
+                this.result.Status = ResponseCode.Ok;
+                this.result.Data = `Scheduled task ${taskId} successfully`;
+            }
+        } catch (ex) {
+            this.result.addException('CronHelper', 'scheduleTask', ex);
+            this.result.Data = null;
+            this.result.Status = ResponseCode.Error;
+        }
+
+        return this.result;
+    }
+
+    public async updateScheduledTask(taskId: string): Promise<Result> {
+        await this.removeScheduledTask(taskId);
+        return this.scheduleTask(taskId);
+    }
+
+    public async removeScheduledTask(taskId: string): Promise<Result> {
+        try {
+            const job = this.scheduledJobs.get(taskId);
+            if (job) {
+                job.stop();
+                this.scheduledJobs.delete(taskId);
+            }
+            this.result.Status = ResponseCode.Ok;
+            this.result.Data = `Removed scheduled task ${taskId} successfully`;
+        } catch (ex) {
+            this.result.addException('CronHelper', 'removeScheduledTask', ex);
+        }
+
+        return this.result;
+    }
+}
+
+export { CronHelper, ScheduleSlot, ScheduleOptions };

package/templates/api/src/helpers/dbcontext.ts

@@ -0,0 +1,83 @@
+import * as mongoose from 'mongoose';
+import { AuditEntity } from '../schemas/audit';
+import { Config } from '../config';
+import { UserEntity } from '../schemas/user';
+import { SessionEntity } from '../schemas/session';
+import { OTPEntity } from '../schemas/otp';
+
+const connectDb = () => {
+    console.log('db connection string' + Config.props.database_connectionstring)
+    return mongoose.connect(Config.props.database_connectionstring);
+};
+
+export const dbcontext = {
+    //A
+    AuditEntity,
+    //B
+    //C
+    //D
+    //E
+    //F
+    //G
+    //
+    //I
+    //J
+    //K
+    //L
+    listCollections: async () => {
+        return await mongoose.connection.db.listCollections()
+    },
+    //M
+    //N
+    //O
+    //P
+    //Q
+    //R
+    //S
+    SessionEntity,
+    //T
+    //U
+    UserEntity,
+    //V
+    //W
+    //X
+    //Y
+    //Z
+    OTPEntity,
+};
+
+export const dbcontextMapping: { [key: string]: any } = {
+    //A
+    //B
+    //C
+    //D
+    //E
+    //F
+    //G
+    //H
+    //I
+    //J
+    //K
+    //L
+    //M
+    //N
+    //O
+    //P
+    //Q
+    //R
+    //S
+    sessions: SessionEntity,
+    //T
+    //U
+    users: UserEntity,
+    //V
+    //W
+    //X
+    //Y
+    //Z
+    otps: OTPEntity,
+};
+
+export { connectDb };
+
+export default dbcontext;

package/templates/api/src/helpers/encryptionHelper.ts

@@ -0,0 +1,76 @@
+import { Buffer } from "buffer";
+import * as zlib from "zlib";
+export class EncryptionHelper {
+    lightEncryption = (valueToEncrypt) => {
+        const encodedURI = encodeURIComponent(valueToEncrypt);
+        const base64Encoded = btoa(encodedURI);
+        return base64Encoded;
+    };
+
+    lightDecryption = (encodedValue) => {
+        const decodedURI = atob(encodedValue);
+        const decoded = decodeURIComponent(decodedURI);
+        return decoded;
+    };
+
+    encryptUserLogin = (valueToEncrypt) => {
+        try {
+            // Compress the value using zlib
+            const compressed = zlib.deflateSync(valueToEncrypt, { level: zlib.constants.Z_BEST_COMPRESSION }).toString('base64');
+            // Encode the compressed value to URI and then base64 encode
+            const encodedURI = encodeURIComponent(compressed);
+            const base64Encoded = Buffer.from(encodedURI).toString('base64');
+            return base64Encoded;
+        }
+        catch (ex) {
+            console.log(ex);
+            return null;
+        }
+    };
+
+    decryptUserLogin = (encodedValue) => {
+        try {
+            // Decode the base64 and URI encoded value
+            const decodedURI = Buffer.from(encodedValue, 'base64').toString('utf-8');
+            const decoded = decodeURIComponent(decodedURI);
+            // Decompress the value using zlib
+            const decompressed: any = zlib.inflateSync(Buffer.from(decoded, 'base64')).toString();
+            return decompressed;
+        }
+        catch (ex) {
+            console.log(ex);
+            return null;
+        }
+    };
+
+
+
+    // encryptUserLogin = (objectToEncrypt) => {
+    //     try {
+    //         const encrypted = this.lightEncryption(objectToEncrypt);
+    //         return encrypted;
+    //     }
+    //     catch (ex) {
+    //         return null;
+    //     }
+    // }
+
+    // decryptUserLogin = (objectToDecrypt) => {
+    //     try {
+    //         const decrypted = this.lightDecryption(objectToDecrypt);
+    //         return JSON.parse(decrypted);
+    //     }
+    //     catch (ex) {
+    //         return null;
+    //     }
+    // }
+
+    serializeXML = (xml) => {
+        try {
+            const xmlSerializer = new XMLSerializer();
+            return xmlSerializer.serializeToString(xml);
+        } catch {
+            return null;
+        }
+    };
+}

package/templates/api/src/helpers/enums.ts

@@ -0,0 +1,258 @@
+export enum CodeType {
+    email_activation,
+    mobile_activation
+}
+
+export enum ResponseCode {
+    Ok = 1000,
+    Duplicate = 1001,
+    NotExist = 1002,
+    Exist = 1003,
+    Error = 0,
+    Authorized = 1010,
+    Unauthorized = 1011,
+    NotRelated = 1004,
+    NeedVerification = 1005,
+    Incompelete = 1006,
+    MissingRequiredFields = 1007
+}
+
+export enum SendifierServiceCode {
+    WHATSAPP_API = "WAPI",
+    USERS = "USRS",
+    WORKFLOW = "WFLW"
+}
+
+export enum WhatsappProviders {
+    twilio = 'twilio',
+    wati = 'wati'
+}
+
+export enum CompanyUserRole {
+    Creator = 0,
+    Admin = 1,
+    Agent = 2
+}
+
+export enum SendifierPlanStatus {
+    Pending = 0,
+    Approved = 1,
+    Paid = 3,
+    Active = 4,
+    Expired = 5,
+    Deactivated = 6,
+    FreeTier = 10
+}
+
+export enum Status {
+    NotActive = 0,
+    Active = 1,
+    PendingPayment = 5
+}
+
+export enum AssignmentStatus {
+    NotActive = 0,
+    Active = 1,
+    AssignedToServiceUser = 3,
+    AssignedToUser = 4,
+    PermenantAssignment = 5,
+    Deactivated = 6,
+}
+
+
+export enum AccountStatus {
+    NotActive = 0,
+    Active = 1,
+    PendingConfirmation = 2,
+    PendingRegisterationComplete = 3,
+    Deleted = 4,
+    PendingPayment = 5
+}
+
+export enum WorkflowExecutionStatus {
+    Pending = 0,
+    Processing = 1,
+    Success = 2,
+    Failed = 3,
+    Expired = 4
+}
+
+export enum ContactTypes {
+    whatsapp = 0,
+}
+
+export enum TaskType {
+    REGULAR = 1,
+    SCHEDULED = 2,
+    SYSTEM = 3
+}
+
+export enum TaskAssignmentLevel {
+    USER = 1,
+    DEPARTMENT = 2,
+    COMPANY = 3
+}
+
+export enum TaskStatus {
+    TODO = 0,
+    INPROGRESS = 1,
+    PENDING = 2,
+    DONE = 3,
+    TRASH = 4
+}
+
+export enum ScheduleSlot {
+    EVERY_MINUTE = '* * * * *',
+    EVERY_TEN_MINUTES = '*/10 * * * *',
+    EVERY_HOUR = '0 * * * *',
+    EVERY_DAY_AT_MIDNIGHT = '0 0 * * *',
+    EVERY_DAY_AT = 'custom_daily',
+    EVERY_WEEK = '0 0 * * 6', // Saturday at midnight
+    EVERY_WEEK_AT = 'custom_weekly',
+    EVERY_MONTH = '0 0 1 * *', // First day of every month at midnight
+    EVERY_MONTH_AT = 'custom_monthly',
+    CUSTOM = 'custom',
+}
+
+export enum AuditMessageType {
+    info = 1,
+    warn = 2,
+    error = 3,
+    exception = 4,
+    unknown = 10,
+    trace = 11,
+    socket = 12
+}
+
+export enum SocketEventCode {
+    Connect = 'connection',
+    ReloadClient = 'reload_web_channel',
+    Error = 'error',
+    UserLoggedIn = 'user_logged_in',
+    UserLoggedOut = 'user_logged_out',
+    MultipleTabLoggedIn = 'multiple_tab_login',
+    Close = 'close_connection',
+    RespondWhatsappMessage = 'respond_whatsapp_message',
+    ReceiveWhatsappMessage = 'whatsapp_message_received',
+    VerifyToken = 'verify_token',
+    RefreshToken = 'refresh_token'
+}
+
+export enum SocketIdentifierType { //used in subscribe & trigger socket events to make the socket provider able to detect which socket will subscribe or trigger
+    User = 'user',
+    Socket = 'socket',
+    Company = 'company',
+    Room = 'room'
+}
+
+export enum MessageStatus {
+    new = 0,
+    delivered = 1,
+    seen = 2,
+    failed = 3
+}
+
+export enum ObjectStatus {
+    Added = 'Added',
+    Modified = 'Modified',
+    Deleted = 'Deleted'
+}
+
+export enum TaskStatus {
+    InActive = -1,
+    ToDo = 0,
+    InProgress = 1,
+    Pending = 2,
+    Done = 3,
+    Trash = 4,
+    Processing = 5,
+    Succeeded = 6,
+    Failed = 7,
+    Expired = 8,
+    Finished = 9
+}
+
+export enum MessagingOptionsSources {
+    Actions = '0',
+    Context = '1',
+    Both = '2',
+    None = '3'
+}
+
+export enum UserType {
+    SYS = 'SYS',
+    NOR = "NOR",
+}
+
+export enum AuthProvider {
+    INTERNAL = 'internal',
+    FIREBASE = 'firebase',
+    GOOGLE = 'google',
+    FACEBOOK = 'facebook',
+    GITHUB = 'github',
+    LINKEDIN = 'linkedin',
+    TWITTER = 'twitter',
+    SMS_OTP = 'sms_otp',
+    EMAIL_OTP = 'email_otp'
+}
+
+export enum AuthMethod {
+    PASSWORD = 'password',
+    OAUTH = 'oauth',
+    OTP = 'otp',
+    MAGIC_LINK = 'magic_link',
+    BIOMETRIC = 'biometric'
+}
+
+export enum OAuthProvider {
+    GOOGLE = 'google',
+    FACEBOOK = 'facebook',
+    GITHUB = 'github',
+    LINKEDIN = 'linkedin',
+    TWITTER = 'twitter'
+}
+
+export enum CommentStatus {
+    Delete = 0,
+    Active = 1,
+}
+
+export enum ActivationStatus {
+    InActive = -1,
+    IsActive = -2,
+}
+
+export enum AssignmentStatus {
+    Assigned = 0,
+    NotAssigned = 1,
+}
+
+export enum TaskAssignmentStatus {
+    WORKFLOWRUN = 1000,
+    DEPARTMENT = 1001,
+}
+
+export enum WeekDays {
+    Friday = 1,
+    Saturday = 2,
+    Sunday,
+    Monday,
+    Tuseday,
+    Wednsday,
+    Thursday
+}
+
+export enum CalendarDefaultView{
+    Month = 1,
+    Week = 2,
+    Day = 3
+}
+
+export enum Period {
+    Minute,
+    Hour,
+    Day,
+    Week,
+    Month,
+    Year
+}

package/templates/api/src/helpers/handle-response.ts

@@ -0,0 +1,49 @@
+import { ServerResponse } from "http";
+import { Result } from "./result";
+import { AuditService } from "../services/audit-service";
+import { ResponseCode } from "./enums";
+import { Config } from "../config";
+
+class ResponseHandler {
+    HandleResponse(req: any, res: any, result: Result) {
+        try {
+            if (result.Errors.length == 0 && result.Status == ResponseCode.Ok) {
+                result.Messages.push('Request completed successfully.')
+            }
+            delete result.addException;
+            delete result.addMessage;
+            delete result.additionalInfo;
+            delete result.user;
+            if (!Config.props.isDev) {
+                delete result.Errors;
+                delete result.Messages;
+            }
+
+            result.StatusMessage = ResponseCode[result.Status]
+            res.json(result);
+        }
+        catch (ex) {
+            res.status(500)
+        }
+    }
+}
+
+const handleResponse = (req: any, res: any, result: Result) => {
+    try {
+        var responseHandler = new ResponseHandler();
+        var auditService = new AuditService();
+        delete result.user;
+        auditService.AddAuditBulk(result.Messages, result.Errors, result.additionalInfo ? JSON.stringify(result.additionalInfo) : null);
+        responseHandler.HandleResponse(req, res, result);
+    }
+    catch (ex) {
+        console.log(ex);
+    }
+}
+export const handleSocketResponse = (result: Result) => {
+    var auditService = new AuditService();
+    auditService.AddAuditBulk(result.Messages, result.Errors, result.additionalInfo);
+    return result;
+}
+
+export default handleResponse;

package/templates/api/src/helpers/httpHelper.ts

@@ -0,0 +1,75 @@
+import axios, { AxiosResponse, AxiosError, AxiosRequestConfig } from 'axios';
+import { Config } from '../config';
+
+class HttpHelper {
+    private static instance: HttpHelper;
+
+    constructor() { }
+
+    public static getInstance(): HttpHelper {
+        if (!HttpHelper.instance) {
+            HttpHelper.instance = new HttpHelper();
+        }
+        return HttpHelper.instance;
+    }
+
+    public async get(url: string, config?: AxiosRequestConfig): Promise<any> {
+        try {
+            config.timeout = Config.props.external_http_request_timeout;
+            const response = await axios.get(url, config);
+            return response;
+        } catch (error) {
+            this.handleRequestError(error);
+            return null;
+        }
+    }
+
+    public async post(url: string, data?: any, config?: AxiosRequestConfig): Promise<any> {
+        try {
+            config.timeout = Config.props.external_http_request_timeout;
+            const response: AxiosResponse = await axios.post(url, data, config);
+            return response;
+        } catch (error) {
+            this.handleRequestError(error);
+            return null;
+        }
+    }
+
+    public async put<T>(url: string, data?: any, config?: AxiosRequestConfig): Promise<any> {
+        try {
+            config.timeout = Config.props.external_http_request_timeout;
+            const response: AxiosResponse<T> = await axios.put(url, data, config);
+            return response.data;
+        } catch (error) {
+            this.handleRequestError(error);
+            throw error;
+        }
+    }
+
+    public async delete<T>(url: string, config?: AxiosRequestConfig): Promise<any> {
+        try {
+            config.timeout = Config.props.external_http_request_timeout;
+            const response: AxiosResponse<T> = await axios.delete(url, config);
+            return response.data;
+        } catch (error) {
+            this.handleRequestError(error);
+            throw error;
+        }
+    }
+
+    private handleRequestError(error: AxiosError): void {
+        if (error.response) {
+            // The request was made, but the server responded with a status code that falls out of the range of 2xx
+            console.error('Response Error:', error.response.data);
+            console.error('Status Code:', error.response.status);
+        } else if (error.request) {
+            // The request was made but no response was received
+            console.error('Request Error:', error.request);
+        } else {
+            // Something happened in setting up the request that triggered an Error
+            console.error('General Error:', error.message);
+        }
+    }
+}
+
+export default HttpHelper;