@tomei/sso 0.8.0 → 0.8.2

package/migrations/01-alter-system-privilege-table.js

@@ -0,0 +1,13 @@
+'use strict';
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.addColumn('sso_systemPrivilege','Module', {
+        type: Sequelize.STRING(200),
+    })
+  },
+
+  async down(queryInterface) {
+    queryInterface.removeColumn('sso_systemPrivilege','Module')
+  },
+};

package/migrations/02-alter-user-group-table.js

@@ -0,0 +1,78 @@
+'use strict';
+
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    return queryInterface.sequelize.transaction(async (t) => {
+      return await Promise.all([
+        queryInterface.addColumn(
+          'sso_usergroup',
+          'AllowInheritFromParentYN',
+          {
+            type: Sequelize.ENUM(['Y', 'N']),
+            defaultValue: 'N',
+          },
+          { transaction: t },
+        ),
+        queryInterface.addColumn(
+            'sso_usergroup',
+            'FullPath',
+            {
+                type: Sequelize.STRING(1000),
+                allowNull: true,
+            },
+            { transaction: t },
+        ),
+        queryInterface.addColumn(
+            'sso_usergroup',
+            'GroupLevel',
+            {
+                type: Sequelize.INTEGER,
+                allowNull: false,
+                defaultValue: 0,
+            },
+            { transaction: t },
+        ),
+        queryInterface.addColumn(
+            'sso_usergroup',
+            'GroupType',
+            {
+                type: Sequelize.STRING(10),
+                allowNull: true,
+            },
+            { transaction: t },
+        ),
+        queryInterface.addColumn(
+            'sso_usergroup',
+            'ParentGroupCode',
+            {
+                type: Sequelize.STRING(10),
+                allowNull: true,
+            },
+            { transaction: t },
+        ),
+        queryInterface.addColumn(
+            'sso_usergroup',
+            'PersonInCharge',
+            {
+                type: Sequelize.STRING(100),
+                allowNull: true,
+            },
+            { transaction: t },
+        ),
+      ]);
+    });
+  },
+
+  down: async (queryInterface) => {
+    return queryInterface.sequelize.transaction(async (t) => {
+      return await Promise.all([
+        queryInterface.removeColumn('sso_usergroup', 'AllowInheritFromParentYN', { transaction: t }),
+        queryInterface.removeColumn('sso_usergroup', 'FullPath', { transaction: t }),
+        queryInterface.removeColumn('sso_usergroup', 'GroupLevel', { transaction: t }),
+        queryInterface.removeColumn('sso_usergroup', 'GroupType', { transaction: t }),
+        queryInterface.removeColumn('sso_usergroup', 'ParentGroupCode', { transaction: t }),
+        queryInterface.removeColumn('sso_usergroup', 'PersonInCharge', { transaction: t }),
+      ]);
+    });
+  },
+};

package/migrations/03-alter-user-system-privilege-table.js

@@ -0,0 +1,38 @@
+'use strict';
+
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    return queryInterface.sequelize.transaction(async (t) => {
+      return await Promise.all([
+        queryInterface.addColumn(
+            'sso_usersystemprivilege',
+            'IsInheritedYN',
+            {
+                type: Sequelize.ENUM(['Y', 'N']),
+                defaultValue: 'N',
+            },
+            { transaction: t },
+        ),
+        queryInterface.addColumn(
+            'sso_usersystemprivilege',
+            'IsRevokedYN',
+            {
+                type: Sequelize.ENUM(['Y', 'N']),
+                defaultValue: 'N',
+            },
+            { transaction: t },
+        ),
+      ]);
+    });
+  },
+
+  down: async (queryInterface) => {
+    return queryInterface.sequelize.transaction(async (t) => {
+      return await Promise.all([
+        queryInterface.removeColumn('sso_usersystemprivilege', 'IsInheritedYN', { transaction: t }),
+        queryInterface.removeColumn('sso_usersystemprivilege', 'IsRevokedYN', { transaction: t }),
+      ]);
+    });
+  },
+};
+'use strict';

package/migrations/04-create-user-user-group-table.js

@@ -0,0 +1,55 @@
+'use strict';
+
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    queryInterface.createTable('sso_UserUserGroup', {
+        UserId: {
+            primaryKey: true,
+            type: Sequelize.INTEGER,
+            allowNull: false,
+            references: {
+                model: 'sso_users',
+                key: 'id',
+            },
+            onDelete: 'CASCADE',
+            onUpdate: 'CASCADE',
+        },
+        GroupCode: {
+            primaryKey: true,
+            type: Sequelize.STRING(191),
+            allowNull: false,
+            references: {
+                model: 'sso_usergroup',
+                key: 'GroupCode',
+            },
+            onDelete: 'CASCADE',
+            onUpdate: 'CASCADE',
+        },
+        SystemId: {
+            type: Sequelize.INTEGER,
+            allowNull: true,
+            references: {
+                model: 'sso_systems',
+                key: 'id',
+            },
+            onDelete: 'CASCADE',
+            onUpdate: 'CASCADE',
+        },
+        CreatedAt: {
+            allowNull: false,
+            defaultValue: Sequelize.literal('CURRENT_TIMESTAMP(3)'),
+            type: Sequelize.DATE,
+        },
+        UpdatedAt: {
+            allowNull: false,
+            defaultValue: Sequelize.literal('CURRENT_TIMESTAMP(3)'),
+            type: Sequelize.DATE,
+        },
+    });
+
+  },
+
+  down: async (queryInterface) => {
+    await queryInterface.dropTable('sso_UserUserGroup');
+  },
+};

package/migrations/05-create-login-history-table.js

@@ -0,0 +1,49 @@
+'use strict';
+
+
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    queryInterface.createTable('sso_LoginHistories', {
+        Id: {
+            primaryKey: true,
+            autoIncrement: true,
+            type: Sequelize.INTEGER,
+            allowNull: false,
+        },
+        UserId: {
+            type: Sequelize.INTEGER,
+            allowNull: false,
+            references: {
+                model: 'sso_users',
+                key: 'id',
+            },
+            onDelete: 'CASCADE',
+            onUpdate: 'CASCADE',
+        },
+        SystemId: {
+            type: Sequelize.INTEGER,
+            allowNull: false,
+            references: {
+                model: 'sso_systems',
+                key: 'id',
+            },
+            onDelete: 'CASCADE',
+            onUpdate: 'CASCADE',
+        },
+        OriginIP: {
+            type: Sequelize.STRING(191),
+            allowNull: false,
+        },
+        CreatedAt: {
+            type: Sequelize.DATE(3),
+            allowNull: false,
+            defaultValue: Sequelize.literal('CURRENT_TIMESTAMP(3)'),
+        },
+    });
+
+  },
+
+  down: async (queryInterface) => {
+    await queryInterface.dropTable('sso_LoginHistories');
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomei/sso",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "Tomei SSO Package",
   "main": "dist/index.js",
   "scripts": {
@@ -31,8 +31,9 @@
     "@tsconfig/node18": "^2.0.1",
     "@types/bcrypt": "^5.0.0",
     "@types/jest": "^29.5.2",
-    "@types/node": "^18.0.6",
+    "@types/node": "^18.17.5",
     "@types/redis": "^4.0.11",
+    "@types/validator": "^13.11.1",
     "@typescript-eslint/eslint-plugin": "^5.33.0",
     "dotenv": "^16.1.4",
     "eslint": "^8.40.0",
@@ -57,7 +58,7 @@
   },
   "peerDependencies": {
     "@prisma/client": "^4.14.1",
-    "@tomei/general": "^0.1.0",
+    "@tomei/general": "^0.3.0",
     "@types/jest": "^29.5.2",
     "argon2": "^0.30.3",
     "cls-hooked": "^4.2.2",
@@ -72,6 +73,9 @@
     ]
   },
   "dependencies": {
-    "@tomei/mailer": "^0.1.3"
+    "@tomei/mailer": "^0.1.3",
+    "reflect-metadata": "^0.1.13",
+    "sequelize": "^6.32.1",
+    "sequelize-typescript": "^2.1.5"
   }
 }

package/src/components/index.ts

@@ -5,3 +5,4 @@ export * from './system';
 export * from './system-access';
 export * from './user-group';
 export * from './user-user-group';
+//test ci

package/src/components/login-history/login-history.repository.ts

@@ -1,33 +1,45 @@
+import LoginHistory from '../../models/login-history.entity';
 import prisma from '../../prisma-client/client';
 
-export class LoginHistoryRepository {
-  private _prisma: any;
+// export class LoginHistoryRepository {
+//   private _prisma: any;
 
-  constructor(client?: any) {
-    if (client) {
-      this._prisma = client;
-    } else {
-      this._prisma = prisma;
-    }
-  }
+//   constructor(client?: any) {
+//     if (client) {
+//       this._prisma = client;
+//     } else {
+//       this._prisma = prisma;
+//     }
+//   }
 
-  public async create(data: any): Promise<any> {
-    return await this._prisma.loginHistory.create(data);
-  }
+//   public async create(data: any): Promise<any> {
+//     return await this._prisma.loginHistory.create(data);
+//   }
 
-  public async findAll(options: any): Promise<any[]> {
-    return await this._prisma.loginHistory.findMany(options);
-  }
+//   public async findAll(options: any): Promise<any[]> {
+//     return await this._prisma.loginHistory.findMany(options);
+//   }
 
-  public async findOne(options: any): Promise<any> {
-    return await this._prisma.loginHistory.findFirst(options);
-  }
+//   public async findOne(options: any): Promise<any> {
+//     return await this._prisma.loginHistory.findFirst(options);
+//   }
 
-  public async update(where: any, data: any): Promise<any> {
-    return await this._prisma.loginHistory.update(where, data);
-  }
+//   public async update(where: any, data: any): Promise<any> {
+//     return await this._prisma.loginHistory.update(where, data);
+//   }
+
+//   public async delete(where: any): Promise<any> {
+//     return await this._prisma.loginHistory.delete(where);
+//   }
+// }
+
+import { RepositoryBase, IRepositoryBase } from '@tomei/general';
 
-  public async delete(where: any): Promise<any> {
-    return await this._prisma.loginHistory.delete(where);
+export class LoginHistoryRepository
+  extends RepositoryBase<LoginHistory>
+  implements IRepositoryBase<LoginHistory>
+{
+  constructor() {
+    super(LoginHistory);
   }
 }

package/src/components/login-user/login-user.ts

@@ -13,6 +13,13 @@ import { UserGroupRepository } from '../user-group/user-group.repository';
 import * as nodemailer from 'nodemailer';
 import { Mailer } from '@tomei/mailer';
 import { ISystemLogin } from '../../../src/interfaces/system-login.interface';
+import Staff from 'models/staff.entity';
+import SystemPrivilege from 'models/system-privilege.entity';
+import LoginHistory from 'models/login-history.entity';
+import GroupSystemPrivilege from 'models/group-system-privilege.entity';
+import GroupRolePrivilege from 'models/group-role-privilege.entity';
+import UserGroup from 'models/user-group.entity';
+import UserSystemPrivileges from 'models/user-system-privileges.entity';
 export class LoginUser extends ObjectBase implements IPerson {
   FullName: string;
   IDNo: string;
@@ -35,6 +42,7 @@ export class LoginUser extends ObjectBase implements IPerson {
   private static _LoginHistoryRepository = new LoginHistoryRepository();
   private static _UserUserGroupRepository = new UserUserGroupRepository();
   private static _UserGroupRepository = new UserGroupRepository();
+  private _dbTransaction: any;
 
   getDetails(): {
     FullName: string;
@@ -63,18 +71,7 @@ export class LoginUser extends ObjectBase implements IPerson {
     // this._MailService = new MailService();
 
     if (dbTransaction) {
-      LoginUser._Repository = new UserRepository(dbTransaction);
-      LoginUser._SystemRepository = new SystemRepository(dbTransaction);
-      LoginUser._SystemAccessRepository = new SystemAccessRepository(
-        dbTransaction,
-      );
-      LoginUser._LoginHistoryRepository = new LoginHistoryRepository(
-        dbTransaction,
-      );
-      LoginUser._UserUserGroupRepository = new UserUserGroupRepository(
-        dbTransaction,
-      );
-      LoginUser._UserGroupRepository = new UserGroupRepository(dbTransaction);
+      this._dbTransaction = dbTransaction;
     }
     // set all the class properties
     if (userInfo) {
@@ -93,31 +90,34 @@ export class LoginUser extends ObjectBase implements IPerson {
 
     if (userId) {
       if (dbTransaction) {
-        LoginUser._Repository = new UserRepository(dbTransaction);
+        LoginUser._Repository = new UserRepository();
       }
       const user = await LoginUser._Repository.findOne({
         where: {
           id: Number(userId),
         },
-        include: {
-          staffs: true,
-          userSystemPrivileges: {
-            include: {
-              systemPrivilege: true,
+        include: [
+          {
+            model: Staff,
+          },
+          {
+            model: SystemPrivilege,
+            Include: {
+              model: SystemPrivilege,
             },
           },
-        },
+        ],
       });
 
       if (user) {
         const userInfo: IUserInfo = {
-          ObjectId: user.id,
-          FullName: user.staffs[0].name,
-          IDNo: user.staffs[0].idNo,
-          ContactNo: user.staffs[0].contactNo,
-          Email: user.staffs[0].email,
-          Password: user.password,
-          staffs: user.staffs[0],
+          ObjectId: user.id.toString(),
+          FullName: user.Staff[0].name,
+          IDNo: user.Staff[0].idNo,
+          ContactNo: user.Staff[0].contactNo,
+          Email: user.Staff[0].email,
+          Password: user.Password,
+          staffs: user.Staff[0],
         };
 
         return new LoginUser(sessionService, dbTransaction, userInfo);
@@ -164,7 +164,7 @@ export class LoginUser extends ObjectBase implements IPerson {
       //validate system access
       await this.checkSystemAccess(this.ObjectId, system.id);
       // alert user if new login
-      await this.alertNewLogin(this.ObjectId, system.id, ipAddress);
+      await this.alertNewLogin(this.ObjectId, system.id.toString(), ipAddress);
 
       // fetch user session if exists
       const userSession = await this._SessionService.retrieveUserSession(
@@ -187,9 +187,9 @@ export class LoginUser extends ObjectBase implements IPerson {
         // if not, add new system login into the userSession
         const newLogin = {
           id: system.id.toString(),
-          code: system.code,
+          code: system.Code,
           sessionId: sessionId,
-          privileges: await this.getPrivileges(system.code),
+          privileges: await this.getPrivileges(system.Code),
         };
         userSession.systemLogins.push(newLogin);
       }
@@ -242,9 +242,9 @@ export class LoginUser extends ObjectBase implements IPerson {
       });
 
       const gotPreviousLogins = userLogins?.length !== 0;
-      let ipFound = null;
+      let ipFound: LoginHistory | undefined = undefined;
       if (gotPreviousLogins) {
-        ipFound = userLogins.find((item) => item.ipAddress === ipAddress);
+        ipFound = userLogins.find((item) => item.OriginIp === ipAddress);
       }
 
       if (gotPreviousLogins && !ipFound) {
@@ -299,25 +299,25 @@ export class LoginUser extends ObjectBase implements IPerson {
       const userUserGroups = await this.getUserUserGroupFromDB(system.id);
 
       // get all userGroup data from user userGroups
-      const userGroupData = userUserGroups.map((u) => u.userGroup);
+      const userGroupData = userUserGroups.map((u) => u.UserGroup);
       // get all privileges from userGroup data
       let privileges: string[] = [];
       for (const userGroup of userGroupData) {
-        const groupSystemPrivileges = userGroup.groupSystemPrivileges.map(
-          (g) => g.systemPrivilege.code,
+        const groupSystemPrivileges = userGroup.GroupSystemPrivileges.map(
+          (g) => g.SystemPrivilege.Code,
         );
-        const groupRolePrivileges = userGroup.groupRolePrivileges.map(
-          (g) => g.systemPrivilege.code,
+        const groupRolePrivileges = userGroup.GroupRolePrivileges.map(
+          (g) => g.SystemPrivilege.Code,
         );
 
         // if userGroup is not root, get all parent tree privileges
         if (
-          userGroup.groupLevel !== 0 &&
-          userGroup.allowInheritFromParentYN === 'Y'
+          userGroup.GroupLevel !== 0 &&
+          userGroup.AllowInheritFromParentYN === 'Y'
         ) {
           // get all parent tree privileges
           const parentTreePrivileges = await this.getPrivilegesFromUserGroup(
-            userGroup.parentGroupCode,
+            userGroup.ParentGroupCode,
           );
 
           privileges = [...privileges, ...parentTreePrivileges];
@@ -380,18 +380,20 @@ export class LoginUser extends ObjectBase implements IPerson {
         where: {
           groupCode: groupCode,
         },
-        include: {
-          groupSystemPrivileges: {
+        include: [
+          {
+            model: GroupSystemPrivilege,
             include: {
-              systemPrivilege: true,
+              model: SystemPrivilege,
             },
           },
-          groupRolePrivileges: {
+          {
+            model: GroupRolePrivilege,
             include: {
-              systemPrivilege: true,
+              model: SystemPrivilege,
             },
           },
-        },
+        ],
       });
       return userGroup;
     } catch (error) {
@@ -407,20 +409,21 @@ export class LoginUser extends ObjectBase implements IPerson {
           systemId: systemCode,
         },
         include: {
-          userGroup: {
-            include: {
-              groupSystemPrivileges: {
-                include: {
-                  systemPrivilege: true,
-                },
+          model: UserGroup,
+          include: [
+            {
+              model: GroupSystemPrivilege,
+              include: {
+                model: SystemPrivilege,
               },
-              groupRolePrivileges: {
-                include: {
-                  systemPrivilege: true,
-                },
+            },
+            {
+              model: GroupRolePrivilege,
+              include: {
+                model: SystemPrivilege,
               },
             },
-          },
+          ],
         },
       });
     } catch (error) {
@@ -435,24 +438,21 @@ export class LoginUser extends ObjectBase implements IPerson {
           id: this.ObjectId,
         },
         include: {
-          userSystemPrivileges: {
-            include: {
-              systemPrivilege: true,
-            },
+          model: UserSystemPrivileges,
+          include: {
+            model: SystemPrivilege,
           },
         },
       });
 
       //retrive all user systemPrevileges data from user roles
-      let userSystemPrivileges = userRole.userSystemPrivileges.map(
-        (u) => u.systemPrivilege,
-      );
+      let userSystemPrivileges = userRole.SystemPrivileges;
 
       userSystemPrivileges = userSystemPrivileges.filter(
-        (u) => u.systemId === systemId,
+        (u) => u.SystemId === systemId,
       );
 
-      const userPrivileges: string[] = userSystemPrivileges.map((u) => u.code);
+      const userPrivileges: string[] = userSystemPrivileges.map((u) => u.Code);
       return userPrivileges;
     } catch (error) {
       throw error;

package/src/components/login-user/user.repository.ts

@@ -1,33 +1,45 @@
+import User from '../../models/user.entity';
 import prisma from '../../prisma-client/client';
 
-export class UserRepository {
-  private _prisma: any;
+// export class UserRepository {
+//   private _prisma: any;
 
-  constructor(client?: any) {
-    if (client) {
-      this._prisma = client;
-    } else {
-      this._prisma = prisma;
-    }
-  }
+//   constructor(client?: any) {
+//     if (client) {
+//       this._prisma = client;
+//     } else {
+//       this._prisma = prisma;
+//     }
+//   }
 
-  public async create(data: any): Promise<any> {
-    return await this._prisma.user.create(data);
-  }
+//   public async create(data: any): Promise<any> {
+//     return await this._prisma.user.create(data);
+//   }
 
-  public async findAll(options: any): Promise<any[]> {
-    return await this._prisma.user.findMany(options);
-  }
+//   public async findAll(options: any): Promise<any[]> {
+//     return await this._prisma.user.findMany(options);
+//   }
 
-  public async findOne(options: any): Promise<any> {
-    return await this._prisma.user.findFirst(options);
-  }
+//   public async findOne(options: any): Promise<any> {
+//     return await this._prisma.user.findFirst(options);
+//   }
 
-  public async update(where: any, data: any): Promise<any> {
-    return await this._prisma.user.update(where, data);
-  }
+//   public async update(where: any, data: any): Promise<any> {
+//     return await this._prisma.user.update(where, data);
+//   }
+
+//   public async delete(where: any): Promise<any> {
+//     return await this._prisma.user.delete(where);
+//   }
+// }
+
+import { RepositoryBase, IRepositoryBase } from '@tomei/general';
 
-  public async delete(where: any): Promise<any> {
-    return await this._prisma.user.delete(where);
+export class UserRepository
+  extends RepositoryBase<User>
+  implements IRepositoryBase<User>
+{
+  constructor() {
+    super(User);
   }
 }