@tomei/rental 0.4.5 → 0.5.1

package/sonar-project.properties

@@ -0,0 +1,13 @@
+sonar.projectKey=all-tomei-projects_rental
+sonar.organization=all-tomei-projects
+
+# This is the name and version displayed in the SonarCloud UI.
+#sonar.projectName=Rental
+#sonar.projectVersion=1.0
+
+
+# Path is relative to the sonar-project.properties file. Replace "\" by "/" on Windows.
+#sonar.sources=.
+
+# Encoding of the source code. Default is default system encoding
+#sonar.sourceEncoding=UTF-8

package/src/components/booking/booking.repository.ts

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

package/src/components/booking/booking.ts

@@ -0,0 +1,291 @@
+import { ClassError, ObjectBase } from '@tomei/general';
+import { BookingStatusEnum } from '../../enum/booking.enum';
+import { IBookingAttr } from '../../interfaces/booking-attr.interface';
+import { BookingRepository } from './booking.repository';
+import { DateTime } from 'luxon';
+import { LoginUser } from '@tomei/sso';
+import { RentalPrice } from '../rental-price/rental-price';
+import { ApplicationConfig } from '@tomei/config';
+import { Op } from 'sequelize';
+import { Rental } from '../rental/rental';
+import { ActionEnum, Activity } from '@tomei/activity-history';
+
+export class Booking extends ObjectBase {
+  ObjectId: string;
+  ObjectName: string;
+  ObjectType: string = 'Booking';
+  TableName = 'booking_Booking';
+  CustomerId: string;
+  CustomerType: string;
+  ItemId: string;
+  ItemType: string;
+  PriceId: string;
+  private _ScheduledStartDateTime: Date;
+  private _ScheduledEndDateTime: Date;
+  BookingFee: number;
+  Status: BookingStatusEnum;
+  CancelRemarks: string;
+  private _CreatedById: string;
+  private _CreatedAt: Date;
+  private _UpdatedById: string;
+  private _UpdatedAt: Date;
+
+  private static _Repo = new BookingRepository();
+
+  get BookingNo(): string {
+    return this.ObjectId;
+  }
+
+  set BookingNo(value: string) {
+    this.ObjectId = value;
+  }
+
+  get CreatedById(): string {
+    return this._CreatedById;
+  }
+
+  get CreatedAt(): Date {
+    return this._CreatedAt;
+  }
+
+  get UpdatedById(): string {
+    return this._UpdatedById;
+  }
+
+  get UpdatedAt(): Date {
+    return this._UpdatedAt;
+  }
+
+  get ScheduledStartDateTime(): Date {
+    return this._ScheduledStartDateTime;
+  }
+
+  get ScheduledEndDateTime(): Date {
+    return this._ScheduledEndDateTime;
+  }
+
+  async setScheduledStartDateTime(datetime: Date) {
+    const dateTime = DateTime.fromJSDate(datetime);
+    const currentDateTime = DateTime.now();
+    if (dateTime <= currentDateTime) {
+      throw new ClassError(
+        'Booking',
+        'BookingErrMsg01',
+        'Booking must be for future date time.',
+      );
+    }
+    this._ScheduledStartDateTime = datetime;
+  }
+
+  async setScheduledEndDateTime(datetime: Date) {
+    const dateTime = DateTime.fromJSDate(datetime);
+    const currentDateTime = DateTime.now();
+    if (dateTime <= currentDateTime) {
+      throw new ClassError(
+        'Booking',
+        'BookingErrMsg01',
+        'Booking must be for future date time.',
+      );
+    }
+
+    if (!this._ScheduledStartDateTime) {
+      throw new ClassError(
+        'Booking',
+        'BookingErrMsg01',
+        'Booking start date time must be set before setting end date time.',
+      );
+    }
+
+    const startDateTime = DateTime.fromJSDate(this._ScheduledStartDateTime);
+    if (dateTime <= startDateTime) {
+      throw new ClassError(
+        'Booking',
+        'BookingErrMsg03',
+        'Booking end date time must be more than start date time.',
+      );
+    }
+
+    this._ScheduledEndDateTime = datetime;
+  }
+
+  protected constructor(bookingAttr?: IBookingAttr) {
+    super();
+    if (bookingAttr) {
+      this.ObjectId = bookingAttr.BookingNo;
+      this.CustomerId = bookingAttr.CustomerId;
+      this.CustomerType = bookingAttr.CustomerType;
+      this.ItemId = bookingAttr.ItemId;
+      this.ItemType = bookingAttr.ItemType;
+      this.PriceId = bookingAttr.PriceId;
+      this._ScheduledStartDateTime = bookingAttr.ScheduledStartDateTime;
+      this._ScheduledEndDateTime = bookingAttr.ScheduledEndDateTime;
+      this.BookingFee = bookingAttr.BookingFee;
+      this.Status = bookingAttr.Status;
+      this.CancelRemarks = bookingAttr.CancelRemarks;
+      this._CreatedById = bookingAttr.CreatedById;
+      this._CreatedAt = bookingAttr.CreatedAt;
+      this._UpdatedById = bookingAttr.UpdatedById;
+      this._UpdatedAt = bookingAttr.UpdatedAt;
+    }
+  }
+
+  public static async init(dbTransaction?: any, bookingNo?: string) {
+    try {
+      if (bookingNo) {
+        const booking = await Booking._Repo.findByPk(bookingNo, {
+          transaction: dbTransaction,
+        });
+
+        if (booking) {
+          return new Booking(booking.get({ plain: true }));
+        } else {
+          throw new Error('Booking not found');
+        }
+      }
+      return new Booking();
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public async create(
+    dbTransaction: any,
+    loginUser: LoginUser,
+    rentalPrice: RentalPrice,
+  ) {
+    //This method will create new booking record.
+    try {
+      //Part 1: Check Privilege
+      const systemCode =
+        ApplicationConfig.getComponentConfigValue('system-code');
+      const isPrivileged = await loginUser.checkPrivileges(
+        systemCode,
+        'Booking - Create',
+      );
+
+      if (!isPrivileged) {
+        throw new ClassError(
+          'Booking',
+          'BookingErrMsg02',
+          "You do not have 'Booking - Create' privilege.",
+        );
+      }
+
+      //Part 2: Booking Validation
+      //check if item and booking available
+      const isRentalAvailable = await Rental.isItemAvailable(
+        this.ItemId,
+        this.ItemType,
+        this._ScheduledStartDateTime,
+        this._ScheduledEndDateTime,
+        dbTransaction,
+      );
+
+      const isBookingAvailable = await Booking.isBookingItemAvailable(
+        dbTransaction,
+        this.ItemId,
+        this.ItemType,
+        this._ScheduledStartDateTime,
+        this._ScheduledEndDateTime,
+      );
+
+      if (!isRentalAvailable || !isBookingAvailable) {
+        throw new ClassError(
+          'Booking',
+          'BookingErrMsg02',
+          'Booking is not available for the item on the chosen date.',
+        );
+      }
+
+      //Part 3: Insert Booking & The Agreed Rental Price
+      const rp = await rentalPrice.create(loginUser, dbTransaction);
+
+      //Set below Booking attributes:
+      this.BookingNo = this.createId();
+      this.PriceId = rp.PriceId;
+      this._CreatedById = loginUser.ObjectId;
+      this._CreatedAt = DateTime.now().toJSDate();
+      this._UpdatedById = loginUser.ObjectId;
+      this._UpdatedAt = DateTime.now().toJSDate();
+
+      //call this class repo create
+      const data: IBookingAttr = {
+        BookingNo: this.BookingNo,
+        CustomerId: this.CustomerId,
+        CustomerType: this.CustomerType,
+        ItemId: this.ItemId,
+        ItemType: this.ItemType,
+        PriceId: this.PriceId,
+        ScheduledStartDateTime: this._ScheduledStartDateTime,
+        ScheduledEndDateTime: this._ScheduledEndDateTime,
+        BookingFee: this.BookingFee,
+        Status: this.Status,
+        CancelRemarks: this.CancelRemarks,
+        CreatedById: this._CreatedById,
+        CreatedAt: this._CreatedAt,
+        UpdatedById: this._UpdatedById,
+        UpdatedAt: this._UpdatedAt,
+      };
+
+      await Booking._Repo.create(data, {
+        transaction: dbTransaction,
+      });
+
+      //Part 4: Record Create Booking Activity
+      const activity = new Activity();
+      activity.ActivityId = activity.createId();
+      activity.Action = ActionEnum.ADD;
+      activity.Description = 'Add Booking';
+      activity.ObjectId = this.BookingNo;
+      activity.EntityType = this.ObjectType;
+      activity.EntityValueBefore = JSON.stringify({});
+      activity.EntityValueAfter = JSON.stringify(data);
+
+      await activity.create(loginUser.ObjectId, dbTransaction);
+
+      return this;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public static async isBookingItemAvailable(
+    dbTransaction: any,
+    itemId: string,
+    itemType: string,
+    startDateTime: Date,
+    endDateTime: Date,
+  ) {
+    //This method will check if booking item available.
+    try {
+      //call this class repo findOne method
+      const booking = await Booking._Repo.findOne({
+        where: {
+          ItemId: itemId,
+          ItemType: itemType,
+          [Op.and]: [
+            {
+              ScheduledStartDateTime: {
+                [Op.lte]: endDateTime,
+              },
+            },
+            {
+              ScheduledEndDateTime: {
+                [Op.gte]: startDateTime,
+              },
+            },
+          ],
+        },
+        transaction: dbTransaction,
+      });
+
+      //if booking record exists, return false.
+      if (booking) {
+        return false;
+      }
+      return true;
+    } catch (error) {
+      throw error;
+    }
+  }
+}

package/src/components/rental/rental.ts

@@ -144,7 +144,7 @@ export class Rental extends ObjectBase {
       }
 
       /*Part 2: Make Sure Rental Item Available*/
-      const isItemAvailable = await this.isItemAvailable(
+      const isItemAvailable = await Rental.isItemAvailable(
         this.ItemId,
         this.ItemType,
         this.StartDateTime,
@@ -198,7 +198,7 @@ export class Rental extends ObjectBase {
 
       /*Part 4: Record Create Rental Activity*/
       const activity = new Activity();
-      activity.ActivityId = this.createId();
+      activity.ActivityId = activity.createId();
       activity.Action = ActionEnum.ADD;
       activity.Description = 'Add Rental';
       activity.EntityType = 'Rental';
@@ -214,7 +214,7 @@ export class Rental extends ObjectBase {
     }
   }
 
-  async isItemAvailable(
+  public static async isItemAvailable(
     itemId: string,
     itemType: string,
     startDateTime: Date,
@@ -494,7 +494,7 @@ export class Rental extends ObjectBase {
 
       // Record the Update Activity
       const activity = new Activity();
-      activity.ActivityId = this.createId();
+      activity.ActivityId = activity.createId();
       activity.Action = ActionEnum.UPDATE;
       activity.Description = 'Set Rental as Terminated';
       activity.EntityType = 'Rental';

package/src/database.ts

@@ -1,6 +1,7 @@
 import { Sequelize, SequelizeOptions } from 'sequelize-typescript';
 import { RentalModel } from './models/rental.entity';
 import { RentalPriceModel } from './models/rental-price.entity';
+import { BookingModel } from './models/booking.entity';
 
 let sequelize: Sequelize;
 
@@ -11,6 +12,7 @@ function init(sequelizeOptions: SequelizeOptions) {
     // Add your models here
     RentalModel,
     RentalPriceModel,
+    BookingModel,
   ]);
 }
 

package/src/enum/booking.enum.ts

@@ -0,0 +1,5 @@
+export enum BookingStatusEnum {
+  CONFIRMED = 'Confirmed',
+  PENDING = 'Pending',
+  CANCELLED = 'Cancelled',
+}

package/src/enum/index.ts

@@ -1,3 +1,4 @@
 import { RentalStatusEnum } from './rental-status.enum';
+import { BookingStatusEnum } from './booking.enum';
 
-export { RentalStatusEnum };
+export { RentalStatusEnum, BookingStatusEnum };

package/src/index.ts

@@ -2,6 +2,8 @@ import { RentalPriceRepository } from './components/rental-price/rental-price.re
 import { RentalRepository } from './components/rental/rental.repository';
 import { Rental } from './components/rental/rental';
 import { RentalPrice } from './components/rental-price/rental-price';
+import { Booking } from './components/booking/booking';
+import { BookingRepository } from './components/booking/booking.repository';
 import * as rentalDb from './database';
 export * from './interfaces';
 export * from './models';
@@ -12,5 +14,7 @@ export {
   RentalPrice,
   RentalRepository,
   RentalPriceRepository,
+  Booking,
+  BookingRepository,
   rentalDb,
 };

package/src/interfaces/booking-attr.interface.ts

@@ -0,0 +1,19 @@
+import { BookingStatusEnum } from '../enum/booking.enum';
+
+export interface IBookingAttr {
+  BookingNo: string;
+  CustomerId: string;
+  CustomerType: string;
+  ItemId: string;
+  ItemType: string;
+  PriceId: string;
+  ScheduledStartDateTime: Date;
+  ScheduledEndDateTime: Date;
+  BookingFee: number;
+  Status: BookingStatusEnum;
+  CancelRemarks: string;
+  CreatedById: string;
+  CreatedAt: Date;
+  UpdatedById: string;
+  UpdatedAt: Date;
+}

package/src/interfaces/index.ts

@@ -1,5 +1,11 @@
 import { IRentalAttr } from './rental-attr.interface';
 import { IRentalPriceAttr } from './rental-price-attr.interface';
 import { IRentalFindAllSearchAttr } from './rental-find-all-search-attr.interface';
+import { IBookingAttr } from './booking-attr.interface';
 
-export { IRentalAttr, IRentalPriceAttr, IRentalFindAllSearchAttr };
+export {
+  IRentalAttr,
+  IRentalPriceAttr,
+  IRentalFindAllSearchAttr,
+  IBookingAttr,
+};

package/src/models/booking.entity.ts

@@ -0,0 +1,105 @@
+import {
+  Column,
+  DataType,
+  Table,
+  Model,
+  ForeignKey,
+  BelongsTo,
+  CreatedAt,
+  UpdatedAt,
+} from 'sequelize-typescript';
+import { RentalPriceModel } from './rental-price.entity';
+import { BookingStatusEnum } from '../enum/booking.enum';
+
+@Table({
+  tableName: 'booking_Booking',
+})
+export class BookingModel extends Model {
+  @Column({
+    primaryKey: true,
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  BookingNo: 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(30),
+  })
+  ItemId: string;
+
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  ItemType: string;
+
+  @ForeignKey(() => RentalPriceModel)
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(30),
+  })
+  PriceId: string;
+
+  @Column({
+    allowNull: false,
+    type: DataType.DATE,
+  })
+  ScheduledStartDateTime: Date;
+
+  @Column({
+    allowNull: false,
+    type: DataType.DATE,
+  })
+  ScheduledEndDateTime: Date;
+
+  @Column({
+    allowNull: true,
+    type: DataType.DECIMAL(10, 2),
+  })
+  BookingFee: number;
+
+  @Column({
+    allowNull: false,
+    type: DataType.STRING(20),
+  })
+  Status: BookingStatusEnum;
+
+  @Column({
+    type: DataType.STRING(3000),
+  })
+  CancelRemarks: string;
+
+  @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(() => RentalPriceModel)
+  RentalPrice: RentalPriceModel;
+}

package/src/models/index.ts

@@ -1,4 +1,5 @@
 import { RentalModel } from './rental.entity';
 import { RentalPriceModel } from './rental-price.entity';
+import { BookingModel } from './booking.entity';
 
-export { RentalModel, RentalPriceModel };
+export { RentalModel, RentalPriceModel, BookingModel };