@eventista/ticketing-common 1.0.0

package/src/schemas/order/order.interfaces.ts

@@ -0,0 +1,78 @@
+
+export enum IPaymentGatewayTypes {
+  FREE = 'free',
+  MOMO = 'momo',
+  ZALOPAY = 'zalopay',
+  ZALOPAY_VIETQR = 'zalopay_vietqr',
+  ZALOPAY_CC = 'zalopay_cc',
+  VNPAY = 'vnpay',
+  INTCARD = 'intcard',
+  PAYPAL = 'paypal',
+  PAYMENTWALL = 'paymentwall',
+  COD = 'cod',
+  MANUALLY = 'manually',
+}
+
+export enum IOrderStatus {
+  PENDING = 'PENDING',
+  REVIEW = 'REVIEW',
+  OPEN = 'OPEN',
+  SUCCESS = 'SUCCESS',
+  FAILED = 'FAILED',
+  CANCELED = 'CANCELED',
+  EXPIRED = 'EXPIRED',
+  CONFIRM = 'CONFIRM',
+  USERCANCEL = 'USERCANCEL',
+  PAYMENT = 'PAYMENT',
+}
+
+export type ProductType = 'event' | 'fanpass' | 'merchandise';
+export type DeliveryStatus = 'pending' | 'delivered' | 'canceled';
+export type CurrencyCode = 'VND' | 'USD';
+
+export interface IOrderProduct {
+  id: string;
+  name: string;
+  price: number;
+  thumbnail: string;
+  promotion: Record<string, any>;
+  quantity: number;
+  totalAmount: number;
+}
+
+export interface IPromotionUsed {
+  code: string;
+  discountPercent: number;
+  maxValue: number;
+}
+
+export interface IOrder {
+  _id?: string;
+  eventId: string;
+  status: IOrderStatus;
+  userId: string;
+  productType: ProductType;
+  paymentGateway?: IPaymentGatewayTypes;
+  tickets: Record<string, any>[];
+  paymentTime?: Date;
+  deliveryStatus?: DeliveryStatus;
+  products: IOrderProduct[];
+  promotionUsed?: IPromotionUsed;
+  currencyCode?: CurrencyCode;
+  originalAmount?: number;
+  originalAmountUSD?: number;
+  amount?: number;
+  amountInUSD?: number;
+  userRefId?: string;
+  confirmAt?: Date;
+  sellFromPlatform?: string;
+  cancelReason?: string;
+  quantity: number;
+  calendarId: string;
+  zoneId?: string;
+  ticketClassId: string;
+  timeCreatePayment?: number;
+  createdAt?: Date;
+  updatedAt?: Date;
+  isDeleted?: boolean;
+}

package/src/schemas/order/order.schema.ts

@@ -0,0 +1,120 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument } from 'mongoose';
+import { BaseDocument, BaseSchema, addSoftDeleteHooks, addUpdateHooks, defaultSchemaOptions } from '../index';
+import { IOrderStatus, IPaymentGatewayTypes, ProductType, DeliveryStatus, CurrencyCode, IPromotionUsed, IOrderProduct } from './order.interfaces';
+
+export type OrderDocument = HydratedDocument<Order> & BaseDocument;
+
+@Schema({
+    collection: 'orders',
+    ...defaultSchemaOptions,
+})
+export class Order extends BaseSchema {
+    @Prop({
+        required: true,
+        index: true,
+    })
+    eventId: string;
+
+    @Prop({
+        required: true,
+        enum: Object.values(IOrderStatus),
+        default: IOrderStatus.PENDING,
+        index: true,
+    })
+    status: IOrderStatus;
+
+    @Prop({ required: true, index: true })
+    userId: string;
+
+    @Prop({
+        required: true,
+        enum: ['event', 'fanpass', 'merchandise'],
+        index: true,
+    })
+    productType: ProductType;
+
+    @Prop({
+        enum: Object.values(IPaymentGatewayTypes),
+        index: true,
+    })
+    paymentGateway: IPaymentGatewayTypes;
+
+    @Prop({ type: [Object], required: true, default: [] })
+    tickets: Record<string, any>[];
+
+    @Prop()
+    paymentTime: Date;
+
+    @Prop({
+        enum: ['pending', 'delivered', 'canceled'],
+        default: 'pending',
+    })
+    deliveryStatus: DeliveryStatus;
+
+    @Prop([
+        {
+            id: String,
+            name: String,
+            price: Number,
+            thumbnail: String,
+            promotion: Object,
+            quantity: Number,
+            totalAmount: Number,
+        },
+    ])
+    products: IOrderProduct[];
+
+    @Prop({
+        type: {
+            code: String,
+            discountPercent: Number,
+            maxValue: Number,
+        },
+        default: {}
+    })
+    promotionUsed: IPromotionUsed;
+
+    @Prop({ enum: ['VND', 'USD'] })
+    currencyCode: CurrencyCode;
+
+    @Prop() originalAmount: number;
+    @Prop() originalAmountUSD: number;
+    @Prop() amount: number;
+    @Prop() amountInUSD: number;
+
+    @Prop() userRefId: string;
+
+    @Prop() confirmAt: Date;
+
+    @Prop({ default: 'web' })
+    sellFromPlatform: string;
+
+    @Prop({ default: '' })
+    cancelReason: string;
+
+    @Prop({ required: true })
+    quantity: number;
+
+    @Prop({ required: true })
+    calendarId: string;
+
+    @Prop() zoneId: string;
+
+    @Prop({ required: true, index: true })
+    ticketClassId: string;
+
+    @Prop()
+    timeCreatePayment: number;
+}
+
+export const OrderSchema = SchemaFactory.createForClass(Order);
+
+// Thêm các hooks và middleware
+addSoftDeleteHooks(OrderSchema);
+addUpdateHooks(OrderSchema);
+
+// Thêm các index nếu cần
+OrderSchema.index({ isDeleted: 1 });
+OrderSchema.index({ userId: 1, status: 1 });
+OrderSchema.index({ eventId: 1, status: 1 });

package/src/schemas/promotions/promotions.interfaces.ts

@@ -0,0 +1,34 @@
+
+export enum IPromotionAppliesTo {
+    EVENT = 'event',
+    TICKET = 'ticket'
+}
+
+export interface IPromotionDiscount {
+    percent: number;
+    percentInUSD: number;
+    maxValue: number;
+    maxValueInUSD: number;
+}
+
+export enum IPromotionType {
+    AUTO = 'auto',
+    MANUALLY = 'manually'
+}
+
+export interface IPromotion {
+    _id?: string;
+    eventId: string;
+    code: string;
+    appliesTo: IPromotionAppliesTo;
+    active: boolean;
+    maxUsage: number;
+    discount: IPromotionDiscount;
+    tickets: Record<string, any>[];
+    type: IPromotionType;
+    minOrderAmount: number;
+    minOrderAmountInUSD: number;
+    createdAt?: Date;
+    updatedAt?: Date;
+    isDeleted?: boolean;
+}

package/src/schemas/promotions/promotions.schema.ts

@@ -0,0 +1,71 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument } from 'mongoose';
+import { BaseDocument, BaseSchema, addSoftDeleteHooks, addUpdateHooks, defaultSchemaOptions } from '../index';
+import { IPromotionAppliesTo, IPromotionDiscount, IPromotionType } from './promotions.interfaces';
+
+export type PromotionDocument = HydratedDocument<Promotion> & BaseDocument;
+@Schema({
+    collection: 'orders',
+    ...defaultSchemaOptions,
+})
+export class Promotion extends BaseSchema {
+
+    @Prop({
+        required: true,
+        index: true,
+    })
+    eventId: string;
+
+    @Prop()
+    code: string;
+
+    @Prop({
+        enum: Object.values(IPromotionAppliesTo),
+        index: true,
+        default: IPromotionAppliesTo.EVENT,
+    })
+    appliesTo: IPromotionAppliesTo;
+
+    @Prop({
+        default: true,
+        type: Boolean,
+    })
+    active: boolean;
+
+    @Prop({
+        type: Number,
+        default: 0,
+    })
+    maxUsage: number;
+
+    @Prop({
+        type: {
+            percent: { type: Number },
+            percentInUSD: { type: Number },
+            maxValue: { type: Number },
+            maxValueInUSD: { type: Number },
+        },
+        default: {},
+    })
+    discount: IPromotionDiscount;
+
+
+    @Prop({ type: [Object], required: true, default: [] })
+    tickets: Record<string, any>[];
+
+    @Prop({
+        enum: Object.values(IPromotionType),
+    })
+    type: IPromotionType;
+
+    @Prop()
+    minOrderAmount: number;
+
+    @Prop()
+    minOrderAmountInUSD: number;
+}
+
+export const PromotionSchema = SchemaFactory.createForClass(Promotion);
+addUpdateHooks(PromotionSchema);
+addSoftDeleteHooks(PromotionSchema);
+PromotionSchema.index({ eventId: 1, code: 1 }, { unique: true });

package/src/schemas/rows/rows.interfaces.ts

@@ -0,0 +1,14 @@
+export interface IRow {
+    _id?: string;
+    calendarId: string;
+    eventId: string;
+    zoneId: string;
+    seatNumberingType: string;
+    seatNumberingFrom: string;
+    seatNumberingTo: string;
+    name: string;
+    position: number;
+    createdAt?: Date;
+    updatedAt?: Date;
+    isDeleted?: boolean;
+} 

package/src/schemas/rows/rows.schema.ts

@@ -0,0 +1,47 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument } from 'mongoose';
+import { BaseDocument, BaseSchema, addSoftDeleteHooks, addUpdateHooks, defaultSchemaOptions } from '../index';
+
+export type RowDocument = HydratedDocument<Row> & BaseDocument;
+
+@Schema({
+    collection: 'rows',
+    ...defaultSchemaOptions,
+})
+export class Row extends BaseSchema {
+    @Prop({})
+    calendarId: string;
+
+    @Prop({
+        required: true,
+        index: true,
+    })
+    eventId: string;
+
+    @Prop({
+        required: true,
+        index: true,
+    })
+    zoneId: string;
+
+    @Prop({})
+    seatNumberingType: string;
+
+    @Prop({})
+    seatNumberingFrom: string;
+
+    @Prop({})
+    seatNumberingTo: string;
+
+    @Prop({})
+    name: string;
+
+    @Prop({})
+    position: number
+}
+
+export const RowSchema = SchemaFactory.createForClass(Row);
+
+// Thêm các hooks và middleware
+addSoftDeleteHooks(RowSchema);
+addUpdateHooks(RowSchema);

package/src/schemas/schema.helper.ts

@@ -0,0 +1,103 @@
+import { Schema, SchemaOptions } from 'mongoose';
+
+export const defaultSchemaOptions: SchemaOptions = {
+  timestamps: { createdAt: 'createdAt', updatedAt: 'updatedAt' },
+  toJSON: {
+    virtuals: true,
+    transform: (_, ret) => {
+      delete ret.__v;
+      return ret;
+    },
+  },
+  toObject: {
+    virtuals: true,
+    transform: (_, ret) => {
+      delete ret.__v;
+      return ret;
+    },
+  },
+};
+
+export const addSoftDeleteHooks = (schema: Schema): void => {
+  // Thêm middleware để không trả về các document đã bị xóa mềm
+  schema.pre('find', function() {
+    if (!this.getQuery().includeDeleted) {
+      this.where({ isDeleted: { $ne: true } });
+    }
+    delete this.getQuery().includeDeleted;
+  });
+
+  schema.pre('findOne', function() {
+    if (!this.getQuery().includeDeleted) {
+      this.where({ isDeleted: { $ne: true } });
+    }
+    delete this.getQuery().includeDeleted;
+  });
+
+  schema.pre('countDocuments', function() {
+    if (!this.getQuery().includeDeleted) {
+      this.where({ isDeleted: { $ne: true } });
+    }
+    delete this.getQuery().includeDeleted;
+  });
+
+  // Thêm method để thực hiện xóa mềm
+  schema.methods.softDelete = async function() {
+    this.isDeleted = true;
+    this.updatedAt = new Date();
+    return this.save();
+  };
+
+  // Thêm method để khôi phục document đã xóa mềm
+  schema.methods.restore = async function() {
+    this.isDeleted = false;
+    return this.save();
+  };
+
+  // Thêm static method để thực hiện xóa mềm nhiều document
+  schema.statics.softDeleteMany = async function(filter = {}) {
+    return this.updateMany(
+      filter,
+      {
+        $set: {
+          isDeleted: true,
+          updatedAt: new Date(),
+        },
+      },
+    );
+  };
+
+  // Thêm static method để khôi phục nhiều document đã xóa mềm
+  schema.statics.restoreMany = async function(filter = {}) {
+    return this.updateMany(
+      filter,
+      {
+        $set: {
+          isDeleted: false,
+        },
+      },
+    );
+  };
+};
+
+export const addUpdateHooks = (schema: Schema): void => {
+  // Cập nhật updatedAt khi document được cập nhật
+  schema.pre('save', function(next) {
+    if (this.isModified()) {
+      this.updatedAt = new Date();
+    }
+    next();
+  });
+
+  schema.pre('updateOne', function() {
+    this.set({ updatedAt: new Date() });
+  });
+
+  schema.pre('updateMany', function() {
+    this.set({ updatedAt: new Date() });
+  });
+
+  schema.pre('findOneAndUpdate', function() {
+    this.set({ updatedAt: new Date() });
+  });
+};

package/src/schemas/ticket-classes/ticket-classes.interfaces.ts

@@ -0,0 +1,18 @@
+export interface ITicketClass {
+    _id?: string;
+    eventId: string;
+    calendarId: string;
+    name: string;
+    color: string;
+    originalPriceVn: number;
+    originalPriceUsd: number;
+    finalPriceVn: number;
+    finalPriceUsd: number;
+    description: string;
+    seatType: string;
+    maxTicketPerUser: number;
+    prototypeUrl: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    isDeleted?: boolean;
+}

package/src/schemas/ticket-classes/ticket-classes.schemas.ts

@@ -0,0 +1,51 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument } from 'mongoose';
+import { BaseDocument, BaseSchema, addSoftDeleteHooks, addUpdateHooks, defaultSchemaOptions } from '../index';
+
+export type TicketClassDocument = HydratedDocument<TicketClass> & BaseDocument;
+
+@Schema({
+    collection: 'ticket_classes',
+    ...defaultSchemaOptions,
+})
+export class TicketClass extends BaseSchema {
+    @Prop({ required: true, index: true })
+    eventId: string;
+
+    @Prop({ required: true, index: true })
+    calendarId: string;
+
+    @Prop({})
+    name: string;
+
+    @Prop({})
+    color: string;
+
+    @Prop({})
+    originalPriceVn: number;
+
+    @Prop({})
+    originalPriceUsd: number;
+
+    @Prop({})
+    finalPriceVn: number;
+
+    @Prop({})
+    finalPriceUsd: number;
+
+    @Prop({})
+    description: string;
+
+    @Prop({})
+    seatType: string;
+
+    @Prop({})
+    maxTicketPerUser: number;
+
+    @Prop({})
+    prototypeUrl: string;
+}
+
+export const TicketClassSchema = SchemaFactory.createForClass(TicketClass);
+addUpdateHooks(TicketClassSchema);
+addSoftDeleteHooks(TicketClassSchema);

package/src/schemas/ticket-summary/ticket-summary.interfaces.ts

@@ -0,0 +1,20 @@
+export enum ITicketSummaryType {
+    ZONE = 'zone',
+    TICKET_CLASS = 'ticketClass',
+}
+
+export interface ITicketSummary {
+    _id?: string;
+    eventId: string;
+    type: ITicketSummaryType;
+    referenceId: string;
+    ticketClassId: string;
+    totalTickets: number;
+    holdTickets: number;
+    soldTickets: number;
+    blockedTickets: number;
+    availableTickets: number;
+    createdAt?: Date;
+    updatedAt?: Date;
+    isDeleted?: boolean;
+}  

package/src/schemas/ticket-summary/ticket-summary.schema.ts

@@ -0,0 +1,46 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument } from 'mongoose';
+import { BaseDocument, BaseSchema, addSoftDeleteHooks, addUpdateHooks, defaultSchemaOptions } from '../index';
+import { ITicketSummaryType } from './ticket-summary.interfaces';
+
+export type TicketSummaryDocument = HydratedDocument<TicketSummary> & BaseDocument;
+
+@Schema({
+    collection: 'ticket_summaries',
+    ...defaultSchemaOptions,
+})
+export class TicketSummary extends BaseSchema {
+
+    @Prop({ required: true, index: true })
+    eventId: string;
+
+    @Prop({ required: true, enum: Object.values(ITicketSummaryType), index: true })
+    type: string;
+
+    @Prop({ required: true, index: true })
+    referenceId: string;
+
+    @Prop({ required: false })
+    ticketClassId: string;
+
+    @Prop({ required: true, default: 0 })
+    totalTickets: number;
+
+    @Prop({ default: 0 })
+    holdTickets: number;
+
+    @Prop({ default: 0 })
+    soldTickets: number;
+
+    @Prop({ default: 0 })
+    blockedTickets: number;
+
+    @Prop({ required: true, default: 0 })
+    availableTickets: number;
+}
+
+export const TicketSummarySchema = SchemaFactory.createForClass(TicketSummary);
+addUpdateHooks(TicketSummarySchema);
+addSoftDeleteHooks(TicketSummarySchema);
+
+TicketSummarySchema.index({ eventId: 1, type: 1, referenceId: 1 }, { unique: true });

package/src/schemas/user-fanpass/user-fanpass.interfaces.ts

@@ -0,0 +1,28 @@
+export enum IUserFanpassStatus {
+    ACTIVE = 'ACTIVE',
+    INACTIVE = 'INACTIVE',
+}
+
+export interface IUserFanpassPaymentInfo{
+    name: string;
+    email: string;
+    phoneNumber: string;
+    address: string;
+}
+
+export interface IUserFanpass {
+    _id?: string;
+    orderId: string;
+    ticketId: string;
+    ticketType: string;
+    ticketDescription: string;
+    ticketPrice: number;
+    userId: string;
+    status: IUserFanpassStatus;
+    paymentTime?: Date;
+    paymentGateway?: string;
+    paymentInfo: IUserFanpassPaymentInfo;
+    createdAt?: Date;
+    updatedAt?: Date;
+    isDeleted?: boolean;
+}