@tomei/rental 0.16.4 → 0.16.6

package/migrations/{hirer-signature-table-migration.js → agreement-signature-table-migration.js}

@@ -3,8 +3,8 @@
 /** @type {import('sequelize-cli').Migration} */
 module.exports = {
   async up(queryInterface, Sequelize) {
-    await queryInterface.createTable('rental_HirerSignature', {
-      HirerSignatureId: {
+    await queryInterface.createTable('rental_AgreementSignature', {
+      SignatureId: {
         type: Sequelize.STRING(30),
         allowNull: false,
         primaryKey: true,
@@ -19,15 +19,15 @@ module.exports = {
         onUpdate: 'CASCADE',
         onDelete: 'CASCADE',
       },
-      HirerType: {
-        type: Sequelize.STRING(10),
+      Party: {
+        type: Sequelize.STRING(30),
         allowNull: false,
       },
-      CustomerId: {
+      PartyId: {
         type: Sequelize.STRING(30),
         allowNull: false,
       },
-      CustomerType: {
+      PartyType: {
         type: Sequelize.STRING(30),
         allowNull: false,
       },
@@ -37,7 +37,7 @@ module.exports = {
       },
       SignedAt: {
         type: Sequelize.DATE,
-        allowNull: false,
+        allowNull: true,
       },
       CreatedById: {
         type: Sequelize.STRING(30),

package/package.json

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

package/src/components/agreement/agreement.ts

@@ -4,10 +4,10 @@ import { IAgreementAttr } from '../../interfaces/agreement-attr.interface';
 import { AgreementRepository } from './agreement.repository';
 import { ApplicationConfig } from '@tomei/config';
 import { LoginUser } from '@tomei/sso';
-import { HirerSignatureRepository } from '../hirer-signature/hirer-signature.repository';
+import { AgreementSignatureRepository } from '../agreement-signature/agreement-signature.repository';
 import * as rentalDb from '../../database';
 import { QueryTypes, where } from 'sequelize';
-import { IResponseHirerSignature } from '../../interfaces/response-hirer-signature-attr.interface';
+import { IResponseAgreementSignature } from '../../interfaces/response-hirer-signature-attr.interface';
 import { AgreementHistoryRepository } from '../agreement-history/agreement-history.repository';
 import { IAgreementHistoryAttr } from 'interfaces/agreement-history-attr.interface';
 import { ActionEnum, Activity } from '@tomei/activity-history';
@@ -22,7 +22,7 @@ export class Agreement extends ObjectBase {
   MediaId: string;
 
   private static _Repo = new AgreementRepository();
-  protected static _HirerSignatureRepo = new HirerSignatureRepository();
+  protected static _AgreementSignatureRepo = new AgreementSignatureRepository();
   protected static _AgreementHistoryRepo = new AgreementHistoryRepository();
 
   get AgreementNo(): string {
@@ -98,14 +98,14 @@ export class Agreement extends ObjectBase {
             SELECT 
                 hs.*
             FROM 
-                rental_HirerSignature hs          
+                rental_AgreementSignature hs          
             WHERE 
                 hs.AgreementNo = '${agreementNo}'
       `;
 
       const db = rentalDb.getConnection();
 
-      const signatures: IResponseHirerSignature[] = await db.query(query, {
+      const signatures: IResponseAgreementSignature[] = await db.query(query, {
         type: QueryTypes.SELECT,
         transaction: dbTransaction,
       });

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

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

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

@@ -0,0 +1,143 @@
+import { ClassError, ObjectBase } from '@tomei/general';
+import { AgreementSignatureRepository } from './agreement-signature.repository';
+import { IAgreementSignatureAttr } from '../../interfaces/agreemeent-signature-attr.interface';
+import { ApplicationConfig } from '@tomei/config';
+import { LoginUser } from '@tomei/sso';
+import { ActionEnum, Activity } from '@tomei/activity-history';
+import { AgreementSignatureStatusEnum } from '../../enum/agreement-signature-status.enum';
+
+export class AgreementSignature
+  extends ObjectBase
+  implements IAgreementSignatureAttr
+{
+  ObjectId: string;
+  ObjectName: string;
+  ObjectType: string = 'AgreementSignature';
+  TableName: string = 'rental_AgreementSignature';
+  AgreementNo: string;
+  Party: string;
+  PartyId: string;
+  PartyType: string;
+  SignatureStatus: AgreementSignatureStatusEnum;
+  SignedAt: Date;
+  CreatedById: string;
+  CreatedAt: Date;
+  UpdatedById: string;
+  UpdatedAt: Date;
+
+  get SignatureId(): string {
+    return this.ObjectId;
+  }
+
+  set SignatureId(value: string) {
+    this.ObjectId = value;
+  }
+
+  protected static _Repository = new AgreementSignatureRepository();
+
+  protected constructor(AgreementSignatureAttr?: IAgreementSignatureAttr) {
+    super();
+    if (AgreementSignatureAttr) {
+      this.SignatureId = AgreementSignatureAttr.SignatureId;
+      this.AgreementNo = AgreementSignatureAttr.AgreementNo;
+      this.Party = AgreementSignatureAttr.Party;
+      this.PartyId = AgreementSignatureAttr.PartyId;
+      this.PartyType = AgreementSignatureAttr.PartyType;
+      this.SignatureStatus = AgreementSignatureAttr.SignatureStatus;
+      this.SignedAt = AgreementSignatureAttr.SignedAt;
+      this.CreatedById = AgreementSignatureAttr.CreatedById;
+      this.CreatedAt = AgreementSignatureAttr.CreatedAt;
+      this.UpdatedById = AgreementSignatureAttr.UpdatedById;
+      this.UpdatedAt = AgreementSignatureAttr.UpdatedAt;
+    }
+  }
+
+  public static async init(AgreementSignatureId?: string, dbTransaction?: any) {
+    try {
+      if (AgreementSignatureId) {
+        const hs = await AgreementSignature._Repository.findByPk(
+          AgreementSignatureId,
+          dbTransaction,
+        );
+        if (hs) {
+          return new AgreementSignature(hs.get({ plain: true }));
+        } else {
+          throw new ClassError(
+            'AgreementSignature',
+            'AgreementSignatureErrMsg01',
+            'AgreementSignature not found',
+          );
+        }
+      }
+      return new AgreementSignature();
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public async create(loginUser: LoginUser, dbTransaction?: any) {
+    try {
+      const systemCode =
+        ApplicationConfig.getComponentConfigValue('system-code');
+      const isPrivileged = await loginUser.checkPrivileges(
+        systemCode,
+        'AgreementSignature - Create',
+      );
+
+      if (!isPrivileged) {
+        throw new ClassError(
+          'AgreementSignature',
+          'AgreementSignatureErrMsg00',
+          "You do not have 'AgreementSignature - Create' privilege.",
+        );
+      }
+
+      if (!this.AgreementNo || !this.PartyId || !this.PartyType) {
+        throw new ClassError(
+          'AgreementSignature',
+          'AgreementSignatureErrMsg03',
+          'AgreementNo, PartyId and PartyType are required.',
+        );
+      }
+
+      this.ObjectId = this.createId();
+      this.CreatedById = loginUser.ObjectId;
+      this.CreatedAt = new Date();
+      this.UpdatedById = loginUser.ObjectId;
+      this.UpdatedAt = new Date();
+
+      const entityValueAfter: IAgreementSignatureAttr = {
+        SignatureId: this.SignatureId,
+        AgreementNo: this.AgreementNo,
+        Party: this.Party,
+        PartyId: this.PartyId,
+        PartyType: this.PartyType,
+        SignatureStatus: this.SignatureStatus,
+        SignedAt: this.SignedAt,
+        CreatedById: this.CreatedById,
+        CreatedAt: this.CreatedAt,
+        UpdatedById: this.UpdatedById,
+        UpdatedAt: this.UpdatedAt,
+      };
+
+      await AgreementSignature._Repository.create(entityValueAfter, {
+        transaction: dbTransaction,
+      });
+
+      const activity = new Activity();
+      activity.ObjectId = this.createId();
+      activity.Action = ActionEnum.CREATE;
+      activity.Description = 'Add Joint Hirer Signature';
+      activity.EntityId = this.ObjectId;
+      activity.EntityType = this.ObjectType;
+      activity.EntityValueBefore = JSON.stringify({});
+      activity.EntityValueAfter = JSON.stringify(entityValueAfter);
+
+      await activity.create(loginUser.ObjectId, dbTransaction);
+
+      return this;
+    } catch (error) {
+      throw error;
+    }
+  }
+}

package/src/components/rental/rental.ts

@@ -18,8 +18,8 @@ import { JointHirerRepository } from '../joint-hirer/joint-hirer.repository';
 import { AgreementModel } from '../../models';
 import { Agreement } from '../agreement/agreement';
 import { AggrementStatusEnum } from '../../enum/aggrement-status.enum';
-import { HirerSignatureRepository } from '../hirer-signature/hirer-signature.repository';
-import { HirerSignatureStatusEnum } from '../../enum/hirer-signature-status.enum';
+import { AgreementSignatureRepository } from '../agreement-signature/agreement-signature.repository';
+import { AgreementSignatureStatusEnum } from '../../enum/agreement-signature-status.enum';
 import { HirerTypeEnum } from '../../enum/hirer-type.enum';
 import { AgreementHistoryRepository } from '../agreement-history/agreement-history.repository';
 
@@ -49,7 +49,7 @@ export class Rental extends ObjectBase {
   protected static _Repo = new RentalRepository();
   protected static _AgreementRepo = new AgreementRepository();
   protected static _JointHirerRepo = new JointHirerRepository();
-  protected static _HirerSignatureRepo = new HirerSignatureRepository();
+  protected static _AgreementSignatureRepo = new AgreementSignatureRepository();
   protected static _AgreementHistoryRepo = new AgreementHistoryRepository();
 
   get RentalId(): string {
@@ -197,16 +197,16 @@ export class Rental extends ObjectBase {
         },
       );
 
-      //Create a record into rental_HirerSignature table
+      //Create a record into rental_AgreementSignature table
       //Create the main customer's signature record
-      await Rental._HirerSignatureRepo.create(
+      await Rental._AgreementSignatureRepo.create(
         {
-          HirerSignatureId: this.createId(),
+          SignatureId: this.createId(),
           AgreementNo: this.AgreementNo,
-          HirerType: HirerTypeEnum.PRIMARY,
-          CustomerId: this.CustomerId,
-          CustomerType: 'Customer',
-          SignatureStatus: HirerSignatureStatusEnum.PENDING,
+          Party: HirerTypeEnum.PRIMARY,
+          PartyId: this.CustomerId,
+          PartyType: 'Customer',
+          SignatureStatus: AgreementSignatureStatusEnum.PENDING,
           SignedAt: new Date(),
           CreatedById: loginUser.ObjectId,
           CreatedAt: new Date(),
@@ -219,14 +219,14 @@ export class Rental extends ObjectBase {
       // Create signatures record for joint hirers if any
       if (jointHirers && jointHirers.length > 0) {
         for (const jointHirer of jointHirers) {
-          await Rental._HirerSignatureRepo.create(
+          await Rental._AgreementSignatureRepo.create(
             {
-              HirerSignatureId: this.createId(),
+              SignatureId: this.createId(),
               AgreementNo: this.AgreementNo,
-              HirerType: HirerTypeEnum.JOINT,
-              CustomerId: jointHirer.CustomerId,
-              CustomerType: 'SDBCustomer',
-              SignatureStatus: HirerSignatureStatusEnum.PENDING,
+              Party: HirerTypeEnum.JOINT,
+              PartyId: jointHirer.CustomerId,
+              PartyType: 'Customer',
+              SignatureStatus: AgreementSignatureStatusEnum.PENDING,
               SignedAt: new Date(),
               CreatedById: loginUser.ObjectId,
               CreatedAt: new Date(),
@@ -773,7 +773,9 @@ export class Rental extends ObjectBase {
 
   async signAgreement(
     loginUser: LoginUser,
-    CustomerId: string,
+    party: string,
+    PartyId: string,
+    PartyType: string,
     dbTransaction: any,
     statusAfterSign?: RentalStatusEnum | string,
   ) {
@@ -816,30 +818,34 @@ export class Rental extends ObjectBase {
       );
       const customerSignature = signatureList.find(
         (sig) =>
-          sig.CustomerId === CustomerId &&
-          sig.SignatureStatus === HirerSignatureStatusEnum.PENDING,
+          sig.PartyId === PartyId &&
+          sig.PartyType === PartyType &&
+          sig.Party === party &&
+          sig.SignatureStatus === AgreementSignatureStatusEnum.PENDING,
       );
 
       if (!customerSignature) {
         throw new ClassError(
           'Rental',
           'RentalErrMsg01',
-          'Customer signature is not pending.',
+          'Signature is not pending.',
         );
       }
 
-      //Update rental_HirerSignature
+      //Update rental_AgreementSignature
       const signaturePayload = {
-        SignatureStatus: HirerSignatureStatusEnum.SIGNED,
+        SignatureStatus: AgreementSignatureStatusEnum.SIGNED,
         SignedAt: new Date(),
         UpdatedById: loginUser.ObjectId,
         UpdatedAt: new Date(),
       };
 
-      await Rental._HirerSignatureRepo.update(signaturePayload, {
+      await Rental._AgreementSignatureRepo.update(signaturePayload, {
         where: {
           AgreementNo: this.AgreementNo,
-          CustomerId: CustomerId,
+          Party: party,
+          PartyId: PartyId,
+          PartyType: PartyType,
         },
         transaction: dbTransaction,
       });
@@ -848,7 +854,7 @@ export class Rental extends ObjectBase {
       signatureActivity.ActivityId = signatureActivity.createId();
       signatureActivity.Action = ActionEnum.UPDATE;
       signatureActivity.Description = 'Update hirer signature';
-      signatureActivity.EntityType = 'HirerSignature';
+      signatureActivity.EntityType = 'AgreementSignature';
       signatureActivity.EntityId = this.AgreementNo;
       signatureActivity.EntityValueBefore = JSON.stringify(customerSignature);
       signatureActivity.EntityValueAfter = JSON.stringify(signaturePayload);

package/src/database.ts

@@ -4,7 +4,7 @@ import { RentalPriceModel } from './models/rental-price.entity';
 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 { AgreementSignatureModel } from './models/agreement-signature.entity';
 import { AgreementHistoryModel } from './models/agreement-history.entity';
 
 let sequelize: Sequelize;
@@ -19,7 +19,7 @@ function init(sequelizeOptions: SequelizeOptions) {
     BookingModel,
     JointHirerModel,
     AgreementModel,
-    HirerSignatureModel,
+    AgreementSignatureModel,
     AgreementHistoryModel,
   ]);
 }

package/src/enum/agreement-signature-status.enum.ts

@@ -0,0 +1,4 @@
+export enum AgreementSignatureStatusEnum {
+  PENDING = 'Pending',
+  SIGNED = 'Signed',
+}

package/src/enum/index.ts

@@ -2,7 +2,7 @@ import { RentalStatusEnum } from './rental-status.enum';
 import { BookingStatusEnum } from './booking.enum';
 import { RentalAccountTypeEnum } from './account-type.enum';
 import { AggrementStatusEnum } from './aggrement-status.enum';
-import { HirerSignatureStatusEnum } from './hirer-signature-status.enum';
+import { AgreementSignatureStatusEnum } from './agreement-signature-status.enum';
 import { HirerTypeEnum } from './hirer-type.enum';
 
 export {
@@ -10,6 +10,6 @@ export {
   BookingStatusEnum,
   RentalAccountTypeEnum,
   AggrementStatusEnum,
-  HirerSignatureStatusEnum,
+  AgreementSignatureStatusEnum,
   HirerTypeEnum,
 };

package/src/index.ts

@@ -8,8 +8,8 @@ import { JointHirer } from './components/joint-hirer/joint-hirer';
 import { JointHirerRepository } from './components/joint-hirer/joint-hirer.repository';
 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 { AgreementSignature } from './components/agreement-signature/agreement-signature';
+import { AgreementSignatureRepository } from './components/agreement-signature/agreement-signature.repository';
 import { AgreementHistory } from './components/agreement-history/agreement-history';
 import { AgreementHistoryRepository } from './components/agreement-history/agreement-history.repository';
 import * as rentalDb from './database';
@@ -29,8 +29,8 @@ export {
   JointHirerRepository,
   Agreement,
   AgreementRepository,
-  HirerSignature,
-  HirerSignatureRepository,
+  AgreementSignature,
+  AgreementSignatureRepository,
   AgreementHistory,
   AgreementHistoryRepository,
 };

package/src/interfaces/agreemeent-signature-attr.interface.ts

@@ -0,0 +1,15 @@
+import { AgreementSignatureStatusEnum } from '../enum/agreement-signature-status.enum';
+
+export interface IAgreementSignatureAttr {
+  SignatureId: string;
+  AgreementNo: string;
+  Party: string;
+  PartyId: string;
+  PartyType: string;
+  SignatureStatus: AgreementSignatureStatusEnum;
+  SignedAt: Date;
+  CreatedById: string;
+  CreatedAt: Date;
+  UpdatedById: string;
+  UpdatedAt: Date;
+}

package/src/interfaces/index.ts

@@ -4,8 +4,8 @@ import { IRentalFindAllSearchAttr } from './rental-find-all-search-attr.interfac
 import { IBookingAttr } from './booking-attr.interface';
 import { IAgreementAttr } from './agreement-attr.interface';
 import { IBookingFindAllSearchAttr } from './booking-find-all-search-attr.interface';
-import { IHirerSignatureAttr } from './hirer-signature-attr.interface';
-import { IResponseHirerSignature } from './response-hirer-signature-attr.interface';
+import { IAgreementSignatureAttr } from './agreemeent-signature-attr.interface';
+import { IResponseAgreementSignature } from './response-hirer-signature-attr.interface';
 
 export {
   IRentalAttr,
@@ -14,6 +14,6 @@ export {
   IBookingAttr,
   IAgreementAttr,
   IBookingFindAllSearchAttr,
-  IHirerSignatureAttr,
-  IResponseHirerSignature,
+  IAgreementSignatureAttr,
+  IResponseAgreementSignature,
 };

package/src/interfaces/response-hirer-signature-attr.interface.ts

@@ -1,12 +1,12 @@
-import { HirerSignatureStatusEnum } from '../enum/hirer-signature-status.enum';
+import { AgreementSignatureStatusEnum } from '../enum/agreement-signature-status.enum';
 
-export interface IResponseHirerSignature {
+export interface IResponseAgreementSignature {
   HirerSignatureId: string;
   AgreementNo: string;
-  HirerType: string;
-  CustomerId: string;
-  CustomerType: string;
-  SignatureStatus: HirerSignatureStatusEnum;
+  Party: string;
+  PartyId: string;
+  PartyType: string;
+  SignatureStatus: AgreementSignatureStatusEnum;
   SignedAt: Date;
   CreatedById: string;
   CreatedAt: Date;

package/src/models/{hirer-signature.entity.ts → agreement-signature.entity.ts}

@@ -9,17 +9,22 @@ import {
   UpdatedAt,
 } from 'sequelize-typescript';
 import { AgreementModel } from './agreement.entity';
+import { IAgreementSignatureAttr } from '../interfaces/agreemeent-signature-attr.interface';
+import { AgreementSignatureStatusEnum } from '../enum/agreement-signature-status.enum';
 
 @Table({
-  tableName: 'rental_HirerSignature',
+  tableName: 'rental_AgreementSignature',
 })
-export class HirerSignatureModel extends Model {
+export class AgreementSignatureModel
+  extends Model
+  implements IAgreementSignatureAttr
+{
   @Column({
     primaryKey: true,
     allowNull: false,
     type: DataType.STRING(30),
   })
-  HirerSignatureId: string;
+  SignatureId: string;
 
   @ForeignKey(() => AgreementModel)
   @Column({
@@ -30,30 +35,30 @@ export class HirerSignatureModel extends Model {
 
   @Column({
     allowNull: false,
-    type: DataType.STRING(10),
+    type: DataType.STRING(30),
   })
-  HirerType: string;
+  Party: string;
 
   @Column({
     allowNull: false,
     type: DataType.STRING(30),
   })
-  CustomerId: string;
+  PartyId: string;
 
   @Column({
     allowNull: false,
     type: DataType.STRING(30),
   })
-  CustomerType: string;
+  PartyType: string;
 
   @Column({
     allowNull: false,
     type: DataType.STRING(10),
   })
-  SignatureStatus: string;
+  SignatureStatus: AgreementSignatureStatusEnum;
 
   @Column({
-    allowNull: false,
+    allowNull: true,
     type: DataType.DATE,
   })
   SignedAt: Date;

package/src/models/agreement.entity.ts

@@ -1,7 +1,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 { AgreementSignatureModel } from './agreement-signature.entity';
 import { AgreementHistoryModel } from './agreement-history.entity';
 
 @Table({
@@ -39,8 +39,8 @@ export class AgreementModel extends Model {
   @HasMany(() => RentalModel)
   Rentals: RentalModel[];
 
-  @HasMany(() => HirerSignatureModel)
-  HirerSignatures: HirerSignatureModel[];
+  @HasMany(() => AgreementSignatureModel)
+  AgreementSignatures: AgreementSignatureModel[];
 
   @HasMany(() => AgreementHistoryModel)
   History: AgreementHistoryModel[];

package/src/models/index.ts

@@ -3,7 +3,7 @@ import { RentalPriceModel } from './rental-price.entity';
 import { BookingModel } from './booking.entity';
 import { JointHirerModel } from './joint-hirer.entity';
 import { AgreementModel } from './agreement.entity';
-import { HirerSignatureModel } from './hirer-signature.entity';
+import { AgreementSignatureModel } from './agreement-signature.entity';
 import { AgreementHistoryModel } from './agreement-history.entity';
 
 export {
@@ -12,6 +12,6 @@ export {
   BookingModel,
   JointHirerModel,
   AgreementModel,
-  HirerSignatureModel,
+  AgreementSignatureModel,
   AgreementHistoryModel,
 };