@tomei/rental 0.13.1 → 0.14.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.1",
+  "version": "0.14.0",
   "description": "Tomei Rental Package",
   "main": "dist/index.js",
   "scripts": {

package/src/components/agreement/agreement.ts

@@ -94,53 +94,23 @@ export class Agreement extends ObjectBase {
             SELECT 
                 hs.*, 
                 c.FullName,
-                cf.RightThumb, 
-                cf.RightIndexFinger,
-                cf.LeftThumb, 
-                cf.LeftIndexFinger 
+                c.CRMRefNo 
             FROM 
                 rental_HirerSignature hs
             LEFT JOIN 
-                sdb_Customer c ON hs.CustomerId = c.CustomerId
-            LEFT JOIN 
-                 ${process.env.CENTRAL_DB_NAME}.customer_fingerprint cf ON c.CRMRefNo = cf.CustomerId
+                sdb_Customer c ON hs.CustomerId = c.CustomerId            
             WHERE 
                 hs.AgreementNo = '${agreementNo}'
       `;
 
       const db = rentalDb.getConnection();
 
-      const signatures = await db.query(query, {
+      const signatures: IResponseHirerSignature[] = await db.query(query, {
         type: QueryTypes.SELECT,
         transaction: dbTransaction,
       });
 
-      // Process the result to convert fingerprint fields to base64 strings
-      const processedSignatures = signatures.map((signature: any) => {
-        const convertToBase64 = (data: Buffer | null) =>
-          data ? atob(Buffer.from(data).toString('base64')) : null;
-
-        const processedSignature = {
-          ...signature,
-          FingerPrint: {
-            RightThumb: convertToBase64(signature.RightThumb),
-            RightIndexFinger: convertToBase64(signature.RightIndexFinger),
-            LeftThumb: convertToBase64(signature.LeftThumb),
-            LeftIndexFinger: convertToBase64(signature.LeftIndexFinger),
-          },
-        };
-
-        // Delete individual fingerprint fields
-        delete processedSignature.RightThumb;
-        delete processedSignature.RightIndexFinger;
-        delete processedSignature.LeftThumb;
-        delete processedSignature.LeftIndexFinger;
-
-        return processedSignature;
-      });
-
-      // Return the processed records
-      return processedSignatures;
+      return signatures;
     } catch (error) {
       throw error;
     }

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/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/interfaces/response-hirer-signature-attr.interface.ts

@@ -5,6 +5,7 @@ export interface IResponseHirerSignature {
   AgreementNo: string;
   HirerType: string;
   CustomerId: string;
+  CRMRefNo: string;
   CustomerName: string;
   CustomerType: string;
   SignatureStatus: HirerSignatureStatusEnum;

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[];
 }