@diagramers/cli 1.0.24 → 1.0.26

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

@@ -1,170 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,258 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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;