@tomei/sso 0.28.6 → 0.29.1

package/package.json

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

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

@@ -225,6 +225,7 @@ export class LoginUser extends LoginUserBase {
 
   async getDetails(): Promise<{
     FullName: string;
+    UserName: string;
     IDNo: string;
     IDType: string;
     Email: string;
@@ -232,6 +233,7 @@ export class LoginUser extends LoginUserBase {
   }> {
     return {
       FullName: this.FullName,
+      UserName: this.UserName,
       IDNo: this.IDNo,
       IDType: this.IDType,
       Email: this.Email,
@@ -338,6 +340,36 @@ export class LoginUser extends LoginUserBase {
     return new LoginUser(sessionService, dbTransaction);
   }
 
+  async setEmail(email: string, dbTransaction): Promise<void> {
+    try {
+      //Check if email is not the same as the current email if it is, skip all the steps
+      if (this.Email === email) {
+        return;
+      }
+
+      //Check if email is duplicated, if yes, throw error
+      const user = await LoginUser._Repository.findOne({
+        where: {
+          Email: email,
+        },
+        transaction: dbTransaction,
+      });
+
+      if (user) {
+        throw new ClassError(
+          'LoginUser',
+          'LoginUserErrMsg0X',
+          'Email already exists',
+        );
+      }
+
+      //Update the email
+      this.Email = email;
+    } catch (error) {
+      throw error;
+    }
+  }
+
   async login(
     systemCode: string,
     email: string,
@@ -1910,4 +1942,396 @@ export class LoginUser extends LoginUserBase {
     );
     return `${userId}:${systemLogin.sessionId}`;
   }
+
+  public async addUserGroup(
+    GroupCode: string,
+    loginUser: LoginUser,
+    dbTransaction: any,
+  ) {
+    // 1. Retrieve group data by calling LoginUser._GroupRepo.findOne with GroupCode
+    const group = await LoginUser._GroupRepo.findOne({
+      where: {
+        GroupCode,
+      },
+      transaction: dbTransaction,
+    });
+
+    // 2. If group data not found then return throw Class Error
+    if (!group) {
+      throw new ClassError(
+        'LoginUser',
+        'LoginUserErrMsg0X',
+        'Invalid Group Code',
+      );
+    }
+
+    //3. Create new UserGroup record
+    const entityValueAfter = {
+      UserId: this.UserId,
+      GroupCode: group.GroupCode,
+      CreatedAt: new Date(),
+      CreatedById: loginUser.UserId,
+      UpdatedAt: new Date(),
+      UpdatedById: loginUser.UserId,
+    };
+    await LoginUser._UserGroupRepo.create(entityValueAfter, {
+      transaction: dbTransaction,
+    });
+
+    //4. Record Create UserGroup Activity
+    const activity = new Activity();
+    activity.ActivityId = activity.createId();
+    activity.Action = ActionEnum.ADD;
+    activity.Description = 'Add User Group';
+    activity.EntityType = 'UserGroup';
+    activity.EntityId = group.GroupCode;
+    activity.EntityValueBefore = JSON.stringify({});
+    activity.EntityValueAfter = JSON.stringify(entityValueAfter);
+
+    await activity.create(loginUser.ObjectId, dbTransaction);
+  }
+
+  public async update(
+    data: {
+      UserName: string;
+      Email: string;
+      Status: UserStatus;
+      RecoveryEmail: string;
+      BuildingCode?: string;
+      CompanyCode?: string;
+      DepartmentCode?: string;
+    },
+    loginUser: LoginUser,
+    dbTransaction: any,
+  ) {
+    //Part 1: Privilege Checking
+    const systemCode = ApplicationConfig.getComponentConfigValue('system-code');
+    const isPrivileged = await loginUser.checkPrivileges(
+      systemCode,
+      'User - Update',
+    );
+
+    //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 update user',
+      );
+    }
+
+    //Part 2: Validation
+    //Make sure UserId got values. If not, throw new ClassError
+    if (!this.UserId) {
+      throw new ClassError(
+        'LoginUser',
+        'LoginUserErrMsg0X',
+        'UserId is required',
+      );
+    }
+
+    //Make sure email is unique, call LoginUser.CheckUserInfoDuplicated method
+    if (data.Email !== this.Email || data.UserName !== this.UserName) {
+      await LoginUser.checkUserInfoDuplicated(dbTransaction, {
+        Email: data.Email,
+        UserName: data.UserName,
+      });
+    }
+
+    //Part 3: Update Building, Company, Department
+    //If Params.BuildingCode is not null,
+    if (data.BuildingCode) {
+      //Check if BuildingCode is valid, call GroupModel.findOne method
+      const building = await GroupModel.findOne({
+        where: {
+          Type: 'Building',
+          GroupCode: data.BuildingCode,
+        },
+        transaction: dbTransaction,
+      });
+
+      //If BuildingCode is invalid, throw new ClassError
+      if (!building) {
+        throw new ClassError(
+          'LoginUser',
+          'LoginUserErrMsg0X',
+          'Invalid Building Code',
+        );
+      }
+
+      //If BuildingCode is valid, call UserGroup.findOne method to find the user building record
+      const userBuilding = await LoginUser._UserGroupRepo.findOne({
+        where: {
+          UserId: this.UserId,
+        },
+        include: [
+          {
+            model: GroupModel,
+            where: {
+              Type: 'Building',
+            },
+          },
+        ],
+        transaction: dbTransaction,
+      });
+
+      //If user building record found, call UserGroup.update method to update the record if not found, call UserGroup.create method to create new record
+      if (userBuilding) {
+        await LoginUser._UserGroupRepo.update(
+          {
+            GroupCode: data.BuildingCode,
+            UpdatedAt: new Date(),
+            UpdatedById: loginUser.UserId,
+          },
+          {
+            where: {
+              UserId: this.UserId,
+              GroupCode: userBuilding.GroupCode,
+            },
+            transaction: dbTransaction,
+          },
+        );
+      } else {
+        await LoginUser._UserGroupRepo.create(
+          {
+            UserId: this.UserId,
+            GroupCode: data.BuildingCode,
+            CreatedAt: new Date(),
+            CreatedById: loginUser.UserId,
+            UpdatedAt: new Date(),
+            UpdatedById: loginUser.UserId,
+          },
+          {
+            transaction: dbTransaction,
+          },
+        );
+      }
+    }
+
+    //If Params.CompanyCode is not null,
+    if (data.CompanyCode) {
+      //Check if CompanyCode is valid, call GroupModel.findOne method
+      const company = await GroupModel.findOne({
+        where: {
+          Type: 'Company',
+          GroupCode: data.CompanyCode,
+        },
+        transaction: dbTransaction,
+      });
+
+      //If CompanyCode is invalid, throw a ClassError
+      if (!company) {
+        throw new ClassError(
+          'LoginUser',
+          'LoginUserErrMsg0X',
+          'Invalid Company Code',
+        );
+      }
+
+      //If CompanyCode is valid, call UserGroup.findOne method to find the user company record
+      const userCompany = await LoginUser._UserGroupRepo.findOne({
+        where: {
+          UserId: this.UserId,
+        },
+        include: [
+          {
+            model: GroupModel,
+            where: {
+              Type: 'Company',
+            },
+          },
+        ],
+        transaction: dbTransaction,
+      });
+
+      //If user company record found, call UserGroup.update method to update the record if not found, call UserGroup.create method to create new record
+      if (userCompany) {
+        await LoginUser._UserGroupRepo.update(
+          {
+            GroupCode: data.CompanyCode,
+            UpdatedAt: new Date(),
+            UpdatedById: loginUser.UserId,
+          },
+          {
+            where: {
+              UserId: this.UserId,
+              GroupCode: userCompany.GroupCode,
+            },
+            transaction: dbTransaction,
+          },
+        );
+      } else {
+        await LoginUser._UserGroupRepo.create(
+          {
+            UserId: this.UserId,
+            GroupCode: data.CompanyCode,
+            CreatedAt: new Date(),
+            CreatedById: loginUser.UserId,
+            UpdatedAt: new Date(),
+            UpdatedById: loginUser.UserId,
+          },
+          {
+            transaction: dbTransaction,
+          },
+        );
+      }
+    }
+
+    //If Params.DepartmentCode is not null,
+    if (data.DepartmentCode) {
+      //Check if DepartmentCode is valid, call GroupModel.findOne method
+      const department = await GroupModel.findOne({
+        where: {
+          Type: 'Department',
+          GroupCode: data.DepartmentCode,
+        },
+        transaction: dbTransaction,
+      });
+
+      //If DepartmentCode is invalid, throw a ClassError
+      if (!department) {
+        throw new ClassError(
+          'LoginUser',
+          'LoginUserErrMsg0X',
+          'Invalid Department Code',
+        );
+      }
+
+      //If DepartmentCode is valid, call UserGroup.findOne method to find the user department record
+      const userDepartment = await LoginUser._UserGroupRepo.findOne({
+        where: {
+          UserId: this.UserId,
+        },
+        include: [
+          {
+            model: GroupModel,
+            where: {
+              Type: 'Department',
+            },
+          },
+        ],
+        transaction: dbTransaction,
+      });
+
+      //If user department record found, call UserGroup.update method to update the record if not found, call UserGroup.create method to create new record
+      if (userDepartment) {
+        await LoginUser._UserGroupRepo.update(
+          {
+            GroupCode: data.DepartmentCode,
+            UpdatedAt: new Date(),
+            UpdatedById: loginUser.UserId,
+          },
+          {
+            where: {
+              UserId: this.UserId,
+              GroupCode: userDepartment.GroupCode,
+            },
+            transaction: dbTransaction,
+          },
+        );
+      } else {
+        await LoginUser._UserGroupRepo.create(
+          {
+            UserId: this.UserId,
+            GroupCode: data.DepartmentCode,
+            CreatedAt: new Date(),
+            CreatedById: loginUser.UserId,
+            UpdatedAt: new Date(),
+            UpdatedById: loginUser.UserId,
+          },
+          {
+            transaction: dbTransaction,
+          },
+        );
+      }
+    }
+
+    //Part 4: Update User Record
+    //Set EntityValueBefore
+    const entityValueBefore = {
+      UserId: this.UserId,
+      UserName: this.UserName,
+      Email: this.Email,
+      Password: this.Password,
+      Status: this.Status,
+      DefaultPasswordChangedYN: this.DefaultPasswordChangedYN,
+      FirstLoginAt: this.FirstLoginAt,
+      LastLoginAt: this.LastLoginAt,
+      MFAEnabled: this.MFAEnabled,
+      MFAConfig: this.MFAConfig,
+      RecoveryEmail: this.RecoveryEmail,
+      FailedLoginAttemptCount: this.FailedLoginAttemptCount,
+      LastFailedLoginAt: this.LastFailedLoginAt,
+      LastPasswordChangedAt: this.LastPasswordChangedAt,
+      NeedToChangePasswordYN: this.NeedToChangePasswordYN,
+      CreatedById: this.CreatedById,
+      CreatedAt: this.CreatedAt,
+      UpdatedById: this.UpdatedById,
+      UpdatedAt: this.UpdatedAt,
+    };
+
+    //Update user record
+    this.UserName = data.UserName;
+    this.Email = data.Email;
+    this.Status = data.Status;
+    this.RecoveryEmail = data.RecoveryEmail;
+    this.UpdatedAt = new Date();
+    this.UpdatedById = loginUser.UserId;
+    //Call LoginUser._Repo update method to update user record
+    await LoginUser._Repository.update(
+      {
+        UserName: this.UserName,
+        Email: this.Email,
+        Status: this.Status,
+        RecoveryEmail: this.RecoveryEmail,
+        UpdatedById: this.UpdatedById,
+        UpdatedAt: this.UpdatedAt,
+      },
+      {
+        where: {
+          UserId: this.UserId,
+        },
+        transaction: dbTransaction,
+      },
+    );
+
+    //Part 5: Record Update User Activity
+    //Set EntityValueAfter
+    const entityValueAfter = {
+      UserId: this.UserId,
+      UserName: this.UserName,
+      Email: this.Email,
+      Password: this.Password,
+      Status: this.Status,
+      DefaultPasswordChangedYN: this.DefaultPasswordChangedYN,
+      FirstLoginAt: this.FirstLoginAt,
+      LastLoginAt: this.LastLoginAt,
+      MFAEnabled: this.MFAEnabled,
+      MFAConfig: this.MFAConfig,
+      RecoveryEmail: this.RecoveryEmail,
+      FailedLoginAttemptCount: this.FailedLoginAttemptCount,
+      LastFailedLoginAt: this.LastFailedLoginAt,
+      LastPasswordChangedAt: this.LastPasswordChangedAt,
+      NeedToChangePasswordYN: this.NeedToChangePasswordYN,
+      CreatedById: this.CreatedById,
+      CreatedAt: this.CreatedAt,
+      UpdatedById: this.UpdatedById,
+      UpdatedAt: this.UpdatedAt,
+    };
+
+    //Call Activity.create method to create new activity record
+    const activity = new Activity();
+    activity.ActivityId = activity.createId();
+    activity.Action = ActionEnum.UPDATE;
+    activity.Description = 'Update User';
+    activity.EntityType = 'LoginUser';
+    activity.EntityId = this.UserId.toString();
+    activity.EntityValueBefore = JSON.stringify(entityValueBefore);
+    activity.EntityValueAfter = JSON.stringify(entityValueAfter);
+
+    await activity.create(loginUser.ObjectId, dbTransaction);
+
+    //Return Updated User Instance
+    return this;
+  }
 }