@tomei/rental 0.17.1 → 0.17.3-dev.1

package/migrations/20250529092130-add-status-to-joint-hirer.js

@@ -0,0 +1,19 @@
+'use strict';
+
+/** @type {import('sequelize-cli').Migration} */
+'use strict';
+
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    await queryInterface.addColumn('rental_JointHirer', 'Status', {
+      type: Sequelize.STRING(20),
+      allowNull: false,
+      defaultValue: 'Active',
+    });
+  },
+
+  down: async (queryInterface, _) => {
+    await queryInterface.removeColumn('rental_JointHirer', 'Status');
+  }
+};
+

package/migrations/hirer-change-request-new-hirer-migration.js

@@ -0,0 +1,72 @@
+'use strict';
+
+/** @type {import('sequelize-cli').Migration} */
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    await queryInterface.createTable('hirerChangeRequest_NewHirer', {
+      NewHirerId: {
+        type: Sequelize.STRING(30),
+        primaryKey: true,
+        allowNull: false,
+      },
+      RequestId: {
+        type: Sequelize.STRING(30),
+        allowNull: false,
+        references: {
+          model: 'rental_HirerChangeRequest',
+          key: 'RequestId',
+        },
+        onUpdate: 'CASCADE',
+        onDelete: 'CASCADE',
+      },
+      FullName: {
+        type: Sequelize.STRING(200),
+        allowNull: false,
+      },
+      Email: {
+        type: Sequelize.STRING(100),
+        allowNull: true,
+      },
+      IdType: {
+        type: Sequelize.STRING(20),
+        allowNull: false,
+      },
+      IdNo: {
+        type: Sequelize.STRING(50),
+        allowNull: false,
+      },
+      ContactNo: {
+        type: Sequelize.STRING(20),
+        allowNull: false,
+      },
+      Relationship: {
+        type: Sequelize.STRING(20),
+        allowNull: false,
+      },
+      Address: {
+        type: Sequelize.STRING(1000),
+        allowNull: false,
+      },
+      City: {
+        type: Sequelize.STRING(100),
+        allowNull: false,
+      },
+      State: {
+        type: Sequelize.STRING(100),
+        allowNull: false,
+      },
+      Postcode: {
+        type: Sequelize.STRING(20),
+        allowNull: false,
+      },
+      Country: {
+        type: Sequelize.STRING(100),
+        allowNull: false,
+      },
+    });
+  },
+
+  down: async (queryInterface, Sequelize) => {
+    await queryInterface.dropTable('hirerChangeRequest_NewHirer');
+  },
+};

package/migrations/hirer-change-request-remove-hirer-migration.js

@@ -0,0 +1,39 @@
+'use strict';
+
+/** @type {import('sequelize-cli').Migration} */
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    await queryInterface.createTable('hirerChangeRequest_RemoveHirer', {
+      RemoveHirerId: {
+        type: Sequelize.STRING(30),
+        primaryKey: true,
+        allowNull: false,
+      },
+      RequestId: {
+        type: Sequelize.STRING(30),
+        allowNull: false,
+        references: {
+          model: 'rental_HirerChangeRequest',
+          key: 'RequestId',
+        },
+        onUpdate: 'CASCADE',
+        onDelete: 'CASCADE',
+      },
+      TargetHirerId: {
+        type: Sequelize.STRING(30),
+        allowNull: false,
+        references: {
+          model: 'rental_JointHirer',
+          key: 'HirerId',
+        },
+        onUpdate: 'CASCADE',
+        onDelete: 'CASCADE',
+      },
+    });
+  },
+
+  down: async (queryInterface, Sequelize) => {
+    await queryInterface.dropTable('hirerChangeRequest_RemoveHirer');
+    // ENUM cleanup not needed in MariaDB
+  },
+};

package/migrations/hirer-change-request-signature-migration.js

@@ -0,0 +1,65 @@
+'use strict';
+
+/** @type {import('sequelize-cli').Migration} */
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    await queryInterface.createTable('hirerChangeRequest_Signature', {
+      SignatureId: {
+        type: Sequelize.STRING(30),
+        primaryKey: true,
+        allowNull: false,
+      },
+      RequestId: {
+        type: Sequelize.STRING(30),
+        allowNull: false,
+        references: {
+          model: 'rental_HirerChangeRequest',
+          key: 'RequestId',
+        },
+        onUpdate: 'CASCADE',
+        onDelete: 'CASCADE',
+      },
+      CustomerId: {
+        type: Sequelize.STRING(30),
+        allowNull: true,
+      },
+      JointHirerId: {
+        type: Sequelize.STRING(30),
+        allowNull: true,
+      },
+      HirerType: {
+        type: Sequelize.STRING(10),
+        allowNull: false,
+      },
+      SignedAt: {
+        type: Sequelize.DATE,
+        allowNull: true,
+      },
+      Method: {
+        type: Sequelize.STRING(20),
+        allowNull: false,
+      },
+      Remarks: {
+        type: Sequelize.STRING(300),
+        allowNull: true,
+      },
+      CreatedAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+      UpdatedAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+      UpdatedById: {
+        type: Sequelize.STRING(30),
+        allowNull: false,
+      },
+    });
+  },
+
+  down: async (queryInterface, Sequelize) => {
+    await queryInterface.dropTable('hirerChangeRequest_Signature');
+    // ENUM cleanup not needed in MariaDB
+  },
+};

package/migrations/rental-hirer-change-request-migrations.js

@@ -0,0 +1,64 @@
+'use strict';
+
+/** @type {import('sequelize-cli').Migration} */
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    await queryInterface.createTable('rental_HirerChangeRequest', {
+      RequestId: {
+        type: Sequelize.STRING(30),
+        primaryKey: true,
+        allowNull: false,
+      },
+      RentalId: {
+        type: Sequelize.STRING(30),
+        allowNull: false,
+        references: {
+          model: 'rental_Rental',
+          key: 'RentalId',
+        },
+        onUpdate: 'CASCADE',
+        onDelete: 'CASCADE',
+      },
+      Type: {
+        type: Sequelize.STRING(10),
+        allowNull: false,
+      },
+      Status: {
+        type: Sequelize.STRING(20),
+        allowNull: false,
+      },
+      RequestedAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+      RequestedById: {
+        type: Sequelize.STRING(30),
+        allowNull: false,
+      },
+      RequestingHirerId: {
+        type: Sequelize.STRING(30),
+        allowNull: false,
+      },
+      RequestingHirerType: {
+        type: Sequelize.ENUM('Main', 'Joint'),
+        allowNull: false,
+      },
+      CancelRemarks: {
+        type: Sequelize.STRING(300),
+        allowNull: true,
+      },
+      UpdatedAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+      UpdatedById: {
+        type: Sequelize.STRING(30),
+        allowNull: false,
+      },
+    });
+  },
+
+  down: async (queryInterface, Sequelize) => {
+    await queryInterface.dropTable('rental_HirerChangeRequest');
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomei/rental",
-  "version": "0.17.1",
+  "version": "0.17.3-dev.1",
   "description": "Tomei Rental Package",
   "main": "dist/index.js",
   "scripts": {
@@ -57,10 +57,10 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@tomei/activity-history": "^0.2.23",
+    "@tomei/activity-history": "^0.4.1",
     "@tomei/config": "^0.3.21",
     "@tomei/general": "^0.21.3",
-    "@tomei/sso": "^0.51.6",
+    "@tomei/sso": "^0.60.4",
     "luxon": "^3.5.0",
     "reflect-metadata": "^0.2.2",
     "sequelize": "^6.37.5",

package/src/components/hirer-change-request-new-hirer/hirer-change-request-new-hirer.repository.ts

@@ -0,0 +1,64 @@
+import { RepositoryBase, IRepositoryBase } from '@tomei/general';
+import { HirerChangeRequestNewHirerModel } from '../../models/hirer-change-request-new-hirer.entity';
+
+export class HirerChangeRequestNewHirerRepository
+  extends RepositoryBase<HirerChangeRequestNewHirerModel>
+  implements IRepositoryBase<HirerChangeRequestNewHirerModel>
+{
+  constructor() {
+    super(HirerChangeRequestNewHirerModel);
+  }
+
+  async findByPk(
+    id: string,
+    transaction?: any,
+  ): Promise<HirerChangeRequestNewHirerModel | null> {
+    try {
+      const result = await HirerChangeRequestNewHirerModel.findByPk(id, {
+        transaction: transaction,
+      });
+
+      return result;
+    } catch (error) {
+      throw new Error(`An Error occured when fetching : ${error.message}`);
+    }
+  }
+
+  async delete(newHirerId: string, dbTransaction?: any) {
+    try {
+      const options = {
+        where: {
+          NewHirerId: newHirerId,
+        },
+        transaction: dbTransaction,
+      };
+      await HirerChangeRequestNewHirerModel.destroy(options);
+    } catch (error) {
+      throw new Error(`An Error occured when delete : ${error.message}`);
+    }
+  }
+
+  async findAndCountAll(options?: any) {
+    try {
+      let hcrNewHirers: any;
+      if (options) {
+        hcrNewHirers =
+          await HirerChangeRequestNewHirerModel.findAndCountAll(options);
+      } else {
+        hcrNewHirers = await HirerChangeRequestNewHirerModel.findAndCountAll();
+      }
+      return hcrNewHirers;
+    } catch (error) {
+      throw new Error(`An Error occured when retriving : ${error.message}`);
+    }
+  }
+
+  async findAll(options: any): Promise<HirerChangeRequestNewHirerModel[]> {
+    try {
+      const result = await HirerChangeRequestNewHirerModel.findAll(options);
+      return result;
+    } catch (error) {
+      throw new Error(`An Error occured when fetching : ${error.message}`);
+    }
+  }
+}

package/src/components/hirer-change-request-new-hirer/hirer-change-request-new-hirer.ts

@@ -0,0 +1,153 @@
+import { ClassError, ObjectBase } from '@tomei/general';
+import { IHirerChangeRequestNewHirerAttr } from '../../interfaces/hirer-change-request-new-hirer-attr.interface';
+import { HirerChangeRequestNewHirerRepository } from './hirer-change-request-new-hirer.repository';
+import { LoginUser } from '@tomei/sso';
+import { ActionEnum, Activity } from '@tomei/activity-history';
+
+export class HirerChangeRequestNewHirer
+  extends ObjectBase
+  implements IHirerChangeRequestNewHirerAttr
+{
+  ObjectId: string;
+  ObjectName: string;
+  ObjectType: string = 'HirerChangeRequestNewHirer';
+  TableName: string = 'hirerChangeRequest_NewHirer';
+
+  RequestId: string;
+  FullName: string;
+  Email: string;
+  IdType: string;
+  IdNo: string;
+  ContactNo: string;
+  Relationship: string;
+  Address: string;
+  City: string;
+  State: string;
+  Postcode: string;
+  Country: string;
+
+  get NewHirerId(): string {
+    return this.ObjectId;
+  }
+
+  set NewHirerId(value: string) {
+    this.ObjectId = value;
+  }
+
+  protected static _Repository = new HirerChangeRequestNewHirerRepository();
+
+  protected constructor(attr?: IHirerChangeRequestNewHirerAttr) {
+    super();
+    if (attr) {
+      this.NewHirerId = attr.NewHirerId;
+      this.RequestId = attr.RequestId;
+      this.FullName = attr.FullName;
+      this.Email = attr.Email;
+      this.IdType = attr.IdType;
+      this.IdNo = attr.IdNo;
+      this.ContactNo = attr.ContactNo;
+      this.Relationship = attr.Relationship;
+      this.Address = attr.Address;
+      this.City = attr.City;
+      this.State = attr.State;
+      this.Postcode = attr.Postcode;
+      this.Country = attr.Country;
+    }
+  }
+
+  public static async init(newHirerId?: string, dbTransaction?: any) {
+    try {
+      if (newHirerId) {
+        const hirerChangeReqNewHirer =
+          await HirerChangeRequestNewHirer._Repository.findByPk(
+            newHirerId,
+            dbTransaction,
+          );
+        if (hirerChangeReqNewHirer) {
+          return new HirerChangeRequestNewHirer(
+            hirerChangeReqNewHirer.get({ plain: true }),
+          );
+        } else {
+          throw new ClassError(
+            'HirerChangeRequestNewHirer',
+            'HirerChangeRequestNewHirerErrMsg00',
+            'HirerChangeRequestNewHirer not found',
+          );
+        }
+      }
+      return new HirerChangeRequestNewHirer();
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public static async findAll(
+    search: {
+      RequestId?: string;
+    },
+    dbTransaction?: any,
+  ): Promise<HirerChangeRequestNewHirer[]> {
+    try {
+      const results = await HirerChangeRequestNewHirer._Repository.findAll({
+        where: {
+          ...search,
+        },
+        transaction: dbTransaction,
+      });
+      return results.map(
+        (result) => new HirerChangeRequestNewHirer(result.get({ plain: true })),
+      );
+    } catch (error) {
+      console.error('Error finding all HirerChangeRequestNewHirer:', error);
+      throw error;
+    }
+  }
+
+  toJSON(): IHirerChangeRequestNewHirerAttr {
+    return {
+      NewHirerId: this.NewHirerId,
+      RequestId: this.RequestId,
+      FullName: this.FullName,
+      Email: this.Email,
+      IdType: this.IdType,
+      IdNo: this.IdNo,
+      ContactNo: this.ContactNo,
+      Relationship: this.Relationship,
+      Address: this.Address,
+      City: this.City,
+      State: this.State,
+      Postcode: this.Postcode,
+      Country: this.Country,
+    };
+  }
+
+  public async create(loginUser: LoginUser, dbTransaction?: any) {
+    //This method will create a new Hirer Change Request New Hirer.
+    try {
+      //Insert record into the database
+      this.ObjectId = this.createId();
+      const entityValueAfter = this.toJSON();
+      const newHirer = await HirerChangeRequestNewHirer._Repository.create(
+        entityValueAfter,
+        {
+          transaction: dbTransaction,
+        },
+      );
+
+      //Create activity log
+      const activity = new Activity();
+      activity.ObjectId = this._createId();
+      activity.Action = ActionEnum.CREATE;
+      activity.Description = `Created new Hirer Change Request New Hirer`;
+      activity.EntityId = newHirer.NewHirerId;
+      activity.EntityType = this.ObjectType;
+      activity.EntityValueBefore = JSON.stringify({});
+      activity.EntityValueAfter = JSON.stringify(newHirer);
+
+      await activity.create(loginUser.ObjectId, dbTransaction);
+    } catch (error) {
+      console.error('Error creating HirerChangeRequestNewHirer:', error);
+      throw error;
+    }
+  }
+}

package/src/components/hirer-change-request-remove-hirer/hirer-change-request-remove-hirer.repository.ts

@@ -0,0 +1,65 @@
+import { RepositoryBase, IRepositoryBase } from '@tomei/general';
+import { HirerChangeRequestRemoveHirerModel } from '../../models/hirer-change-request-remove-hirer.entity';
+
+export class HirerChangeRequestRemoveHirerRepository
+  extends RepositoryBase<HirerChangeRequestRemoveHirerModel>
+  implements IRepositoryBase<HirerChangeRequestRemoveHirerModel>
+{
+  constructor() {
+    super(HirerChangeRequestRemoveHirerModel);
+  }
+
+  async findByPk(
+    id: string,
+    transaction?: any,
+  ): Promise<HirerChangeRequestRemoveHirerModel | null> {
+    try {
+      const result = await HirerChangeRequestRemoveHirerModel.findByPk(id, {
+        transaction: transaction,
+      });
+
+      return result;
+    } catch (error) {
+      throw new Error(`An Error occured when fetching : ${error.message}`);
+    }
+  }
+
+  async delete(removeHirerId: string, dbTransaction?: any) {
+    try {
+      const options = {
+        where: {
+          RemoveHirerId: removeHirerId,
+        },
+        transaction: dbTransaction,
+      };
+      await HirerChangeRequestRemoveHirerModel.destroy(options);
+    } catch (error) {
+      throw new Error(`An Error occured when delete : ${error.message}`);
+    }
+  }
+
+  async findAndCountAll(options?: any) {
+    try {
+      let hcrRemoveHirers: any;
+      if (options) {
+        hcrRemoveHirers =
+          await HirerChangeRequestRemoveHirerModel.findAndCountAll(options);
+      } else {
+        hcrRemoveHirers =
+          await HirerChangeRequestRemoveHirerModel.findAndCountAll();
+      }
+      return hcrRemoveHirers;
+    } catch (error) {
+      throw new Error(`An Error occured when retriving : ${error.message}`);
+    }
+  }
+
+  async findAll(options: any): Promise<HirerChangeRequestRemoveHirerModel[]> {
+    try {
+      const result = await HirerChangeRequestRemoveHirerModel.findAll(options);
+      return result;
+    } catch (error) {
+      throw new Error(`An Error occured when fetching : ${error.message}`);
+    }
+  }
+}

package/src/components/hirer-change-request-remove-hirer/hirer-change-request-remove-hirer.ts

@@ -0,0 +1,134 @@
+import { ClassError, ObjectBase } from '@tomei/general';
+import { LoginUser } from '@tomei/sso';
+import { ActionEnum, Activity } from '@tomei/activity-history';
+import { IHirerChangeRequestRemoveHirerAttr } from '../../interfaces/hirer-change-request-remove-hirer-attr.interface';
+import { HirerChangeRequestRemoveHirerRepository } from './hirer-change-request-remove-hirer.repository';
+import { JointHirer } from 'components/joint-hirer/joint-hirer';
+
+export class HirerChangeRequestRemoveHirer
+  extends ObjectBase
+  implements IHirerChangeRequestRemoveHirerAttr
+{
+  ObjectId: string;
+  ObjectName: string;
+  ObjectType: string = 'HirerChangeRequestRemoveHirer';
+  TableName: string = 'hirerChangeRequest_RemoveHirer';
+  RequestId: string;
+  TargetHirerId: string;
+
+  get RemoveHirerId(): string {
+    return this.ObjectId;
+  }
+
+  set RemoveHirerId(value: string) {
+    this.ObjectId = value;
+  }
+
+  protected static _Repository = new HirerChangeRequestRemoveHirerRepository();
+
+  protected constructor(attr?: IHirerChangeRequestRemoveHirerAttr) {
+    super();
+    if (attr) {
+      this.RemoveHirerId = attr.RemoveHirerId;
+      this.RequestId = attr.RequestId;
+      this.TargetHirerId = attr.TargetHirerId;
+    }
+  }
+
+  public static async init(removeHirerId?: string, dbTransaction?: any) {
+    try {
+      if (removeHirerId) {
+        const hirerChangeReqRemoveHirer =
+          await HirerChangeRequestRemoveHirer._Repository.findByPk(
+            removeHirerId,
+            dbTransaction,
+          );
+        if (hirerChangeReqRemoveHirer) {
+          return new HirerChangeRequestRemoveHirer(
+            hirerChangeReqRemoveHirer.get({ plain: true }),
+          );
+        } else {
+          throw new ClassError(
+            'HirerChangeRequestRemoveHirer',
+            'HirerChangeRequestRemoveHirerErrMsg00',
+            'HirerChangeRequestRemoveHirer not found',
+          );
+        }
+      }
+      return new HirerChangeRequestRemoveHirer();
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public static async findAll(
+    search: {
+      RequestId?: string;
+    },
+    dbTransaction?: any,
+  ): Promise<HirerChangeRequestRemoveHirer[]> {
+    try {
+      const results = await HirerChangeRequestRemoveHirer._Repository.findAll({
+        where: {
+          ...search,
+        },
+        transaction: dbTransaction,
+      });
+      return results.map(
+        (result) =>
+          new HirerChangeRequestRemoveHirer(result.get({ plain: true })),
+      );
+    } catch (error) {
+      console.error('Error finding all HirerChangeRequestRemoveHirer:', error);
+      throw error;
+    }
+  }
+
+  toJSON(): IHirerChangeRequestRemoveHirerAttr {
+    return {
+      RemoveHirerId: this.RemoveHirerId,
+      RequestId: this.RequestId,
+      TargetHirerId: this.TargetHirerId,
+    };
+  }
+
+  public async create(loginUser: LoginUser, dbTransaction?: any) {
+    //This method will create a new Hirer Change Request Remove Hirer.
+    try {
+      //Make sure targetHirerId and requestId is not empty
+      if (!this.TargetHirerId && !this.RequestId) {
+        throw new ClassError(
+          'HirerChangeRequestRemoveHirer',
+          'HirerChangeRequestRemoveHirerErrMsg01',
+          'TargetHirerId and RequestId are required',
+        );
+      }
+
+      //Insert record into the database
+      this.ObjectId = this.createId();
+      const entityValueAfter = this.toJSON();
+      const removeHirer =
+        await HirerChangeRequestRemoveHirer._Repository.create(
+          entityValueAfter,
+          {
+            transaction: dbTransaction,
+          },
+        );
+
+      //Create activity log
+      const activity = new Activity();
+      activity.ObjectId = this._createId();
+      activity.Action = ActionEnum.CREATE;
+      activity.Description = `Created new Hirer Change Request Remove Hirer`;
+      activity.EntityId = removeHirer.RemoveHirerId;
+      activity.EntityType = this.ObjectType;
+      activity.EntityValueBefore = JSON.stringify({});
+      activity.EntityValueAfter = JSON.stringify(removeHirer);
+
+      await activity.create(loginUser.ObjectId, dbTransaction);
+    } catch (error) {
+      console.error('Error creating HirerChangeRequestRemoveHirer:', error);
+      throw error;
+    }
+  }
+}