@tomei/sso 0.35.8 → 0.37.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomei/sso",
-  "version": "0.35.8",
+  "version": "0.37.0",
   "description": "Tomei SSO Package",
   "main": "dist/index.js",
   "scripts": {

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

@@ -33,6 +33,7 @@ import * as speakeasy from 'speakeasy';
 import { LoginStatusEnum } from '../../enum/login-status.enum';
 import { RedisService } from '../../redis-client/redis.service';
 import { LoginUser } from './login-user';
+import { SessionService } from 'session';
 
 export class User extends UserBase {
   ObjectId: string;
@@ -2388,4 +2389,96 @@ export class User extends UserBase {
       throw error;
     }
   }
+
+  public static async findByEmail(
+    loginUser: LoginUser,
+    dbTransaction: any,
+    Email: string,
+  ): Promise<User> {
+    //This method search user record by their email.
+    try {
+      // Part 1: Privilege Checking
+      // Call loginUser.checkPrivilege() by passing:
+      // SystemCode: "<get_from_app_config>"
+      // PrivilegeCode: "USER_VIEW"
+      const systemCode =
+        ApplicationConfig.getComponentConfigValue('system-code');
+      const isPrivileged = await loginUser.checkPrivileges(
+        systemCode,
+        'USER_VIEW',
+      );
+
+      // If user does not have privilege to update user, throw a ClassError
+      if (!isPrivileged) {
+        throw new ClassError(
+          'LoginUser',
+          'LoginUserErrMsg0X',
+          'You do not have the privilege to find user',
+        );
+      }
+
+      // Part 2: Retrieve User & Returns
+      // Call User._Repo findOne method by passing:
+      // where:
+      // Email: Param.Email
+      // Status: 'Active'
+      // dbTransaction
+
+      const user = await User._Repository.findOne({
+        where: {
+          Email: Email,
+        },
+        include: [
+          {
+            model: Staff,
+          },
+        ],
+        transaction: dbTransaction,
+      });
+      // Instantiate new User by mapping all user info returned from above step.
+      if (!user) {
+        // If user not found, throw new ClassError by passing:
+        // Classname: "User"
+        // MethodName: "findByEmail"
+        // MessageCode: "UserErrMsg0X"
+        // Message: "User not found."
+
+        throw new ClassError('User', 'UserErrMsg0X', 'User not found.');
+      }
+
+      const userAttr: IUserAttr = {
+        UserId: user.UserId,
+        UserName: user.UserName,
+        FullName: user?.FullName || null,
+        IDNo: user?.IdNo || null,
+        IDType: user?.IdType || null,
+        ContactNo: user?.ContactNo || null,
+        Email: user.Email,
+        Password: user.Password,
+        Status: user.Status,
+        DefaultPasswordChangedYN: user.DefaultPasswordChangedYN,
+        FirstLoginAt: user.FirstLoginAt,
+        LastLoginAt: user.LastLoginAt,
+        MFAEnabled: user.MFAEnabled,
+        MFAConfig: user.MFAConfig,
+        RecoveryEmail: user.RecoveryEmail,
+        FailedLoginAttemptCount: user.FailedLoginAttemptCount,
+        LastFailedLoginAt: user.LastFailedLoginAt,
+        LastPasswordChangedAt: user.LastPasswordChangedAt,
+        NeedToChangePasswordYN: user.NeedToChangePasswordYN,
+        CreatedById: user.CreatedById,
+        CreatedAt: user.CreatedAt,
+        UpdatedById: user.UpdatedById,
+        UpdatedAt: user.UpdatedAt,
+        staffs: user?.Staff,
+      };
+      const sessionService = await SessionService.init(undefined);
+      const usr = new User(sessionService, undefined, userAttr);
+
+      return usr;
+      // Return the user instance.
+    } catch (error) {
+      throw error;
+    }
+  }
 }

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

@@ -1,6 +1,10 @@
 import { ClassError, ObjectBase } from '@tomei/general';
 import { UserGroupRepository } from './user-group.repository';
 import { IUserGroupAttr } from '../../interfaces/user-group.interface';
+import { LoginUser, User } from 'components/login-user';
+import { Group } from 'components/group';
+import { ApplicationConfig } from '@tomei/config';
+import { ActionEnum, Activity } from '@tomei/activity-history';
 
 export class UserGroup extends ObjectBase {
   ObjectType = 'UserGroup';
@@ -10,8 +14,8 @@ export class UserGroup extends ObjectBase {
   UserGroupId: number;
   UserId: number;
   GroupCode: string;
-  InheritGroupPrivilegeYN: string;
-  InheritGroupSystemAccessYN: string;
+  InheritGroupPrivilegeYN = 'Y';
+  InheritGroupSystemAccessYN = 'Y';
   Status: string;
   private _CreatedAt: Date;
   private _UpdatedAt: Date;
@@ -87,4 +91,208 @@ export class UserGroup extends ObjectBase {
       throw error;
     }
   }
+
+  async create(
+    loginUser: LoginUser,
+    dbTransaction: any,
+    group: Group,
+    user: User,
+  ) {
+    //This method will create a user group record.
+    try {
+      // Part 1: Privilege Checking
+      // Call loginUser.checkPrivileges() by passing:
+      // SystemCode: "<get_from_app_config>"
+      // PrivilegeCode: "USER_GROUP_CREATE"
+      const systemCode =
+        ApplicationConfig.getComponentConfigValue('system-code');
+      const isPrivileged = await loginUser.checkPrivileges(
+        systemCode,
+        'USER_GROUP_CREATE',
+      );
+
+      // If user does not have privilege to update user, throw a ClassError
+      if (!isPrivileged) {
+        throw new ClassError(
+          'UserGroup',
+          'UserGroupErrMsg0X',
+          'User does not have privilege to create user group.',
+        );
+      }
+
+      // Part 2: Validation
+      // Make sure group.GroupCode exists, if not throw new ClassError by passing:
+      // Classname: "UserGroup"
+      // MethodName: "create"
+      // MessageCode: "UserGroupErrMsg02"
+      // Message: "GroupCode is required."
+      if (!group.GroupCode) {
+        throw new ClassError(
+          'UserGroup',
+          'UserGroupErrMsg02',
+          'GroupCode is required.',
+        );
+      }
+
+      // Make sure user.UserId exists, if not throw new ClassError by passing:
+      // Classname: "UserGroup"
+      // MethodName: "create"
+      // MessageCode: "UserGroupErrMsg03"
+      // Message: "UserId is required."
+      if (!user.UserId) {
+        throw new ClassError(
+          'UserGroup',
+          'UserGroupErrMsg03',
+          'UserId is required.',
+        );
+      }
+
+      // Call UserGroup.findOne static method by passing:
+      // loginUser
+      // dbTransaction
+      // GroupCode: group.GroupCode
+      // UserId: user.UserId
+      const userGroup = await UserGroup.findOne(
+        dbTransaction,
+        loginUser,
+        group.GroupCode,
+        user.UserId,
+      );
+
+      if (userGroup) {
+        return userGroup;
+      }
+
+      // Part 3: Create
+      // Set below attributes:
+      // UserGroupId: this.createId()
+      // UserId: Params.user.UserId
+      // GroupCode: Params.group.GroupCode
+      // Status: "Active"
+      // CreatedById: loginUser.ObjectId
+      // CreatedAt: current timestamp
+      // UpdatedById: loginUser.ObjectId
+      // UpdatedAt: current timestamp
+      this.UserId = user.UserId;
+      this.GroupCode = group.GroupCode;
+      this.Status = 'Active';
+      this._CreatedById = loginUser.UserId;
+      this._CreatedAt = new Date();
+      this._UpdatedById = loginUser.UserId;
+      this._UpdatedAt = new Date();
+
+      // Call UserGroup._Repo create() method by passing:
+      // populate this instance attributes
+      // dbTransaction
+
+      const userData = await UserGroup._Repository.create(
+        {
+          UserId: this.UserId,
+          GroupCode: this.GroupCode,
+          Status: this.Status,
+          CreatedById: this._CreatedById,
+          CreatedAt: this._CreatedAt,
+          UpdatedById: this._UpdatedById,
+          UpdatedAt: this._UpdatedAt,
+          InheritGroupPrivilegeYN: this.InheritGroupPrivilegeYN,
+          InheritGroupSystemAccessYN: this.InheritGroupSystemAccessYN,
+        },
+        {
+          transaction: dbTransaction,
+        },
+      );
+
+      this.UserGroupId = userData.UserGroupId;
+
+      // Part 4: Record Create UserGroup Activity
+      // Initialise EntityValueAfter variable and set to this instance
+      const EntityValueAfter = {
+        UserGroupId: this.UserGroupId,
+        UserId: this.UserId,
+        GroupCode: this.GroupCode,
+        Status: this.Status,
+        CreatedById: this._CreatedById,
+        CreatedAt: this._CreatedAt,
+        UpdatedById: this._UpdatedById,
+        UpdatedAt: this._UpdatedAt,
+        InheritGroupPrivilegeYN: this.InheritGroupPrivilegeYN,
+        InheritGroupSystemAccessYN: this.InheritGroupSystemAccessYN,
+      };
+      // Instantiate new activity from Activity class, call createId() method, then set:
+      // Action: ActionEnum.Create
+      // Description: Assign user to group.
+      // EntityType: "UserGroup"
+      // EntityId: this.UserGroupId
+      // EntityValueBefore: <stringify of empty object>
+      // EntityValueAfter: EntityValueAfter
+      const activity = new Activity();
+      activity.Action = ActionEnum.ADD;
+      activity.Description = 'Assign user to group.';
+      activity.EntityType = 'UserGroup';
+      activity.EntityId = this.UserGroupId.toString();
+      activity.EntityValueBefore = JSON.stringify({});
+      activity.EntityValueAfter = JSON.stringify(EntityValueAfter);
+      // Call new activity create method by passing:
+      // dbTransaction
+      // userId: loginUser.ObjectId
+      // return this instance
+      await activity.create(loginUser.ObjectId, dbTransaction);
+
+      return this;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public static async findOne(
+    dbTransaction: any,
+    loginUser: LoginUser,
+    GroupCode: string,
+    UserId: number,
+  ): Promise<UserGroup> {
+    try {
+      // Part 1: Privilege Checking
+      // Call loginUser.checkPrivileges() by passing:
+      // SystemCode: "<get_from_app_config>"
+      // PrivilegeCode: "USER_GROUP_VIEW"
+      const systemCode =
+        ApplicationConfig.getComponentConfigValue('system-code');
+      const isPrivileged = await loginUser.checkPrivileges(
+        systemCode,
+        'USER_GROUP_VIEW',
+      );
+
+      // If user does not have privilege to view user group, throw a ClassError
+      if (!isPrivileged) {
+        throw new ClassError(
+          'UserGroup',
+          'UserGroupErrMsg0X',
+          'User does not have privilege to view user group.',
+        );
+      }
+
+      // Part 2: Retrieve Record
+      // Call UserGroup._Repo findOne method by passing:
+      // where:
+      // [Op.AND]:
+      // UserId: Params.UserId
+      // GroupCode: Params.GroupCode
+      // dbTransaction
+      const userGroupAttr = await UserGroup._Repository.findOne({
+        where: {
+          UserId,
+          GroupCode,
+        },
+        transaction: dbTransaction,
+      });
+      // If record exists, instantiate UserGroup by calling the private constructor and passing the attributes. Then, returns the instance
+      if (userGroupAttr) {
+        return new UserGroup(userGroupAttr.get({ plain: true }));
+      }
+      // If record not exists, return null.
+      return null;
+    } catch (error) {
+      throw error;
+    }
+  }
 }