@tomei/sso 0.36.0 → 0.37.1

package/package.json

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

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;
+    }
+  }
 }