@tomei/sso 0.60.4-staging.1 → 0.61.0

package/src/components/user-object-privilege/index.ts

@@ -1,2 +1,2 @@
-export * from './user-object-privilege';
-export * from './user-object-privilege.repository';
+export * from './user-object-privilege';
+export * from './user-object-privilege.repository';

package/src/components/user-object-privilege/user-object-privilege.repository.ts

@@ -1,11 +1,11 @@
-import UserObjectPrivilegeModel from '../../models/user-object-privilege.entity';
-import { RepositoryBase, IRepositoryBase } from '@tomei/general';
-
-export class UserObjectPrivilegeRepository
-  extends RepositoryBase<UserObjectPrivilegeModel>
-  implements IRepositoryBase<UserObjectPrivilegeModel>
-{
-  constructor() {
-    super(UserObjectPrivilegeModel);
-  }
-}
+import UserObjectPrivilegeModel from '../../models/user-object-privilege.entity';
+import { RepositoryBase, IRepositoryBase } from '@tomei/general';
+
+export class UserObjectPrivilegeRepository
+  extends RepositoryBase<UserObjectPrivilegeModel>
+  implements IRepositoryBase<UserObjectPrivilegeModel>
+{
+  constructor() {
+    super(UserObjectPrivilegeModel);
+  }
+}

package/src/components/user-object-privilege/user-object-privilege.ts

@@ -1,79 +1,79 @@
-import { ClassError, ObjectBase } from '@tomei/general';
-import { UserObjectPrivilegeRepository } from './user-object-privilege.repository';
-import { IUserObjectPrivilegeAttr } from '../../interfaces/user-object-privilege.interface';
-import { ObjectStatus } from '../../enum/object-status.enum';
-
-export class UserObjectPrivilege extends ObjectBase {
-  TableName = 'sso_UserObjectPrivilege';
-  ObjectName: string;
-  ObjectPrivilegeId: number;
-  UserId: number;
-  SystemPrivilegeId: string;
-  ObjectId: string;
-  ObjectType: string;
-  Status: ObjectStatus;
-  private _CreatedAt: Date;
-  private _UpdatedAt: Date;
-  private _CreatedById: number;
-  private _UpdatedById: number;
-
-  get CreatedAt() {
-    return this._CreatedAt;
-  }
-
-  get UpdatedAt() {
-    return this._UpdatedAt;
-  }
-
-  get CreatedById() {
-    return this._CreatedById;
-  }
-
-  get UpdatedById() {
-    return this._UpdatedById;
-  }
-
-  private static _Repository = new UserObjectPrivilegeRepository();
-
-  private constructor(userObjectPrivilegeAttr?: IUserObjectPrivilegeAttr) {
-    super();
-    if (userObjectPrivilegeAttr) {
-      this.ObjectPrivilegeId = userObjectPrivilegeAttr.ObjectPrivilegeId;
-      this.UserId = userObjectPrivilegeAttr.UserId;
-      this.SystemPrivilegeId = userObjectPrivilegeAttr.SystemPrivilegeId;
-      this.ObjectId = userObjectPrivilegeAttr.ObjectId;
-      this.ObjectType = userObjectPrivilegeAttr.ObjectType;
-      this.Status = userObjectPrivilegeAttr.Status;
-      this._CreatedAt = userObjectPrivilegeAttr.CreatedAt;
-      this._UpdatedAt = userObjectPrivilegeAttr.UpdatedAt;
-      this._CreatedById = userObjectPrivilegeAttr.CreatedById;
-      this._UpdatedById = userObjectPrivilegeAttr.UpdatedById;
-    }
-  }
-
-  public static async init(dbTransaction?: any, ObjectPrivilegeId?: number) {
-    try {
-      const userObjectPrivilege = new UserObjectPrivilege();
-      if (ObjectPrivilegeId) {
-        const userObjectPrivilegeAttr = await this._Repository.findOne({
-          where: { ObjectPrivilegeId },
-          transaction: dbTransaction,
-        });
-        if (userObjectPrivilegeAttr) {
-          return new UserObjectPrivilege(
-            userObjectPrivilegeAttr.get({ plain: true }),
-          );
-        } else {
-          throw new ClassError(
-            'UserObjectPrivilege',
-            'UserObjectPrivilegeErrMsg00',
-            'UserObjectPrivilege not found',
-          );
-        }
-      }
-      return userObjectPrivilege;
-    } catch (error) {
-      throw error;
-    }
-  }
-}
+import { ClassError, ObjectBase } from '@tomei/general';
+import { UserObjectPrivilegeRepository } from './user-object-privilege.repository';
+import { IUserObjectPrivilegeAttr } from '../../interfaces/user-object-privilege.interface';
+import { ObjectStatus } from '../../enum/object-status.enum';
+
+export class UserObjectPrivilege extends ObjectBase {
+  TableName = 'sso_UserObjectPrivilege';
+  ObjectName: string;
+  ObjectPrivilegeId: number;
+  UserId: number;
+  SystemPrivilegeId: string;
+  ObjectId: string;
+  ObjectType: string;
+  Status: ObjectStatus;
+  private _CreatedAt: Date;
+  private _UpdatedAt: Date;
+  private _CreatedById: number;
+  private _UpdatedById: number;
+
+  get CreatedAt() {
+    return this._CreatedAt;
+  }
+
+  get UpdatedAt() {
+    return this._UpdatedAt;
+  }
+
+  get CreatedById() {
+    return this._CreatedById;
+  }
+
+  get UpdatedById() {
+    return this._UpdatedById;
+  }
+
+  private static _Repository = new UserObjectPrivilegeRepository();
+
+  private constructor(userObjectPrivilegeAttr?: IUserObjectPrivilegeAttr) {
+    super();
+    if (userObjectPrivilegeAttr) {
+      this.ObjectPrivilegeId = userObjectPrivilegeAttr.ObjectPrivilegeId;
+      this.UserId = userObjectPrivilegeAttr.UserId;
+      this.SystemPrivilegeId = userObjectPrivilegeAttr.SystemPrivilegeId;
+      this.ObjectId = userObjectPrivilegeAttr.ObjectId;
+      this.ObjectType = userObjectPrivilegeAttr.ObjectType;
+      this.Status = userObjectPrivilegeAttr.Status;
+      this._CreatedAt = userObjectPrivilegeAttr.CreatedAt;
+      this._UpdatedAt = userObjectPrivilegeAttr.UpdatedAt;
+      this._CreatedById = userObjectPrivilegeAttr.CreatedById;
+      this._UpdatedById = userObjectPrivilegeAttr.UpdatedById;
+    }
+  }
+
+  public static async init(dbTransaction?: any, ObjectPrivilegeId?: number) {
+    try {
+      const userObjectPrivilege = new UserObjectPrivilege();
+      if (ObjectPrivilegeId) {
+        const userObjectPrivilegeAttr = await this._Repository.findOne({
+          where: { ObjectPrivilegeId },
+          transaction: dbTransaction,
+        });
+        if (userObjectPrivilegeAttr) {
+          return new UserObjectPrivilege(
+            userObjectPrivilegeAttr.get({ plain: true }),
+          );
+        } else {
+          throw new ClassError(
+            'UserObjectPrivilege',
+            'UserObjectPrivilegeErrMsg00',
+            'UserObjectPrivilege not found',
+          );
+        }
+      }
+      return userObjectPrivilege;
+    } catch (error) {
+      throw error;
+    }
+  }
+}

package/src/components/user-password-history/index.ts

@@ -1,2 +1,2 @@
-export * from './user-password-history';
-export * from './user-password-history.repository';
+export * from './user-password-history';
+export * from './user-password-history.repository';

package/src/components/user-password-history/user-password-history.repository.ts

@@ -1,39 +1,39 @@
-import { RepositoryBase, IRepositoryBase } from '@tomei/general';
-import UserPasswordHistoryModel from '../../models/user-password-history';
-import { Op } from 'sequelize';
-
-export class UserPasswordHistoryRepository
-  extends RepositoryBase<UserPasswordHistoryModel>
-  implements IRepositoryBase<UserPasswordHistoryModel>
-{
-  constructor() {
-    super(UserPasswordHistoryModel);
-  }
-
-  async findByPk(id: string, options?: any): Promise<UserPasswordHistoryModel> {
-    return await UserPasswordHistoryModel.findByPk(parseInt(id), options);
-  }
-
-  async destroy(HistoryId: number, dbTransaction: any): Promise<void> {
-    await UserPasswordHistoryModel.destroy({
-      where: {
-        HistoryId: HistoryId,
-      },
-      transaction: dbTransaction,
-    });
-  }
-
-  async destroyMultiple(
-    HistoryIdList: string[],
-    dbTransaction: any,
-  ): Promise<void> {
-    await UserPasswordHistoryModel.destroy({
-      where: {
-        HistoryId: {
-          [Op.in]: HistoryIdList,
-        },
-      },
-      transaction: dbTransaction,
-    });
-  }
-}
+import { RepositoryBase, IRepositoryBase } from '@tomei/general';
+import UserPasswordHistoryModel from '../../models/user-password-history';
+import { Op } from 'sequelize';
+
+export class UserPasswordHistoryRepository
+  extends RepositoryBase<UserPasswordHistoryModel>
+  implements IRepositoryBase<UserPasswordHistoryModel>
+{
+  constructor() {
+    super(UserPasswordHistoryModel);
+  }
+
+  async findByPk(id: string, options?: any): Promise<UserPasswordHistoryModel> {
+    return await UserPasswordHistoryModel.findByPk(parseInt(id), options);
+  }
+
+  async destroy(HistoryId: number, dbTransaction: any): Promise<void> {
+    await UserPasswordHistoryModel.destroy({
+      where: {
+        HistoryId: HistoryId,
+      },
+      transaction: dbTransaction,
+    });
+  }
+
+  async destroyMultiple(
+    HistoryIdList: string[],
+    dbTransaction: any,
+  ): Promise<void> {
+    await UserPasswordHistoryModel.destroy({
+      where: {
+        HistoryId: {
+          [Op.in]: HistoryIdList,
+        },
+      },
+      transaction: dbTransaction,
+    });
+  }
+}

package/src/components/user-password-history/user-password-history.ts

@@ -1,187 +1,187 @@
-import { ClassError, ObjectBase } from '@tomei/general';
-import { ComponentConfig } from '@tomei/config';
-import { IUserPasswordHistoryAttr } from '../../interfaces/user-password-history.interface';
-import { UserPasswordHistoryRepository } from './user-password-history.repository';
-import { PasswordHashService } from '../../components/password-hash';
-
-export class UserPasswordHistory
-  extends ObjectBase
-  implements IUserPasswordHistoryAttr
-{
-  ObjectId: string;
-  ObjectName: string;
-  ObjectType = 'UserPasswordHistory';
-  TableName = 'sso_UserPasswordHistory';
-  UserId: number;
-  PasswordHash: string;
-  private _CreatedAt: Date;
-
-  private static _Repo = new UserPasswordHistoryRepository();
-
-  get HistoryId(): string {
-    return this.ObjectId;
-  }
-
-  set HistoryId(value: string) {
-    this.ObjectId = value;
-  }
-
-  get CreatedAt(): Date {
-    return this._CreatedAt;
-  }
-
-  private constructor(params?: IUserPasswordHistoryAttr) {
-    super();
-    if (params) {
-      this.ObjectId = params.HistoryId;
-      this.UserId = params.UserId;
-      this.PasswordHash = params.PasswordHash;
-      this._CreatedAt = params.CreatedAt;
-    }
-  }
-
-  public static async init(
-    historyId?: number,
-    dbTransaction?: any,
-  ): Promise<UserPasswordHistory> {
-    try {
-      if (historyId) {
-        const data = await UserPasswordHistory._Repo.findByPk(
-          historyId.toString(),
-          dbTransaction,
-        );
-        if (!data) {
-          throw new ClassError(
-            'UserPasswordHistory',
-            'UserPasswordHistoryErrMsg01',
-            'UserPasswordHistory not found',
-            'init',
-            400,
-          );
-        }
-
-        return new UserPasswordHistory(data.get({ plain: true }));
-      }
-      return new UserPasswordHistory();
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  public static async validate(
-    dbTransaction: any,
-    UserId: number,
-    Password: string,
-    passwordHashService: PasswordHashService,
-  ): Promise<void> {
-    // This method used to check if password entered is valid by checking previous password history
-    try {
-      // Part 1-2: Retrieve password history policy by using component config, call ComponentConfig. by passing:
-      // - ComponentName: "@tomei/sso"
-      // - ConfigKey: "passwordHistory"
-      // If no password history set, use default value 3
-
-      const passwordHistoryPolicy =
-        ComponentConfig.getComponentConfigValue(
-          '@tomei/sso',
-          'passwordHistory',
-        ) || 3;
-
-      // Part 3-4: Retrieve records from the table by using  class._repo findAll() by passing:
-      // where: { UserId: params.UserId }
-      // order: [['CreatedAt', 'DESC']]
-      // limit: passwordHistory count above.
-      // If no record found, return null.
-
-      let passwordHistory = await UserPasswordHistory._Repo.findAll({
-        where: { UserId: UserId },
-        order: [['CreatedAt', 'DESC']],
-        limit: passwordHistoryPolicy,
-        transaction: dbTransaction,
-      });
-
-      if (passwordHistory?.length < 1) {
-        return null;
-      } else {
-        // Part 5: If record found, map each record to compare params.Password and record.PasswordHash using the params.passwordHashService. If match, stop the mapping, and return ClassError:
-        // ClassName: "UserPasswordHistory"
-        // MethodName: "validate"
-        // MessageCode: "UserPasswordHistory01"
-        // Message: You cannot reuse your last ${passwordHistory} passwords. Please choose a new and unique password.
-        for (let index = 0; index < passwordHistory.length; index++) {
-          const isPasswordSame = await passwordHashService.verify(
-            Password,
-            passwordHistory[index].PasswordHash,
-          );
-
-          if (isPasswordSame) {
-            throw new ClassError(
-              'UserPasswordHistory',
-              'UserPasswordHistory01',
-              `You cannot reuse your last ${passwordHistoryPolicy} passwords. Please choose a new and unique password.`,
-              'validate',
-              403,
-            );
-          }
-        }
-      }
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  public static async create(
-    dbTransaction: any,
-    UserId: number,
-    PasswordHash: string,
-  ): Promise<void> {
-    // This method used to check if password entered is valid by checking previous password history
-    try {
-      // Part 1-2: Retrieve password history policy by using component config, call ComponentConfig. by passing:
-      // - ComponentName: "@tomei/sso"
-      // - ConfigKey: "passwordHistory"
-      // If no password history set, use default value 3
-
-      const passwordHistoryPolicy =
-        ComponentConfig.getComponentConfigValue(
-          '@tomei/sso',
-          'passwordHistory',
-        ) || 3;
-
-      // Part 3: Insert new password history by calling class _repo create() method.
-      const userPasswordHistory = new UserPasswordHistory();
-      let passwordHistory = await UserPasswordHistory._Repo.create(
-        {
-          HistoryId: userPasswordHistory.createId(),
-          UserId: UserId,
-          PasswordHash: PasswordHash,
-        },
-        {
-          transaction: dbTransaction,
-        },
-      );
-
-      // Part 3: When inserted successfully, retrieve all the password history for the user to check
-      // how many previous password records. If records more than the passwordHistory count from
-      // config. Remove the oldest record.
-      if (passwordHistory) {
-        let passwordHistoryList = await UserPasswordHistory._Repo.findAll({
-          where: { UserId: UserId },
-          order: [['CreatedAt', 'DESC']],
-          transaction: dbTransaction,
-        });
-
-        if (passwordHistoryList.length > passwordHistoryPolicy) {
-          let deleteList = passwordHistoryList.slice(passwordHistoryPolicy);
-          let historyIdList = deleteList.map((record) => record.HistoryId);
-          await UserPasswordHistory._Repo.destroyMultiple(
-            historyIdList,
-            dbTransaction,
-          );
-        }
-      }
-    } catch (error) {
-      throw error;
-    }
-  }
-}
+import { ClassError, ObjectBase } from '@tomei/general';
+import { ComponentConfig } from '@tomei/config';
+import { IUserPasswordHistoryAttr } from '../../interfaces/user-password-history.interface';
+import { UserPasswordHistoryRepository } from './user-password-history.repository';
+import { PasswordHashService } from '../../components/password-hash';
+
+export class UserPasswordHistory
+  extends ObjectBase
+  implements IUserPasswordHistoryAttr
+{
+  ObjectId: string;
+  ObjectName: string;
+  ObjectType = 'UserPasswordHistory';
+  TableName = 'sso_UserPasswordHistory';
+  UserId: number;
+  PasswordHash: string;
+  private _CreatedAt: Date;
+
+  private static _Repo = new UserPasswordHistoryRepository();
+
+  get HistoryId(): string {
+    return this.ObjectId;
+  }
+
+  set HistoryId(value: string) {
+    this.ObjectId = value;
+  }
+
+  get CreatedAt(): Date {
+    return this._CreatedAt;
+  }
+
+  private constructor(params?: IUserPasswordHistoryAttr) {
+    super();
+    if (params) {
+      this.ObjectId = params.HistoryId;
+      this.UserId = params.UserId;
+      this.PasswordHash = params.PasswordHash;
+      this._CreatedAt = params.CreatedAt;
+    }
+  }
+
+  public static async init(
+    historyId?: number,
+    dbTransaction?: any,
+  ): Promise<UserPasswordHistory> {
+    try {
+      if (historyId) {
+        const data = await UserPasswordHistory._Repo.findByPk(
+          historyId.toString(),
+          dbTransaction,
+        );
+        if (!data) {
+          throw new ClassError(
+            'UserPasswordHistory',
+            'UserPasswordHistoryErrMsg01',
+            'UserPasswordHistory not found',
+            'init',
+            400,
+          );
+        }
+
+        return new UserPasswordHistory(data.get({ plain: true }));
+      }
+      return new UserPasswordHistory();
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public static async validate(
+    dbTransaction: any,
+    UserId: number,
+    Password: string,
+    passwordHashService: PasswordHashService,
+  ): Promise<void> {
+    // This method used to check if password entered is valid by checking previous password history
+    try {
+      // Part 1-2: Retrieve password history policy by using component config, call ComponentConfig. by passing:
+      // - ComponentName: "@tomei/sso"
+      // - ConfigKey: "passwordHistory"
+      // If no password history set, use default value 3
+
+      const passwordHistoryPolicy =
+        ComponentConfig.getComponentConfigValue(
+          '@tomei/sso',
+          'passwordHistory',
+        ) || 3;
+
+      // Part 3-4: Retrieve records from the table by using  class._repo findAll() by passing:
+      // where: { UserId: params.UserId }
+      // order: [['CreatedAt', 'DESC']]
+      // limit: passwordHistory count above.
+      // If no record found, return null.
+
+      let passwordHistory = await UserPasswordHistory._Repo.findAll({
+        where: { UserId: UserId },
+        order: [['CreatedAt', 'DESC']],
+        limit: passwordHistoryPolicy,
+        transaction: dbTransaction,
+      });
+
+      if (passwordHistory?.length < 1) {
+        return null;
+      } else {
+        // Part 5: If record found, map each record to compare params.Password and record.PasswordHash using the params.passwordHashService. If match, stop the mapping, and return ClassError:
+        // ClassName: "UserPasswordHistory"
+        // MethodName: "validate"
+        // MessageCode: "UserPasswordHistory01"
+        // Message: You cannot reuse your last ${passwordHistory} passwords. Please choose a new and unique password.
+        for (let index = 0; index < passwordHistory.length; index++) {
+          const isPasswordSame = await passwordHashService.verify(
+            Password,
+            passwordHistory[index].PasswordHash,
+          );
+
+          if (isPasswordSame) {
+            throw new ClassError(
+              'UserPasswordHistory',
+              'UserPasswordHistory01',
+              `You cannot reuse your last ${passwordHistoryPolicy} passwords. Please choose a new and unique password.`,
+              'validate',
+              403,
+            );
+          }
+        }
+      }
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public static async create(
+    dbTransaction: any,
+    UserId: number,
+    PasswordHash: string,
+  ): Promise<void> {
+    // This method used to check if password entered is valid by checking previous password history
+    try {
+      // Part 1-2: Retrieve password history policy by using component config, call ComponentConfig. by passing:
+      // - ComponentName: "@tomei/sso"
+      // - ConfigKey: "passwordHistory"
+      // If no password history set, use default value 3
+
+      const passwordHistoryPolicy =
+        ComponentConfig.getComponentConfigValue(
+          '@tomei/sso',
+          'passwordHistory',
+        ) || 3;
+
+      // Part 3: Insert new password history by calling class _repo create() method.
+      const userPasswordHistory = new UserPasswordHistory();
+      let passwordHistory = await UserPasswordHistory._Repo.create(
+        {
+          HistoryId: userPasswordHistory.createId(),
+          UserId: UserId,
+          PasswordHash: PasswordHash,
+        },
+        {
+          transaction: dbTransaction,
+        },
+      );
+
+      // Part 3: When inserted successfully, retrieve all the password history for the user to check
+      // how many previous password records. If records more than the passwordHistory count from
+      // config. Remove the oldest record.
+      if (passwordHistory) {
+        let passwordHistoryList = await UserPasswordHistory._Repo.findAll({
+          where: { UserId: UserId },
+          order: [['CreatedAt', 'DESC']],
+          transaction: dbTransaction,
+        });
+
+        if (passwordHistoryList.length > passwordHistoryPolicy) {
+          let deleteList = passwordHistoryList.slice(passwordHistoryPolicy);
+          let historyIdList = deleteList.map((record) => record.HistoryId);
+          await UserPasswordHistory._Repo.destroyMultiple(
+            historyIdList,
+            dbTransaction,
+          );
+        }
+      }
+    } catch (error) {
+      throw error;
+    }
+  }
+}

package/src/components/user-privilege/index.ts

@@ -1,2 +1,2 @@
-export * from './user-privilege.repository';
-export * from './user-privilege';
+export * from './user-privilege.repository';
+export * from './user-privilege';