@diagramers/cli 1.0.22 → 1.0.24

package/templates/api/src/controllers/account-controller.ts

@@ -0,0 +1,162 @@
+import { AuditMessageType, ResponseCode } from "../helpers/enums";
+import handleResponse from "../helpers/handle-response";
+import { Result } from "../helpers/result";
+import { AccountService } from "../services/account-service";
+
+export default class AccountController {
+
+    async verifyToken(req, res) {
+        const result = new Result(null, ResponseCode.Incompelete, [], [], req.body.requestIdentifier);
+        const accountService = new AccountService(result);
+        const serviceResult = await accountService.VerifyToken(req.body.idToken);
+        return handleResponse(req, res, serviceResult);
+    }
+
+    async activateEmail(req, res) {
+        const result = new Result(null, ResponseCode.Incompelete, [], [], req.body.requestIdentifier);
+        try {
+            result.addMessage(AuditMessageType.info, req.baseUrl, 'activateEmail', `Started`);
+            const accountService = new AccountService(result);
+            const serviceResult = await accountService.confirmEmail(req.body);
+            result.addMessage(AuditMessageType.info, req.baseUrl, 'activateEmail', `Finished`);
+            return handleResponse(req, res, serviceResult);
+        } catch (ex) {
+            result.addException(req.baseUrl, 'activateEmail', ex);
+            return handleResponse(req, res, result);
+        }
+    }
+
+    async register(req, res) {
+        const result = res.locals.result;
+        try {
+            result.addMessage(AuditMessageType.info, req.baseUrl, 'register', `Started`);
+            const accountService = new AccountService(result);
+            const serviceResult = await accountService.register(req.body);
+            result.addMessage(AuditMessageType.info, req.baseUrl, 'register', `Finished`);
+            return handleResponse(req, res, serviceResult);
+        } catch (ex) {
+            result.addException(req.baseUrl, 'register', ex);
+            return handleResponse(req, res, result);
+        }
+    }
+
+    async login(req, res) {
+        const result = res.locals.result;
+        try {
+            result.addMessage(AuditMessageType.info, req.baseUrl, 'login', `Started`);
+            const accountService = new AccountService(result);
+            const serviceResult = await accountService.login(req.body);
+            result.addMessage(AuditMessageType.info, req.baseUrl, 'login', `Finished`);
+            return handleResponse(req, res, serviceResult);
+        } catch (ex) {
+            result.addException(req.baseUrl, 'login', ex);
+            return handleResponse(req, res, result);
+        }
+    }
+
+    async verifySignupCode(req, res) {
+        const result = res.locals.result;
+        try {
+            result.addMessage(AuditMessageType.info, req.baseUrl, 'verifySignupCode', `Started`);
+            const accountService = new AccountService(result);
+            const serviceResult = await accountService.VerifyMobileVerificationCode(req.body);
+            result.addMessage(AuditMessageType.info, req.baseUrl, 'verifySignupCode', `Finished`);
+            return handleResponse(req, res, serviceResult);
+        } catch (ex) {
+            result.addException(req.baseUrl, 'verifySignupCode', ex);
+            return handleResponse(req, res, result);
+        }
+    }
+
+    async completeSignup(req, res) {
+        const result = res.locals.result;
+        try {
+            result.addMessage(AuditMessageType.info, req.baseUrl, 'completeSignup', `Started`);
+            const accountService = new AccountService(result);
+            const serviceResult = await accountService.completeSignup(req.body);
+            result.addMessage(AuditMessageType.info, req.baseUrl, 'completeSignup', `Finished`);
+            return handleResponse(req, res, serviceResult);
+        } catch (ex) {
+            result.addException(req.baseUrl, 'completeSignup', ex);
+            return handleResponse(req, res, result);
+        }
+    }
+
+    async sendSignUpEmail(req, res) {
+        const result = res.locals.result;
+        const accountService = new AccountService(result);
+        // Implement sendSignupEmail if needed
+        return handleResponse(req, res, new Result(true, ResponseCode.Ok, [], []));
+    }
+
+    async checkEmailIsExistForBusiness(req, res) {
+        const result = res.locals.result;
+        try {
+            result.addMessage(AuditMessageType.info, req.baseUrl, 'checkEmailIsExistForBusiness', `Started`);
+            const accountService = new AccountService(result);
+            const serviceResult = await accountService.checkEmailIsExistForBusiness(req.body);
+            result.addMessage(AuditMessageType.info, req.baseUrl, 'checkEmailIsExistForBusiness', `Finished`);
+            return handleResponse(req, res, serviceResult);
+        } catch (ex) {
+            result.addException(req.baseUrl, 'checkEmailIsExistForBusiness', ex);
+            return handleResponse(req, res, result);
+        }
+    }
+
+    async checkPhoneIsExistForBusiness(req, res) {
+        const result = res.locals.result;
+        try {
+            result.addMessage(AuditMessageType.info, req.baseUrl, 'checkPhoneIsExistForBusiness', `Started`);
+            const accountService = new AccountService(result);
+            const serviceResult = await accountService.checkPhoneIsExistForBusiness(req.body);
+            result.addMessage(AuditMessageType.info, req.baseUrl, 'checkPhoneIsExistForBusiness', `Finished`);
+            return handleResponse(req, res, serviceResult);
+        } catch (ex) {
+            result.addException(req.baseUrl, 'checkPhoneIsExistForBusiness', ex);
+            return handleResponse(req, res, result);
+        }
+    }
+
+    async resetUserPassword(req, res) {
+        const result = res.locals.result;
+        try {
+            result.addMessage(AuditMessageType.info, req.baseUrl, 'resetUserPassword', `Started`);
+            const accountService = new AccountService(result);
+            const serviceResult = await accountService.resetUserPassword(req.body);
+            result.addMessage(AuditMessageType.info, req.baseUrl, 'resetUserPassword', `Finished`);
+            return handleResponse(req, res, serviceResult);
+        } catch (ex) {
+            result.addException(req.baseUrl, 'resetUserPassword', ex);
+            return handleResponse(req, res, result);
+        }
+    }
+
+    async requestResetUserPassword(req, res) {
+        const result = res.locals.result;
+        try {
+            result.addMessage(AuditMessageType.info, req.baseUrl, 'requestResetUserPassword', `Started`);
+            const accountService = new AccountService(result);
+            const serviceResult = await accountService.requestResettUserPassword(req.body);
+            result.addMessage(AuditMessageType.info, req.baseUrl, 'requestResetUserPassword', `Finished`);
+            return handleResponse(req, res, serviceResult);
+        } catch (ex) {
+            result.addException(req.baseUrl, 'requestResetUserPassword', ex);
+            return handleResponse(req, res, result);
+        }
+    }
+
+    // ✅ NEW: Seed user method for seeding admin user
+    async seedUser(req, res) {
+        const result = new Result(null, ResponseCode.Incompelete, [], [], req.body?.requestIdentifier);
+        try {
+            result.addMessage(AuditMessageType.info, req.baseUrl, 'seedUser', `Started`);
+            const accountService = new AccountService(result);
+            const serviceResult = await accountService.seedUser();
+            result.addMessage(AuditMessageType.info, req.baseUrl, 'seedUser', `Finished`);
+            return handleResponse(req, res, serviceResult);
+        } catch (ex) {
+            result.addException(req.baseUrl, 'seedUser', ex);
+            return handleResponse(req, res, result);
+        }
+    }
+}

package/templates/api/src/entities/audit.ts

@@ -0,0 +1,12 @@
+import * as mongoose from 'mongoose';
+import { ObjectId } from 'bson';
+import { IBaseEntity } from './base-entity';
+
+export interface IAudit extends IBaseEntity {
+    type: string;
+    auditTime: string;
+    className: string;
+    methodName: string;
+    message: string;
+    additionalInfo: JSON;
+}

package/templates/api/src/entities/base-entity.ts

@@ -0,0 +1,10 @@
+import * as mongoose from 'mongoose';
+import { ObjectId } from 'bson';
+
+export interface IBaseEntity extends mongoose.Document {
+    _id: ObjectId,
+    _createdBy: ObjectId,
+    createdAt: Date,
+    _updatedBy: ObjectId,
+    updatedAt: Date
+}

package/templates/api/src/entities/user.ts

@@ -0,0 +1,71 @@
+import * as mongoose from 'mongoose';
+import { ObjectId } from "bson";
+import { AuthProvider, AuthMethod } from '../helpers/enums';
+
+export interface IUser extends mongoose.Document {
+    _id: ObjectId,
+    name: string,
+    email: string,
+    emailVerified: boolean,
+    username: string,
+    
+    // Authentication fields
+    auth_providers: AuthProviderInfo[],
+    primary_auth_provider: AuthProvider,
+    
+    // Legacy fields (for backward compatibility)
+    hashedPassword?: string,
+    firebaseUID?: string,
+    
+    // Contact information
+    phone?: string,
+    phoneVerified: boolean,
+    
+    // Profile information
+    identity: string,
+    address?: any,
+    invitationCode?: string,
+    registerationStatus?: boolean,
+    userType: string,
+    status: number,
+    
+    // Timestamps
+    createdAt: Date,
+    updatedAt: Date
+}
+
+export interface AuthProviderInfo {
+    provider: AuthProvider;
+    provider_user_id?: string; // External provider user ID
+    provider_access_token?: string;
+    provider_refresh_token?: string;
+    provider_metadata?: any; // Additional provider-specific data
+    is_verified: boolean;
+    last_used: Date;
+    created_at: Date;
+}
+
+export interface UserSession {
+    session_id: string;
+    user_id: ObjectId;
+    auth_provider: AuthProvider;
+    auth_method: AuthMethod;
+    ip_address: string;
+    user_agent: string;
+    is_active: boolean;
+    expires_at: Date;
+    created_at: Date;
+    last_activity: Date;
+}
+
+export interface OTPCode {
+    code: string;
+    user_id: ObjectId;
+    auth_provider: AuthProvider;
+    purpose: 'email_verification' | 'phone_verification' | 'password_reset' | 'login';
+    expires_at: Date;
+    attempts: number;
+    max_attempts: number;
+    is_used: boolean;
+    created_at: Date;
+}

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

@@ -0,0 +1,157 @@
+/* eslint-disable */
+import * as base64Encryption from "base-64";
+import { date } from "yup";
+import { ResponseCode } from "./enums";
+import { Result } from "./result";
+const momentTZ = require("moment-timezone");
+
+class FrameworkHelper {
+
+  listAllTimeZones = () => {
+    var aryIannaTimeZones = Intl.supportedValuesOf("timeZone");
+
+    const date = new Date();
+    const timeZones = [];
+    aryIannaTimeZones.forEach((timeZone) => {
+      let strTime = date.toLocaleString("en-US", { timeZone: `${timeZone}` });
+      timeZones.push({
+        value: timeZone,
+        label: timeZone + " (" + strTime + ")",
+      });
+    });
+    return timeZones;
+  };
+
+  convertTimeToFriendly = (timeSpan, isPretty = true) => {
+    try {
+      var time = momentTZ.unix(timeSpan).format("MM/DD/YYYY hh:mm:ss.SSS a");
+      if (!isPretty) return momentTZ(time).toLocaleString();
+      return momentTZ(time).fromNow().toLocaleLowerCase();
+    } catch (ex) {
+      return new momentTZ().fromNow();
+    }
+  };
+
+  sortList(list, sortField, dir = 1) {
+    try {
+      var sortedList = list.sort((a, b) => {
+        if (a[sortField] > b[sortField]) {
+          return 1;
+        }
+        if (a[sortField] < b[sortField]) {
+          return -1;
+        }
+        return 0;
+      });
+      if (dir == -1) {
+        return sortedList.reverse();
+      }
+      return sortedList;
+    } catch (ex) {
+      return [];
+    }
+  }
+
+  deepEqual(obj1, obj2) {
+    // Check if both are objects
+    if (
+      typeof obj1 === "object" &&
+      obj1 !== null &&
+      typeof obj2 === "object" &&
+      obj2 !== null
+    ) {
+      // Get the keys of the objects
+      const keys1 = Object.keys(obj1);
+      const keys2 = Object.keys(obj2);
+
+      // Check if the number of keys is the same
+      if (keys1.length !== keys2.length) {
+        return false;
+      }
+
+      // Check each property
+      for (const key of keys1) {
+        if (!keys2.includes(key) || !this.deepEqual(obj1[key], obj2[key])) {
+          return false;
+        }
+      }
+
+      return true;
+    } else {
+      // If not objects, use strict equality
+      return obj1 === obj2;
+    }
+  }
+
+  uniqueObjects = (dataArray) => {
+    return Array.from(
+      new Map(dataArray.map((obj) => [JSON.stringify(obj), obj])).values()
+    );
+  };
+
+  clearTextSpaces = (text) => {
+    let wordsArray = text.split(" ").filter((word) => word !== "");
+    let stringWithoutSpaces = wordsArray.join("");
+    return stringWithoutSpaces;
+  };
+
+  filterDictionaryObject = (inputObject, targetKey, targetValue) => {
+    return Object.keys(inputObject)
+      .filter(key => inputObject[key][targetKey] === targetValue)
+      .map(key => inputObject[key]);
+  };
+
+  generateRandomString(length) {
+    const crypto = require('crypto');
+    return crypto.randomBytes(Math.ceil(length / 2))
+      .toString('hex') // Convert to hexadecimal format
+      .slice(0, length); // Return required number of characters
+  }
+
+  mapObjectsToType(source, TargetType) {
+    const target = new TargetType();
+    if (source) {
+      // Iterate over the properties of the target object
+      Object.keys(target).forEach(key => {
+        if (key in source) {
+          const descriptor = Object.getOwnPropertyDescriptor(source, key);
+          if (descriptor && (descriptor.get || descriptor.set)) {
+            // Handle getters and setters
+            Object.defineProperty(target, key, descriptor);
+          } else {
+            // Direct value copy for normal properties
+            target[key] = source[key];
+          }
+        }
+      });
+      return target;
+    }
+    return null;
+  };
+
+  formatTextAsCode(input: String): String {
+    // Remove spaces and special characters using regex
+    let processedText = input.replace(/[^a-zA-Z0-9]/g, '');
+    // Capitalize all characters
+    processedText = processedText.toUpperCase();
+    return processedText;
+  }
+
+  getDifferenceDatesInDays(date1, date2) {
+    // Convert both dates to milliseconds
+    const date1Time = new Date(date1).getTime();
+    const date2Time = new Date(date2).getTime();
+
+    // Calculate the difference in milliseconds
+    const diffTime = Math.abs(date2Time - date1Time);
+
+    // Convert the difference to days
+    const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
+
+    return diffDays;
+  }
+
+
+}
+
+export const frameworkHelper = new FrameworkHelper();