@tomei/rental 0.13.2 → 0.15.0

package/migrations/rental-aggreement-history.js

@@ -0,0 +1,41 @@
+'use strict';
+
+/** @type {import('sequelize-cli').Migration} */
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable('rental_AgreementHistory', {
+      BookingNo: {
+        type: Sequelize.INTEGER,
+        allowNull: false,
+        primaryKey: true,
+        autoIncrement: true,
+      },
+      MediaId: {
+        type: Sequelize.STRING(30),
+        allowNull: false,
+      },
+      ActivityCompleted: {
+        type: Sequelize.STRING(200),
+        allowNull: false,
+      },
+      AgreementNo: {
+        type: Sequelize.STRING(30),
+        allowNull: false,
+        references: {
+          model: 'rental_Agreement',
+          key: 'AgreementNo',
+        },
+        onUpdate: 'CASCADE',
+        onDelete: 'CASCADE',
+      },
+      CreatedAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+    },
+    });
+  },
+
+  async down(queryInterface, Sequelize) {
+    await queryInterface.dropTable('rental_AgreementHistory');
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomei/rental",
-  "version": "0.13.2",
+  "version": "0.15.0",
   "description": "Tomei Rental Package",
   "main": "dist/index.js",
   "scripts": {

package/src/components/agreement-history/agreement-history.repository.ts

@@ -0,0 +1,54 @@
+import { RepositoryBase, IRepositoryBase } from '@tomei/general';
+import { AgreementHistoryModel } from '../../models/agreement-history.entity';
+
+export class AgreementHistoryRepository
+  extends RepositoryBase<AgreementHistoryModel>
+  implements IRepositoryBase<AgreementHistoryModel>
+{
+  constructor() {
+    super(AgreementHistoryModel);
+  }
+
+  async findByPk(
+    id: string,
+    transaction?: any,
+  ): Promise<AgreementHistoryModel | null> {
+    try {
+      const result = await AgreementHistoryModel.findByPk(parseInt(id), {
+        transaction: transaction,
+      });
+
+      return result;
+    } catch (error) {
+      throw new Error(`An Error occured when fetching : ${error.message}`);
+    }
+  }
+
+  async delete(AgreementNo: string, dbTransaction?: any) {
+    try {
+      const options = {
+        where: {
+          AgreementNo,
+        },
+        transaction: dbTransaction,
+      };
+      await AgreementHistoryModel.destroy(options);
+    } catch (error) {
+      throw new Error(`An Error occured when delete : ${error.message}`);
+    }
+  }
+
+  async findAndCountAll(options?: any) {
+    try {
+      let Agreements: any;
+      if (options) {
+        Agreements = await AgreementHistoryModel.findAndCountAll(options);
+      } else {
+        Agreements = await AgreementHistoryModel.findAndCountAll();
+      }
+      return Agreements;
+    } catch (error) {
+      throw new Error(`An Error occured when retriving : ${error.message}`);
+    }
+  }
+}

package/src/components/agreement-history/agreement-history.ts

@@ -0,0 +1,57 @@
+import { ObjectBase } from '@tomei/general';
+import { AgreementHistoryRepository } from './agreement-history.repository';
+import { AggrementStatusEnum } from '../../enum/aggrement-status.enum';
+import { IAgreementHistoryAttr } from '../../interfaces/agreement-history-attr.interface';
+
+export class AgreementHistory
+  extends ObjectBase
+  implements IAgreementHistoryAttr
+{
+  ObjectId: string;
+  ObjectName: string;
+  ObjectType: string = 'AgreementHistory';
+  TableName = 'rental_AgreementHistory';
+  AgreementNo: string;
+  ActivityCompleted: string;
+  MediaId: string;
+  CreatedAt: Date;
+
+  private static _Repo = new AgreementHistoryRepository();
+
+  get HistoryId(): number {
+    return parseInt(this.ObjectId);
+  }
+
+  set HistoryId(value: number) {
+    this.ObjectId = value.toString();
+  }
+
+  protected constructor(agreementAttr?: IAgreementHistoryAttr) {
+    super();
+    if (agreementAttr) {
+      this.HistoryId = agreementAttr.HistoryId;
+      this.AgreementNo = agreementAttr.AgreementNo;
+      this.ActivityCompleted = agreementAttr.ActivityCompleted;
+      this.MediaId = agreementAttr.MediaId;
+      this.CreatedAt = agreementAttr.CreatedAt;
+    }
+  }
+
+  public static async init(
+    historyId: number,
+    dbTransaction?: any,
+  ): Promise<AgreementHistory> {
+    try {
+      if (historyId) {
+        const ah = await this._Repo.findByPk(
+          historyId.toString(),
+          dbTransaction,
+        );
+        return new AgreementHistory(ah?.get({ plain: true }));
+      }
+      return new AgreementHistory();
+    } catch (error) {
+      throw error;
+    }
+  }
+}

package/src/components/rental/rental.ts

@@ -21,6 +21,7 @@ import { AggrementStatusEnum } from '../../enum/aggrement-status.enum';
 import { HirerSignatureRepository } from '../hirer-signature/hirer-signature.repository';
 import { HirerSignatureStatusEnum } from '../../enum/hirer-signature-status.enum';
 import { HirerTypeEnum } from '../../enum/hirer-type.enum';
+import { AgreementHistoryRepository } from '../agreement-history/agreement-history.repository';
 
 export class Rental extends ObjectBase {
   ObjectId: string;
@@ -49,6 +50,7 @@ export class Rental extends ObjectBase {
   protected static _AgreementRepo = new AgreementRepository();
   protected static _JointHirerRepo = new JointHirerRepository();
   protected static _HirerSignatureRepo = new HirerSignatureRepository();
+  protected static _AgreementHistoryRepo = new AgreementHistoryRepository();
 
   get RentalId(): string {
     return this.ObjectId;
@@ -1066,6 +1068,47 @@ export class Rental extends ObjectBase {
       // dbTransaction
       // userId: loginUser.ObjectId
       await activity.create(loginUser.ObjectId, dbTransaction);
+
+      // Part 5: Add Record To Agreement History Table
+      // Make sure there is a private static readonly _AgreementHistoryRepo variable.
+      // Set newRecord to an object with below key-value:
+      // AgreementNo: this.AgreementNo
+      // MediaId: params.MediaId
+      // ActivityCompleted: "Agreement Generated"
+      // CreatedAt: Current Timestamp
+      // Use _AgreementHistoryRepo.create() method and pass newRecord and dbTransaction.
+      const agreementHistory = await Rental._AgreementHistoryRepo.create(
+        {
+          AgreementNo: this.AgreementNo,
+          MediaId,
+          ActivityCompleted: 'Agreement Generated',
+          CreatedAt: new Date(),
+        },
+        { transaction: dbTransaction },
+      );
+
+      // Part 6: Record Agreement History Activity
+      // Initialise EntityValueAfter variable and set to newRecord from previous part.
+      // Instantiate new activity from Activity class, call createId() method, then set:
+      // Action: ActionEnum.CREATE
+      // Description: "Generate agreement."
+      // EntityType: "RentalAgreementHistory"
+      // EntityId: HistoryId from previous part.
+      // EntityValueBefore: empty object.
+      // EntityValueAfter: EntityValueAfter
+      // Call new activity create method by passing:
+      // dbTransaction
+      // userId: loginUser.ObjectId
+      const entityValueAfter = agreementHistory.get({ plain: true });
+      const activityHistory = new Activity();
+      activityHistory.ActivityId = activityHistory.createId();
+      activityHistory.Action = ActionEnum.CREATE;
+      activityHistory.Description = 'Generate agreement.';
+      activityHistory.EntityType = 'RentalAgreementHistory';
+      activityHistory.EntityId = agreementHistory.HistoryId.toString();
+      activityHistory.EntityValueBefore = JSON.stringify({});
+      activityHistory.EntityValueAfter = JSON.stringify(entityValueAfter);
+      await activityHistory.create(loginUser.ObjectId, dbTransaction);
     } catch (error) {
       throw error;
     }

package/src/database.ts

@@ -5,6 +5,7 @@ import { BookingModel } from './models/booking.entity';
 import { JointHirerModel } from './models/joint-hirer.entity';
 import { AgreementModel } from './models/agreement.entity';
 import { HirerSignatureModel } from './models/hirer-signature.entity';
+import { AgreementHistoryModel } from './models/agreement-history.entity';
 
 let sequelize: Sequelize;
 
@@ -19,6 +20,7 @@ function init(sequelizeOptions: SequelizeOptions) {
     JointHirerModel,
     AgreementModel,
     HirerSignatureModel,
+    AgreementHistoryModel,
   ]);
 }
 

package/src/index.ts

@@ -10,6 +10,8 @@ import { Agreement } from './components/agreement/agreement';
 import { AgreementRepository } from './components/agreement/agreement.repository';
 import { HirerSignature } from './components/hirer-signature/hirer-signature';
 import { HirerSignatureRepository } from './components/hirer-signature/hirer-signature.repository';
+import { AgreementHistory } from './components/agreement-history/agreement-history';
+import { AgreementHistoryRepository } from './components/agreement-history/agreement-history.repository';
 import * as rentalDb from './database';
 export * from './interfaces';
 export * from './models';
@@ -29,4 +31,6 @@ export {
   AgreementRepository,
   HirerSignature,
   HirerSignatureRepository,
+  AgreementHistory,
+  AgreementHistoryRepository,
 };

package/src/interfaces/agreement-history-attr.interface.ts

@@ -0,0 +1,7 @@
+export interface IAgreementHistoryAttr {
+  HistoryId: number;
+  AgreementNo: string;
+  ActivityCompleted: string;
+  MediaId: string;
+  CreatedAt: Date;
+}

package/src/models/agreement-history.entity.ts

@@ -0,0 +1,51 @@
+import {
+  Column,
+  DataType,
+  Table,
+  Model,
+  ForeignKey,
+  BelongsTo,
+  CreatedAt,
+} from 'sequelize-typescript';
+import { AgreementModel } from './agreement.entity';
+
+@Table({
+  tableName: 'rental_Agreement',
+  createdAt: 'CreatedAt',
+  updatedAt: false,
+  timestamps: true,
+})
+export class AgreementHistoryModel extends Model {
+  @Column({
+    primaryKey: true,
+    allowNull: false,
+    autoIncrement: true,
+    type: DataType.INTEGER,
+  })
+  HistoryId: number;
+
+  @ForeignKey(() => AgreementModel)
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  AgreementNo: string;
+
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  MediaId: string;
+
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(200),
+  })
+  ActivityCompleted: string;
+
+  @CreatedAt
+  CreatedAt?: Date;
+
+  @BelongsTo(() => AgreementModel)
+  Agreement: AgreementModel;
+}

package/src/models/agreement.entity.ts

@@ -2,6 +2,7 @@ import { Column, DataType, Table, Model, HasMany } from 'sequelize-typescript';
 import { RentalModel } from './rental.entity';
 import { AggrementStatusEnum } from '../enum/aggrement-status.enum';
 import { HirerSignatureModel } from './hirer-signature.entity';
+import { AgreementHistoryModel } from './agreement-history.entity';
 
 @Table({
   tableName: 'rental_Agreement',
@@ -40,4 +41,7 @@ export class AgreementModel extends Model {
 
   @HasMany(() => HirerSignatureModel)
   HirerSignatures: HirerSignatureModel[];
+
+  @HasMany(() => AgreementHistoryModel)
+  History: AgreementHistoryModel[];
 }