@tomei/rental 0.12.3 → 0.13.0

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

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

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

@@ -0,0 +1,140 @@
+import { ClassError, ObjectBase } from '@tomei/general';
+import { HirerSignatureRepository } from './hirer-signature.repository';
+import { IHirerSignatureAttr } from '../../interfaces/hirer-signature-attr.interface';
+import { ApplicationConfig } from '@tomei/config';
+import { LoginUser } from '@tomei/sso';
+import { ActionEnum, Activity } from '@tomei/activity-history';
+import { HirerSignatureStatusEnum } from '../../enum/hirer-signature-status.enum';
+
+export class HirerSignature extends ObjectBase {
+  ObjectId: string;
+  ObjectName: string;
+  ObjectType: string = 'HirerSignature';
+  TableName: string = 'rental_HirerSignature';
+  AgreementNo: string;
+  HirerType: string;
+  CustomerId: string;
+  CustomerType: string;
+  SignatureStatus: HirerSignatureStatusEnum;
+  SignedAt: Date;
+  CreatedById: string;
+  CreatedAt: Date;
+  UpdatedById: string;
+  UpdatedAt: Date;
+
+  get HirerSignatureId(): string {
+    return this.ObjectId;
+  }
+
+  set HirerSignatureId(value: string) {
+    this.ObjectId = value;
+  }
+
+  protected static _Repository = new HirerSignatureRepository();
+
+  protected constructor(hirerSignatureAttr?: IHirerSignatureAttr) {
+    super();
+    if (hirerSignatureAttr) {
+      this.HirerSignatureId = hirerSignatureAttr.HirerSignatureId;
+      this.AgreementNo = hirerSignatureAttr.AgreementNo;
+      this.HirerType = hirerSignatureAttr.HirerType;
+      this.CustomerId = hirerSignatureAttr.CustomerId;
+      this.CustomerType = hirerSignatureAttr.CustomerType;
+      this.SignatureStatus = hirerSignatureAttr.SignatureStatus;
+      this.SignedAt = hirerSignatureAttr.SignedAt;
+      this.CreatedById = hirerSignatureAttr.CreatedById;
+      this.CreatedAt = hirerSignatureAttr.CreatedAt;
+      this.UpdatedById = hirerSignatureAttr.UpdatedById;
+      this.UpdatedAt = hirerSignatureAttr.UpdatedAt;
+    }
+  }
+
+  public static async init(HirerSignatureId?: string, dbTransaction?: any) {
+    try {
+      if (HirerSignatureId) {
+        const hs = await HirerSignature._Repository.findByPk(
+          HirerSignatureId,
+          dbTransaction,
+        );
+        if (hs) {
+          return new HirerSignature(hs.get({ plain: true }));
+        } else {
+          throw new ClassError(
+            'HirerSignature',
+            'HirerSignatureErrMsg01',
+            'HirerSignature not found',
+          );
+        }
+      }
+      return new HirerSignature();
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public async create(loginUser: LoginUser, dbTransaction?: any) {
+    try {
+      const systemCode =
+        ApplicationConfig.getComponentConfigValue('system-code');
+      const isPrivileged = await loginUser.checkPrivileges(
+        systemCode,
+        'HirerSignature - Create',
+      );
+
+      if (!isPrivileged) {
+        throw new ClassError(
+          'HirerSignature',
+          'HirerSignatureErrMsg00',
+          "You do not have 'HirerSignature - Create' privilege.",
+        );
+      }
+
+      if (!this.AgreementNo || !this.CustomerId || !this.CustomerType) {
+        throw new ClassError(
+          'HirerSignature',
+          'HirerSignatureErrMsg03',
+          'AgreementNo, CustomerId and CustomerType are required.',
+        );
+      }
+
+      this.ObjectId = this.createId();
+      this.CreatedById = loginUser.ObjectId;
+      this.CreatedAt = new Date();
+      this.UpdatedById = loginUser.ObjectId;
+      this.UpdatedAt = new Date();
+
+      const entityValueAfter: IHirerSignatureAttr = {
+        HirerSignatureId: this.HirerSignatureId,
+        AgreementNo: this.AgreementNo,
+        HirerType: this.HirerType,
+        CustomerId: this.CustomerId,
+        CustomerType: this.CustomerType,
+        SignatureStatus: this.SignatureStatus,
+        SignedAt: this.SignedAt,
+        CreatedById: this.CreatedById,
+        CreatedAt: this.CreatedAt,
+        UpdatedById: this.UpdatedById,
+        UpdatedAt: this.UpdatedAt,
+      };
+
+      await HirerSignature._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,6 +18,9 @@ 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 { HirerTypeEnum } from '../../enum/hirer-type.enum';
 
 export class Rental extends ObjectBase {
   ObjectId: string;
@@ -45,6 +48,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();
 
   get RentalId(): string {
     return this.ObjectId;
@@ -191,6 +195,47 @@ export class Rental extends ObjectBase {
         },
       );
 
+      //Create a record into rental_HirerSignature table
+      //Create the main customer's signature record
+      await Rental._HirerSignatureRepo.create(
+        {
+          HirerSignatureId: this.createId(),
+          AgreementNo: this.AgreementNo,
+          HirerType: HirerTypeEnum.PRIMARY,
+          CustomerId: this.CustomerId,
+          CustomerType: 'Customer',
+          SignatureStatus: HirerSignatureStatusEnum.PENDING,
+          SignedAt: new Date(),
+          CreatedById: loginUser.ObjectId,
+          CreatedAt: new Date(),
+          UpdatedById: loginUser.ObjectId,
+          UpdatedAt: new Date(),
+        },
+        { transaction: dbTransaction },
+      );
+
+      // Create signatures record for joint hirers if any
+      if (jointHirers && jointHirers.length > 0) {
+        for (const jointHirer of jointHirers) {
+          await Rental._HirerSignatureRepo.create(
+            {
+              HirerSignatureId: this.createId(),
+              AgreementNo: this.AgreementNo,
+              HirerType: HirerTypeEnum.JOINT,
+              CustomerId: jointHirer.CustomerId,
+              CustomerType: 'SDBCustomer',
+              SignatureStatus: HirerSignatureStatusEnum.PENDING,
+              SignedAt: new Date(),
+              CreatedById: loginUser.ObjectId,
+              CreatedAt: new Date(),
+              UpdatedById: loginUser.ObjectId,
+              UpdatedAt: new Date(),
+            },
+            { transaction: dbTransaction },
+          );
+        }
+      }
+
       /*Part 4: Insert Rental & The Agreed Rental Price*/
       if (!rentalPrice.PriceId) {
         const rentalPriceData = await rentalPrice.create(
@@ -724,7 +769,11 @@ export class Rental extends ObjectBase {
     }
   }
 
-  async signAgreement(loginUser: LoginUser, dbTransaction: any) {
+  async signAgreement(
+    loginUser: LoginUser,
+    CustomerId: string,
+    dbTransaction: any,
+  ) {
     try {
       // Part 1: Privilege Checking
       // Call loginUser.checkPrivileges() by passing:
@@ -756,6 +805,65 @@ export class Rental extends ObjectBase {
         );
       }
 
+      //Make sure CustomerId inside the listing and SignatureStatus is "Pending"
+      const signatureList = await Agreement.getSignatureList(
+        loginUser,
+        this.AgreementNo,
+        dbTransaction,
+      );
+      const customerSignature = signatureList.find(
+        (sig) =>
+          sig.CustomerId === CustomerId &&
+          sig.SignatureStatus === HirerSignatureStatusEnum.PENDING,
+      );
+
+      if (!customerSignature) {
+        throw new ClassError(
+          'Rental',
+          'RentalErrMsg01',
+          'Customer signature is not pending.',
+        );
+      }
+
+      //Update rental_HirerSignature
+      const signaturePayload = {
+        SignatureStatus: HirerSignatureStatusEnum.SIGNED,
+        SignedAt: new Date(),
+        UpdatedById: loginUser.ObjectId,
+        UpdatedAt: new Date(),
+      };
+
+      await Rental._HirerSignatureRepo.update(signaturePayload, {
+        where: {
+          AgreementNo: this.AgreementNo,
+          CustomerId: CustomerId,
+        },
+        transaction: dbTransaction,
+      });
+
+      const signatureActivity = new Activity();
+      signatureActivity.ActivityId = signatureActivity.createId();
+      signatureActivity.Action = ActionEnum.UPDATE;
+      signatureActivity.Description = 'Update hirer signature';
+      signatureActivity.EntityType = 'HirerSignature';
+      signatureActivity.EntityId = this.AgreementNo;
+      signatureActivity.EntityValueBefore = JSON.stringify(customerSignature);
+      signatureActivity.EntityValueAfter = JSON.stringify(signaturePayload);
+      await signatureActivity.create(loginUser.ObjectId, dbTransaction);
+
+      const updatedSignatureList = await Agreement.getSignatureList(
+        loginUser,
+        this.AgreementNo,
+        dbTransaction,
+      );
+
+      const pendingSignatures = updatedSignatureList.filter(
+        (sig) => sig.SignatureStatus === 'Pending',
+      );
+      if (pendingSignatures.length > 0) {
+        return;
+      }
+
       //Part 3: Update Agreement Status
       // 3.1  Set EntityValueBefore to current agreement instance.
       const entityValueAgreementBefore = {
@@ -844,6 +952,8 @@ export class Rental extends ObjectBase {
         ...payloadRental,
       };
 
+      this._Status = RentalStatusEnum.PENDING_KEY_COLLECTION;
+
       // Part 6: Record Update Agreement Activity
       const rentalActivity = new Activity();
       rentalActivity.ActivityId = activity.createId();

package/src/database.ts

@@ -4,6 +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';
 
 let sequelize: Sequelize;
 
@@ -17,6 +18,7 @@ function init(sequelizeOptions: SequelizeOptions) {
     BookingModel,
     JointHirerModel,
     AgreementModel,
+    HirerSignatureModel,
   ]);
 }
 

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

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

package/src/enum/hirer-type.enum.ts

@@ -0,0 +1,4 @@
+export enum HirerTypeEnum {
+  PRIMARY = 'Primary',
+  JOINT = 'Joint',
+}

package/src/enum/index.ts

@@ -2,10 +2,14 @@ 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 { HirerTypeEnum } from './hirer-type.enum';
 
 export {
   RentalStatusEnum,
   BookingStatusEnum,
   RentalAccountTypeEnum,
   AggrementStatusEnum,
+  HirerSignatureStatusEnum,
+  HirerTypeEnum,
 };

package/src/index.ts

@@ -8,6 +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 * as rentalDb from './database';
 export * from './interfaces';
 export * from './models';
@@ -25,4 +27,6 @@ export {
   JointHirerRepository,
   Agreement,
   AgreementRepository,
+  HirerSignature,
+  HirerSignatureRepository,
 };

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

@@ -0,0 +1,15 @@
+import { HirerSignatureStatusEnum } from '../enum/hirer-signature-status.enum';
+
+export interface IHirerSignatureAttr {
+  HirerSignatureId: string;
+  AgreementNo: string;
+  HirerType: string;
+  CustomerId: string;
+  CustomerType: string;
+  SignatureStatus: HirerSignatureStatusEnum;
+  SignedAt: Date;
+  CreatedById: string;
+  CreatedAt: Date;
+  UpdatedById: string;
+  UpdatedAt: Date;
+}

package/src/interfaces/index.ts

@@ -4,6 +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';
 
 export {
   IRentalAttr,
@@ -12,4 +14,6 @@ export {
   IBookingAttr,
   IAgreementAttr,
   IBookingFindAllSearchAttr,
+  IHirerSignatureAttr,
+  IResponseHirerSignature,
 };

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

@@ -0,0 +1,16 @@
+import { HirerSignatureStatusEnum } from '../enum/hirer-signature-status.enum';
+
+export interface IResponseHirerSignature {
+  HirerSignatureId: string;
+  AgreementNo: string;
+  HirerType: string;
+  CustomerId: string;
+  CustomerName: string;
+  CustomerType: string;
+  SignatureStatus: HirerSignatureStatusEnum;
+  SignedAt: Date;
+  CreatedById: string;
+  CreatedAt: Date;
+  UpdatedById: string;
+  UpdatedAt: Date;
+}

package/src/models/agreement.entity.ts

@@ -1,6 +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';
 
 @Table({
   tableName: 'rental_Agreement',
@@ -36,4 +37,7 @@ export class AgreementModel extends Model {
 
   @HasMany(() => RentalModel)
   Rentals: RentalModel[];
+
+  @HasMany(() => HirerSignatureModel)
+  HirerSignatures: HirerSignatureModel[];
 }

package/src/models/hirer-signature.entity.ts

@@ -0,0 +1,81 @@
+import {
+  Column,
+  DataType,
+  Table,
+  Model,
+  ForeignKey,
+  BelongsTo,
+  CreatedAt,
+  UpdatedAt,
+} from 'sequelize-typescript';
+import { AgreementModel } from './agreement.entity';
+
+@Table({
+  tableName: 'rental_HirerSignature',
+})
+export class HirerSignatureModel extends Model {
+  @Column({
+    primaryKey: true,
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  HirerSignatureId: string;
+
+  @ForeignKey(() => AgreementModel)
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  AgreementNo: string;
+
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(10),
+  })
+  HirerType: string;
+
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  CustomerId: string;
+
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  CustomerType: string;
+
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(10),
+  })
+  SignatureStatus: string;
+
+  @Column({
+    allowNull: false,
+    type: DataType.DATE,
+  })
+  SignedAt: Date;
+
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  CreatedById: string;
+
+  @CreatedAt
+  CreatedAt: Date;
+
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  UpdatedById: string;
+
+  @UpdatedAt
+  UpdatedAt: Date;
+
+  @BelongsTo(() => AgreementModel)
+  Agreement: AgreementModel;
+}

package/src/models/index.ts

@@ -3,6 +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';
 
 export {
   RentalModel,
@@ -10,4 +11,5 @@ export {
   BookingModel,
   JointHirerModel,
   AgreementModel,
+  HirerSignatureModel,
 };

package/tsconfig.json

@@ -20,4 +20,5 @@
     "noFallthroughCasesInSwitch": false,
     "strictNullChecks": false,
   },
+  "exclude": ["node_modules", "dist"]
 }

package/.eslintrc

@@ -1,16 +0,0 @@
-{
-  "parser": "@typescript-eslint/parser",
-  "parserOptions": {
-    "ecmaVersion": "latest",
-    "sourceType": "module" // Allows for the use of imports
-  },
-  "extends": ["plugin:@typescript-eslint/recommended"],
-  "env": {
-    "node": true // Enable Node.js global variables
-  },
-  "rules": {
-    "no-console": "off",
-    "import/prefer-default-export": "off",
-    "@typescript-eslint/no-unused-vars": "warn"
-  }
-}

package/.eslintrc.js

@@ -1,35 +0,0 @@
-module.exports = {
-  parser: "@typescript-eslint/parser",
-  plugins: ["@typescript-eslint"],
-
-  parserOptions: {
-    ecmaVersion: "latest", // Allows the use of modern ECMAScript features
-    sourceType: "module", // Allows for the use of imports
-  },
-
-  extends: ["eslint:recommended", "plugin:@typescript-eslint/recommended"],
-  env: {
-    node: true, // Enable Node.js global variables
-  },
-  rules: {
-    "no-console": "off",
-    "@typescript-eslint/no-explicit-any": "off",
-    "@typescript-eslint/no-var-requires": "off",
-    "@typescript-eslint/explicit-module-boundary-types": "off",
-    "import/prefer-default-export": "off",
-    "@typescript-eslint/no-unused-vars": "warn",
-    "no-useless-catch": "off",
-    "@typescript-eslint/no-non-null-assertion": "off",
-    "@typescript-eslint/no-empty-function": "off",
-    "@typescript-eslint/no-empty-interface": "off",
-    "@typescript-eslint/no-inferrable-types": "off",
-    "@typescript-eslint/no-namespace": "off",
-    "@typescript-eslint/no-use-before-define": "off",
-    "@typescript-eslint/no-unsafe-assignment": "off",
-    "@typescript-eslint/no-unsafe-call": "off",
-    "@typescript-eslint/no-unsafe-member-access": "off",
-    "@typescript-eslint/no-unsafe-return": "off",
-    "@typescript-eslint/restrict-template-expressions": "off",
-    "no-useless-escape": "off",
-  },
-};