@diagramers/cli 1.0.24 → 1.0.25

package/templates/api/src/services/account-service.ts

@@ -1,243 +0,0 @@
-import { ObjectId } from "bson";
-import * as uuid from 'uuid4';
-import dbcontext from "../helpers/dbcontext";
-import { EncryptionHelper } from "../helpers/encryptionHelper";
-import { AccountStatus, AuditMessageType, ResponseCode } from "../helpers/enums";
-import { Result } from "../helpers/result";
-import { UserEntity } from "../schemas/user";
-import { frameworkHelper } from "../helpers/FrameworkHelper";
-import { MailHelper } from "../helpers/mailer";
-import { Config } from "../config";
-import { AuthHelper } from "../helpers/auth";
-
-export class AccountService {
-    encryptionHelper: EncryptionHelper;
-    authHelper: AuthHelper;
-    result: Result;
-    className = 'AccountService';
-
-    constructor(result: Result) {
-        this.result = result;
-        this.encryptionHelper = new EncryptionHelper();
-        this.authHelper = new AuthHelper(result);
-    }
-
-    async seedUser(): Promise<Result> {
-        try {
-            this.result.addMessage(AuditMessageType.info, this.className, 'SeedUser', 'Started');
-            const existingAdmin = await dbcontext.UserEntity.findOne({ email: 'admin@tactic.com' });
-            if (existingAdmin) {
-                this.result.Data = existingAdmin._id;
-                this.result.Status = ResponseCode.Ok;
-                return this.result;
-            }
-            const userEntity = new UserEntity({
-                _id: new ObjectId(),
-                email: 'admin@diagrammers.com',
-                username: 'admin@diagrammers.com',
-                name: 'Admin User',
-                emailVerified: true,
-                status: AccountStatus.Active,
-                hashedPassword: this.encryptionHelper.encryptUserLogin('Admin123!'),
-                userType: 'ADMIN',
-                invitationCode: frameworkHelper.generateRandomString(6),
-                identity: uuid()
-            });
-            const createdUser = await dbcontext.UserEntity.create(userEntity);
-            if (createdUser) {
-                this.result.Data = createdUser._id;
-                this.result.Status = ResponseCode.Ok;
-            } else {
-                this.result.Status = ResponseCode.Error;
-                this.result.Errors.push('Failed to seed admin user');
-            }
-            return this.result;
-        } catch (ex) {
-            this.result.addException(this.className, 'SeedUser', ex);
-            return new Result(null, ResponseCode.Error, [ex], [ex.message]);
-        }
-    }
-
-    async register(userVM: any): Promise<Result> {
-        try {
-            const userEntity = new UserEntity({
-                email: userVM.email.toLowerCase(),
-                name: userVM.name,
-                username: userVM.email,
-                emailVerified: false,
-                invitationCode: frameworkHelper.generateRandomString(6),
-                status: AccountStatus.PendingConfirmation,
-                hashedPassword: this.encryptionHelper.encryptUserLogin(userVM.password),
-                userType: "NOR",
-                identity: uuid()
-            });
-            const createdUser = await dbcontext.UserEntity.create(userEntity);
-            if (createdUser) {
-                this.result.Data = createdUser._id;
-                const emailView = MailHelper.GetEmailConfirmationTemplate(
-                    userEntity.name,
-                    `${Config.props.base_site_url}/otp?oobCode=${this.encryptionHelper.encryptUserLogin(userEntity.invitationCode)}&inviteEmail=${this.encryptionHelper.encryptUserLogin(userEntity.email)}&usrStat=${this.encryptionHelper.encryptUserLogin(userEntity.status)}`,
-                    'Get Started'
-                );
-                await MailHelper.SendEmail(userVM.email, emailView, `Email Confirmation`);
-                this.result.Status = ResponseCode.Ok;
-            } else {
-                this.result.Status = ResponseCode.Error;
-                this.result.Errors.push('User could not be created');
-            }
-            return this.result;
-        } catch (ex) {
-            this.result.addException(this.className, 'Register', ex);
-            return new Result(null, ResponseCode.Error, [ex], [ex.message]);
-        }
-    }
-
-    async checkUserNameAvailability(username: string): Promise<Result> {
-        try {
-            const user = await dbcontext.UserEntity.findOne({ username });
-            if (!user) {
-                return new Result('', ResponseCode.NotExist);
-            } else {
-                return new Result(user._id, ResponseCode.Exist);
-            }
-        } catch (ex) {
-            return new Result(ex.message, ResponseCode.Error);
-        }
-    }
-
-    async confirmEmail(data: any): Promise<Result> {
-        try {
-            const email = this.encryptionHelper.decryptUserLogin(data.email);
-            const code = this.encryptionHelper.decryptUserLogin(data.code);
-            const user = await dbcontext.UserEntity.findOne({ email });
-            if (user && user.invitationCode === code) {
-                user.emailVerified = true;
-                user.status = AccountStatus.Active;
-                await user.save();
-                this.result.Data = user.email;
-                this.result.Status = ResponseCode.Ok;
-            } else {
-                this.result.Status = ResponseCode.Error;
-                this.result.Errors.push('Invalid email confirmation data');
-            }
-            return this.result;
-        } catch (ex) {
-            return new Result(null, ResponseCode.Error, [ex], [ex.message]);
-        }
-    }
-
-    async login(userLoginModel: any): Promise<Result> {
-        try {
-            const encryptedPassword = this.encryptionHelper.encryptUserLogin(userLoginModel.password);
-            const user = await dbcontext.UserEntity.findOne({ email: userLoginModel.email, hashedPassword: encryptedPassword });
-            if (user) {
-                this.result.Data = this.encryptionHelper.encryptUserLogin(JSON.stringify(user));
-                this.result.Status = ResponseCode.Ok;
-            } else {
-                this.result.Status = ResponseCode.Unauthorized;
-                this.result.Errors.push('Invalid login credentials');
-            }
-            return this.result;
-        } catch (ex) {
-            this.result.addException(this.className, 'Login', ex);
-            return this.result;
-        }
-    }
-
-    async getUserByEmail(email: string): Promise<Result> {
-        try {
-            const user = await dbcontext.UserEntity.findOne({ email });
-            if (user) {
-                this.result.Data = user;
-                this.result.Status = ResponseCode.Ok;
-            } else {
-                this.result.Status = ResponseCode.NotExist;
-            }
-            return this.result;
-        } catch (ex) {
-            this.result.addException(this.className, 'GetUserByEmail', ex);
-            return this.result;
-        }
-    }
-
-    // --- Added missing methods as skeletons ---
-
-    async VerifyToken(token: string): Promise<Result> {
-        try {
-            const verified = await this.authHelper.VerifyToken(token);
-            this.result.Data = verified;
-            this.result.Status = ResponseCode.Ok;
-            return this.result;
-        } catch (ex) {
-            this.result.addException(this.className, 'VerifyToken', ex);
-            return new Result(null, ResponseCode.Unauthorized, [ex], ['Invalid token']);
-        }
-    }
-
-    async VerifyMobileVerificationCode(data: any): Promise<Result> {
-        if (data.code === '123456') {
-            this.result.Data = true;
-            this.result.Status = ResponseCode.Ok;
-        } else {
-            this.result.Status = ResponseCode.Unauthorized;
-            this.result.Errors.push('Invalid code');
-        }
-        return this.result;
-    }
-
-    async resetUserPassword(data: any): Promise<Result> {
-        try {
-            const user = await dbcontext.UserEntity.findOne({ email: data.email });
-            if (user) {
-                user.hashedPassword = this.encryptionHelper.encryptUserLogin(data.password);
-                await user.save();
-                this.result.Data = true;
-                this.result.Status = ResponseCode.Ok;
-            } else {
-                this.result.Status = ResponseCode.NotExist;
-                this.result.Errors.push('User not found');
-            }
-            return this.result;
-        } catch (ex) {
-            this.result.addException(this.className, 'resetUserPassword', ex);
-            return new Result(null, ResponseCode.Error, [ex], [ex.message]);
-        }
-    }
-
-    async requestResettUserPassword(data: any): Promise<Result> {
-        try {
-            const user = await dbcontext.UserEntity.findOne({ email: data.email });
-            if (user) {
-                user.invitationCode = frameworkHelper.generateRandomString(6);
-                await user.save();
-                this.result.Data = true;
-                this.result.Status = ResponseCode.Ok;
-            } else {
-                this.result.Status = ResponseCode.NotExist;
-                this.result.Errors.push('User not found');
-            }
-            return this.result;
-        } catch (ex) {
-            this.result.addException(this.className, 'requestResettUserPassword', ex);
-            return new Result(null, ResponseCode.Error, [ex], [ex.message]);
-        }
-    }
-
-    async completeSignup(data: any): Promise<Result> {
-        this.result.Status = ResponseCode.Ok;
-        this.result.Data = true;
-        return this.result;
-    }
-
-    async checkEmailIsExistForBusiness(data: any): Promise<Result> {
-        this.result.Status = ResponseCode.NotExist;
-        this.result.Data = false;
-        return this.result;
-    }
-
-    async checkPhoneIsExistForBusiness(data: any): Promise<Result> {
-        this.result.Status = ResponseCode.NotExist;
-        this.result.Data = false;
-        return this.result;
-    }
-}

package/templates/api/src/services/audit-service.ts

@@ -1,56 +0,0 @@
-
-import { Config } from "../config";
-import { IAudit } from "../entities/audit";
-import dbcontext from "../helpers/dbcontext";
-import { AuditMessageType } from "../helpers/enums";
-export class AuditService {
-    async AddAuditBulk(messages: any, errors: any, additionalInfo: any) {
-        try {
-            var auditDocuments = [];
-            if (Config.props.isDev) {
-                messages.map((message: any) => {
-                    auditDocuments.push({
-                        type: message.type ? AuditMessageType[message.type] : AuditMessageType[AuditMessageType.unknown],
-                        className: message.className ? message.className : '-',
-                        methodName: message.methodName ? message.methodName : '-',
-                        requestIdentifier: message.requestIdentifier ? message.requestIdentifier : '-',
-                        message: message.message ? message.message : message,
-                        auditTime: message.auditTime ? message.auditTime : new Date(),
-                        additionalInfo: additionalInfo
-                    });
-                });
-            }
-            errors.map((error: any) => {
-                auditDocuments.push({
-                    type: AuditMessageType[AuditMessageType.exception],
-                    className: error.className ? error.className : '-',
-                    methodName: error.methodName ? error.methodName : '-',
-                    requestIdentifier: error.requestIdentifier ? error.requestIdentifier : '-',
-                    message: error.message ? error.message : error,
-                    auditTime: error.auditTime ? error.auditTime : new Date(),
-                    additionalInfo: additionalInfo
-                });
-            })
-            dbcontext.AuditEntity.insertMany(auditDocuments);
-        }
-        catch (ex) {
-            console.error(ex)
-        }
-    }
-    async AddAuditSingle(type: AuditMessageType, className, methodName, requestIdentifier, message, addInfo = undefined) {
-        try {
-            dbcontext.AuditEntity.create({
-                type: type ? AuditMessageType[type].toString() : AuditMessageType[AuditMessageType.unknown].toString(),
-                className: className,
-                methodName: methodName,
-                requestIdentifier: requestIdentifier,
-                message: message,
-                auditTime: new Date(),
-                additionalInfo: addInfo
-            })
-        }
-        catch (ex) {
-            console.error(ex)
-        }
-    }
-}

package/templates/api/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "CommonJS",
-    "noImplicitReturns": false,
-    "noImplicitAny": false,
-    "moduleResolution": "node",
-    "noUnusedLocals": false,
-    "outDir": "lib",
-    "sourceMap": true,
-    "target": "ES2022",
-    "allowJs": true
-  },
-  "typeRoots": ["node_modules/@types"],
-  "compileOnSave": true,
-  "include": ["src", "src/*/*.hbs", "main.ts","scripts"]
-}

package/templates/api/webpack.config.js

@@ -1,66 +0,0 @@
-"use strict";
-
-var nodeExternals = require("webpack-node-externals");
-var path = require("path");
-const CopyPlugin = require("copy-webpack-plugin");
-const CssMinimizerPlugin = require("css-minimizer-webpack-plugin");
-const MiniCssExtractPlugin = require("mini-css-extract-plugin");
-
-const { env } = require("process");
-
-module.exports = {
-  entry: "./main.ts",
-  mode: env.NODE_ENV || "development",
-  output: {
-    path: path.resolve(__dirname, "lib"),
-    filename: "[name].js",
-    libraryTarget: "this",
-  },
-  target: "electron-main",
-  module: {
-    rules: [
-      {
-        test: /\.tsx?$/,
-        loader: "ts-loader",
-        options: {
-          transpileOnly: false,
-          compilerOptions: {
-            declaration: true,
-            declarationDir: "./lib"
-          }
-        },
-      },
-      {
-        test: /\.s?css$/,
-        use: [MiniCssExtractPlugin.loader, "css-loader", "sass-loader"],
-      },
-    ],
-  },
-  resolve: {
-    extensions: [".ts", ".tsx", ".js"],
-    fallback: { crypto: false },
-  },
-  node: {
-    __dirname: true,
-    __filename: true,
-  },
-  externals: [nodeExternals()],
-  plugins: [
-    new CopyPlugin({
-      patterns: [
-        {
-          from: "src/assets",
-          to: "assets/",
-        },
-        {
-          from: "certs",
-          to: "certs/",
-        },
-      ],
-    }),
-  ],
-  optimization: {
-    minimizer: [new CssMinimizerPlugin()],
-    minimize: true,
-  },
-};