@tomei/sso/src/components/group-object-privilege/group-object-privilege.ts

Tomei SSO Package

import { ClassError, ObjectBase } from '@tomei/general';
import { GroupObjectPrivilegeRepository } from './group-object-privilege.repository';
import { IGroupObjectPrivilegeAttr } from '../../interfaces/group-object-privilege.interface';
import { ObjectStatus } from '../../enum/object-status.enum';
import { LoginUser } from '../login-user/login-user';
import { ApplicationConfig } from '@tomei/config';
import { ActionEnum, Activity } from '@tomei/activity-history';

export class GroupObjectPrivilege extends ObjectBase {
  TableName = 'sso_GroupObjectPrivilege';
  ObjectName: string;
  GroupObjectPrivilegeId: number;
  GroupCode: string;
  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 GroupObjectPrivilegeRepository();

  constructor(GroupObjectPrivilegeAttr?: IGroupObjectPrivilegeAttr) {
    super();
    if (GroupObjectPrivilegeAttr) {
      this.GroupObjectPrivilegeId =
        GroupObjectPrivilegeAttr.GroupObjectPrivilegeId;
      this.GroupCode = GroupObjectPrivilegeAttr.GroupCode;
      this.SystemPrivilegeId = GroupObjectPrivilegeAttr.SystemPrivilegeId;
      this.ObjectId = GroupObjectPrivilegeAttr.ObjectId;
      this.ObjectType = GroupObjectPrivilegeAttr.ObjectType;
      this.Status = GroupObjectPrivilegeAttr.Status;
      this._CreatedAt = GroupObjectPrivilegeAttr.CreatedAt;
      this._UpdatedAt = GroupObjectPrivilegeAttr.UpdatedAt;
      this._CreatedById = GroupObjectPrivilegeAttr.CreatedById;
      this._UpdatedById = GroupObjectPrivilegeAttr.UpdatedById;
    }
  }

  public static async init(
    dbTransaction?: any,
    GroupObjectPrivilegeId?: number,
  ) {
    try {
      if (GroupObjectPrivilegeId) {
        const GroupObjectPrivilegeAttr = await this._Repository.findOne({
          where: { GroupObjectPrivilegeId },
          transaction: dbTransaction,
        });
        if (GroupObjectPrivilegeAttr) {
          return new GroupObjectPrivilege(
            GroupObjectPrivilegeAttr.get({ plain: true }),
          );
        } else {
          throw new ClassError(
            'GroupObjectPrivilege',
            'GroupObjectPrivilegeErrMsg00',
            'GroupObjectPrivilege not found',
          );
        }
      }
      return new GroupObjectPrivilege();
    } catch (error) {
      throw error;
    }
  }

  public static async create(
    loginUser: LoginUser,
    dbTransaction: any,
    groupObjectPrivilege: GroupObjectPrivilege,
  ) {
    try {
      // Part 1: Privilege Checking
      const systemCode =
        ApplicationConfig.getComponentConfigValue('system-code');
      const isPrivileged = await loginUser.checkPrivileges(
        systemCode,
        'GROUP_OBJECT_PRIVILEGE_CREATE',
      );

      if (!isPrivileged) {
        throw new ClassError(
          'GroupObjectPrivilege',
          'GroupErrMsg01',
          'You do not have the privilege to create Group Object Privilege',
        );
      }

      // Part 2: Validation
      // Make sure below variables exists:
      // Params.groupObjectPrivilege.GroupCode
      if (!groupObjectPrivilege.GroupCode) {
        throw new ClassError(
          'GroupObjectPrivilege',
          'GroupObjectPrivilegeErrMsg01',
          'GroupCode is missing.',
        );
      }
      // Params.groupObjectPrivilege.SystemPrivilegeId
      if (!groupObjectPrivilege.SystemPrivilegeId) {
        throw new ClassError(
          'GroupObjectPrivilege',
          'GroupObjectPrivilegeErrMsg02',
          'SystemPrivilegeId is missing.',
        );
      }
      // Params.groupObjectPrivilege.ObjectId
      if (!groupObjectPrivilege.ObjectId) {
        throw new ClassError(
          'GroupObjectPrivilege',
          'GroupObjectPrivilegeErrMsg03',
          'ObjectId is missing.',
        );
      }
      // Params.groupObjectPrivilege.ObjectType
      if (!groupObjectPrivilege.ObjectType) {
        throw new ClassError(
          'GroupObjectPrivilege',
          'GroupObjectPrivilegeErrMsg04',
          'ObjectType is missing.',
        );
      }

      // Call GroupObjectPrivilege._Repo findOne
      const existingGroupObjectPrivilege =
        await GroupObjectPrivilege._Repository.findOne({
          where: {
            GroupCode: groupObjectPrivilege.GroupCode,
            SystemPrivilegeId: groupObjectPrivilege.SystemPrivilegeId,
            ObjectId: groupObjectPrivilege.ObjectId,
            ObjectType: groupObjectPrivilege.ObjectType,
          },
          transaction: dbTransaction,
        });

      // If GroupObjectPrivilege found, throw new ClassError
      if (existingGroupObjectPrivilege) {
        throw new ClassError(
          'GroupObjectPrivilege',
          'GroupObjectPrivilegeErrMsg05',
          'Duplicate GroupObjectPrivilege found.',
        );
      }

      // Part 3: Create GroupObjectPrivilege
      // Initialise new Group instance and populate the attributes
      const objectAttr = {
        GroupCode: groupObjectPrivilege.GroupCode,
        SystemPrivilegeId: groupObjectPrivilege.SystemPrivilegeId,
        ObjectId: groupObjectPrivilege.ObjectId,
        ObjectType: groupObjectPrivilege.ObjectType,
        Status: ObjectStatus.ACTIVE,
        CreatedById: loginUser.UserId,
        CreatedAt: new Date(),
        UpdatedById: loginUser.UserId,
        UpdatedAt: new Date(),
      };
      const newGroupObjectPrivilege = new GroupObjectPrivilege(objectAttr);

      // Call GroupObjectPrivilege._Repo create method
      const createdObject = await GroupObjectPrivilege._Repository.create(
        newGroupObjectPrivilege,
        {
          transaction: dbTransaction,
        },
      );
      newGroupObjectPrivilege.GroupObjectPrivilegeId =
        createdObject.GroupObjectPrivilegeId;

      // Part 4: Record Create Group Activity
      // Initialise EntityValueBefore variable and set to empty object.
      const EntityValueBefore = {};
      // Initialise EntityValueAfter variable and set to new Group instance in Part 3.
      const EntityValueAfter = objectAttr;
      // Instantiate new activity from Activity class
      const activity = new Activity();
      activity.createId();
      activity.Action = ActionEnum.CREATE;
      activity.Description = `Create GroupObjectPrivilege for (${newGroupObjectPrivilege.GroupCode})`;
      activity.EntityType = 'GroupObjectPrivilege';
      activity.EntityId =
        newGroupObjectPrivilege.GroupObjectPrivilegeId.toString();
      activity.EntityValueBefore = JSON.stringify(EntityValueBefore);
      activity.EntityValueAfter = JSON.stringify(EntityValueAfter);
      // Call new activity create method.Make sure to pass the dbTransaction and loginUser.userId.
      await activity.create(dbTransaction, loginUser.UserId);

      // Return new Group instance
      return newGroupObjectPrivilege;
    } catch (error) {
      throw error;
    }
  }

  public async delete(loginUser: LoginUser, dbTransaction: any) {
    try {
      //Part 1: Privilege Checking
      const systemCode =
        ApplicationConfig.getComponentConfigValue('system-code');
      const isPrivileged = await loginUser.checkPrivileges(
        systemCode,
        'GROUP_OBJECT_PRIVILEGE_DELETE',
      );

      if (!isPrivileged) {
        throw new ClassError(
          'GroupObjectPrivilege',
          'GroupErrMsg01',
          'You do not have the privilege to delete Group Object Privilege',
        );
      }

      // Part 2: Delete GroupObjectPrivilege
      // Call GroupObjectPrivilege._Repo delete method by passing:
      // dbTransaction
      // GroupObjectPrivilege: this.GroupObjectPrivilegeId

      await GroupObjectPrivilege._Repository.delete(
        this.GroupObjectPrivilegeId,
        {
          transaction: dbTransaction,
        },
      );

      // Part 4: Record Create Group Activity
      // Initialise EntityValueBefore variable and set GroupObjectPrivelege column properties
      const EntityValueBefore = {
        GroupCode: this.GroupCode,
        SystemPrivilegeId: this.SystemPrivilegeId,
        ObjectId: this.ObjectId,
        ObjectType: this.ObjectType,
        Status: this.Status,
        CreatedById: this.CreatedById,
        UpdatedById: this.UpdatedById,
      };

      // Initialise EntityValueAfter variable and set empty object
      const EntityValueAfter = {};

      // Instantiate new activity from Activity class
      const activity = new Activity();
      activity.createId();
      activity.Action = ActionEnum.DELETE;
      activity.Description = `Delete GroupObjectPrivilege ${this.GroupObjectPrivilegeId}`;
      activity.EntityType = 'GroupObjectPrivilege';
      activity.EntityId = this.GroupObjectPrivilegeId.toString();
      activity.EntityValueBefore = JSON.stringify(EntityValueBefore);
      activity.EntityValueAfter = JSON.stringify(EntityValueAfter);

      // Call new activity create method.Make sure to pass the dbTransaction and LoginUser.userId.
      await activity.create(dbTransaction, loginUser.UserId);

      // Return this
      return this;
    } catch (error) {
      throw error;
    }
  }
}