@eventista/ticketing-common 1.0.0

package/src/generic-repository/services/base.service.ts

@@ -0,0 +1,165 @@
+import { Document, FilterQuery, UpdateQuery, QueryOptions, PipelineStage } from 'mongoose';
+import { IBaseRepository } from '../repositories/base.repository.interface';
+import { Logger } from '@nestjs/common';
+import { IBaseService } from './base.service.interface';
+
+export class BaseService<T extends Document> implements IBaseService<T> {
+  protected readonly logger: Logger;
+
+  constructor(
+    protected readonly repository: IBaseRepository<T>,
+    context?: string,
+  ) {
+    this.logger = new Logger(context || this.constructor.name);
+  }
+
+  /**
+   * Tìm một document theo điều kiện
+   */
+  async findOne(
+    filterQuery: FilterQuery<T>,
+    projection?: Record<string, unknown>,
+    options?: QueryOptions,
+  ): Promise<T | null> {
+    return this.repository.findOne(filterQuery, projection, options);
+  }
+
+  /**
+   * Tìm một document theo điều kiện hoặc throw exception nếu không tìm thấy
+   */
+  async findOneOrFail(
+    filterQuery: FilterQuery<T>,
+    projection?: Record<string, unknown>,
+    options?: QueryOptions,
+  ): Promise<T> {
+    return this.repository.findOneOrFail(filterQuery, projection, options);
+  }
+
+  /**
+   * Tìm nhiều documents theo điều kiện
+   */
+  async find(
+    filterQuery: FilterQuery<T>,
+    projection?: Record<string, unknown>,
+    options?: QueryOptions,
+  ): Promise<T[]> {
+    return this.repository.find(filterQuery, projection, options);
+  }
+
+  /**
+   * Tạo một document mới
+   */
+  async create(createDto: Partial<T>): Promise<T> {
+    return this.repository.create(createDto);
+  }
+
+  /**
+   * Tạo nhiều documents
+   */
+  async createMany(createDtos: Partial<T>[]): Promise<T[]> {
+    return this.repository.createMany(createDtos);
+  }
+
+  /**
+   * Cập nhật một document theo điều kiện
+   */
+  async update(
+    filterQuery: FilterQuery<T>,
+    updateQuery: UpdateQuery<T>,
+    options: QueryOptions = { new: true },
+  ): Promise<T | null> {
+    return this.repository.findOneAndUpdate(filterQuery, updateQuery, options);
+  }
+
+  /**
+   * Cập nhật một document theo điều kiện hoặc throw exception nếu không tìm thấy
+   */
+  async updateOrFail(
+    filterQuery: FilterQuery<T>,
+    updateQuery: UpdateQuery<T>,
+    options: QueryOptions = { new: true },
+  ): Promise<T> {
+    return this.repository.findOneAndUpdateOrFail(filterQuery, updateQuery, options);
+  }
+
+  /**
+   * Cập nhật nhiều documents theo điều kiện
+   */
+  async updateMany(
+    filterQuery: FilterQuery<T>,
+    updateQuery: UpdateQuery<T>,
+  ): Promise<{ matchedCount: number; modifiedCount: number }> {
+    return this.repository.updateMany(filterQuery, updateQuery);
+  }
+
+  /**
+   * Xóa một document theo điều kiện
+   */
+  async delete(
+    filterQuery: FilterQuery<T>,
+    options?: QueryOptions,
+  ): Promise<T | null> {
+    return this.repository.findOneAndDelete(filterQuery, options);
+  }
+
+  /**
+   * Xóa một document theo điều kiện hoặc throw exception nếu không tìm thấy
+   */
+  async deleteOrFail(
+    filterQuery: FilterQuery<T>,
+    options?: QueryOptions,
+  ): Promise<T> {
+    return this.repository.findOneAndDeleteOrFail(filterQuery, options);
+  }
+
+  /**
+   * Xóa nhiều documents theo điều kiện
+   */
+  async deleteMany(filterQuery: FilterQuery<T>): Promise<{ deletedCount: number }> {
+    return this.repository.deleteMany(filterQuery);
+  }
+
+  /**
+   * Đếm số lượng documents theo điều kiện
+   */
+  async count(filterQuery: FilterQuery<T>): Promise<number> {
+    return this.repository.count(filterQuery);
+  }
+
+  /**
+   * Kiểm tra document có tồn tại không
+   */
+  async exists(filterQuery: FilterQuery<T>): Promise<boolean> {
+    return this.repository.exists(filterQuery);
+  }
+
+  /**
+   * Thực hiện aggregation pipeline
+   */
+  async aggregate(pipeline: PipelineStage[]): Promise<any[]> {
+    return this.repository.aggregate(pipeline);
+  }
+
+  /**
+   * Phân trang
+   */
+  async paginate(
+    filterQuery: FilterQuery<T>,
+    options: {
+      page?: number;
+      limit?: number;
+      sort?: Record<string, 1 | -1>;
+      projection?: Record<string, unknown>;
+    } = {},
+  ): Promise<{
+    data: T[];
+    pagination: {
+      total: number;
+      page: number;
+      limit: number;
+      pages: number;
+    };
+  }> {
+    return this.repository.paginate(filterQuery, options);
+  }
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+
+export * from './database';
+export * from './exception/exception.filter';
+export * from './generic-repository';
+
+export * from './logger';
+
+export * from './pipes/custom-validation.pipe';
+export * from './response/response.interceptor'
+
+export * from './schemas';

package/src/logger/custom.logger.ts

@@ -0,0 +1,83 @@
+import { LoggerService } from '@nestjs/common';
+import { blue, cyan, gray, green, red, yellow } from 'colorette';
+
+export class CustomLogger implements LoggerService {
+  private readonly isProduction: boolean;
+
+  constructor(private readonly context?: string) {
+    this.isProduction = process.env.NODE_ENV === 'production';
+  }
+
+
+  private getTimestamp(): string {
+    const localeStringOptions = {
+      year: 'numeric',
+      hour: 'numeric',
+      minute: 'numeric',
+      second: 'numeric',
+      day: '2-digit',
+      month: '2-digit',
+    };
+    return new Date().toLocaleString(undefined, localeStringOptions as Intl.DateTimeFormatOptions);
+  }
+
+  private formatMessage(level: string, message: string, context?: string): string {
+    if (this.isProduction) {
+      return JSON.stringify({
+        timestamp: this.getTimestamp(),
+        pid: process.pid,
+        level,
+        context: context || this.context,
+        message
+      });
+    }
+
+    const timestamp = gray(`[Nest] ${process.pid}  - ${this.getTimestamp()}`);
+    const formattedLevel = this.colorize(level);
+    const contextStr = yellow(`[${context || this.context}] `);
+    return `${timestamp}   ${formattedLevel} ${contextStr}${message}`;
+  }
+
+  private colorize(level: string): string {
+    switch (level) {
+      case 'LOG':
+        return green(`${level} `);
+      case 'ERROR':
+        return red(`${level}`);
+      case 'WARN':
+        return yellow(`${level} `);
+      case 'DEBUG':
+        return blue(`${level}`);
+      case 'VERBOSE':
+        return cyan(`${level}`);
+      default:
+        return level;
+    }
+  }
+
+  log(message: string, context?: string) {
+    console.log(this.formatMessage('LOG', message, context));
+  }
+
+  error(message: string, metadata?: any) {
+    const baseLog = this.formatMessage('ERROR', message);
+    if (metadata) {
+      console.error(baseLog);
+      console.error(red('Details:'), metadata);
+    } else {
+      console.error(baseLog);
+    }
+  }
+
+  warn(message: string, context?: string) {
+    console.warn(this.formatMessage('WARN', message, context));
+  }
+
+  debug(message: string, context?: string) {
+    console.debug(this.formatMessage('DEBUG', message, context));
+  }
+
+  verbose(message: string, context?: string) {
+    console.log(this.formatMessage('VERBOSE', message, context));
+  }
+}

package/src/logger/index.ts

@@ -0,0 +1,2 @@
+export * from './logger.module';
+export * from './custom.logger';

package/src/logger/logger.module.ts

@@ -0,0 +1,14 @@
+import { Global, Module } from '@nestjs/common';
+import { CustomLogger } from './custom.logger';
+
+@Global()
+@Module({
+  providers: [
+    {
+      provide: 'Logger',
+      useValue: new CustomLogger(), // Initialize with no context
+    },
+  ],
+  exports: ['Logger'],
+})
+export class LoggerModule {}

package/src/pipes/custom-validation.pipe.ts

@@ -0,0 +1,61 @@
+import {
+  ArgumentMetadata,
+  BadRequestException,
+  Injectable,
+  ValidationPipe,
+  ValidationPipeOptions,
+} from '@nestjs/common';
+
+@Injectable()
+export class CustomValidationPipe extends ValidationPipe {
+  constructor(options?: ValidationPipeOptions) {
+    super({
+      whitelist: true, // Loại bỏ các trường không có trong DTO
+      transform: true, // Tự động chuyển đổi dữ liệu đầu vào thành class instance của DTO
+      ...options, // Cho phép truyền thêm tùy chọn nếu cần
+    });
+  }
+  public async transform(value, metadata: ArgumentMetadata) {
+    try {
+      return await super.transform(value, metadata);
+    } catch (e) {
+      if (e instanceof BadRequestException) {
+        const errors: any = [];
+        for (const err of e.getResponse()['message']) {
+          errors.push({
+            field: err.property,
+            constraints: this.getConstraints(err),
+          });
+        }
+
+        throw new BadRequestException({
+          errorCode: 400,
+          message: 'Validation failed',
+          errors,
+        });
+      }
+    }
+  }
+
+  getConstraints(err) {
+    if (typeof err == 'string') {
+      return err;
+    }
+    if (typeof err == 'object' && err.constraints) {
+      return err.constraints;
+    }
+    return this.deepReduce(err.children);
+  }
+
+  deepReduce(array) {
+    return array.reduce((accumulator, currentValue) => {
+      if (currentValue.children && currentValue.children.length > 0) {
+        return this.deepReduce(currentValue.children);
+      }
+      if (currentValue.constraints) {
+        return currentValue.constraints;
+      }
+      return accumulator;
+    }, {});
+  }
+}

package/src/response/response.interceptor.ts

@@ -0,0 +1,26 @@
+import {
+  CallHandler,
+  ExecutionContext,
+  Injectable,
+  NestInterceptor,
+} from '@nestjs/common';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+
+@Injectable()
+export class ResponseInterceptor implements NestInterceptor {
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    // Chỉ áp dụng cho HTTP hoặc HTTPS requests
+    if (context.getType() !== 'http') {
+      return next.handle();
+    }
+    return next.handle().pipe(
+      map((data) => ({
+        errorCode: 0,
+        message: 'Success',
+        data,
+        timestamp: new Date().toISOString(),
+      })),
+    );
+  }
+}

package/src/schemas/base.schema.ts

@@ -0,0 +1,19 @@
+import { Prop, Schema } from '@nestjs/mongoose';
+import { Document } from 'mongoose';
+
+export interface BaseDocument extends Document {
+  createdAt: Date;
+  updatedAt: Date;
+  isDeleted: boolean;
+}
+
+export class BaseSchema {
+  @Prop({ type: Date, default: Date.now })
+  createdAt: Date;
+
+  @Prop({ type: Date, default: Date.now })
+  updatedAt: Date;
+
+  @Prop({ type: Boolean, default: false })
+  isDeleted: boolean;
+}

package/src/schemas/event/event.interfaces.ts

@@ -0,0 +1,74 @@
+
+export enum IStatusEvent {
+  OPEN = 'OPEN',
+  CLOSE = 'CLOSE',
+}
+
+export interface IPaymentInfoField {
+  key: string;
+  text: string;
+  type?: string;
+  isDefault?: boolean;
+  isRequired?: boolean;
+}
+
+export interface IGeneral {
+  collaboration?: 'eventista' | 'agency' | 'seatmap' | 'seatmap_zone';
+  ticketType?: 'e_ticket' | 'hard_ticket';
+  paymentInfoFields?: IPaymentInfoField[];
+}
+
+export interface IVisitor {
+  name?: string;
+  picture?: string;
+  id?: string;
+}
+
+export type Category = 'concert' | 'live_show' | 'workshop' | 'fan_meeting';
+
+export interface IEventCalendar {
+  calendarId: string;
+  startDate: Date;
+  endDate: Date;
+  maxTicketPerUser?: number;
+}
+
+export interface ITicketCalendar {
+  thumbnail?: string;
+  description?: string;
+}
+
+export interface IEvent {
+  _id?: string;
+  eventName: string;
+  location: string;
+  address: string;
+  pathName: string;
+  thumbnail?: string;
+  logo?: string;
+  venueMap?: string;
+  status?: IStatusEvent;
+  eventCalendar: IEventCalendar[];
+  ticketCalendar?: ITicketCalendar;
+  hostedBy?: string;
+  tickets: Record<string, any>[];
+  eventDescriptions?: { title: string; description: string }[];
+  maxTicketPerUser: number;
+  note: string;
+  general?: IGeneral;
+  domain: string;
+  categories?: Category[];
+  featuredFlg?: boolean;
+  hideInMarketPlace?: boolean;
+  tenantId?: string;
+  visitors?: IVisitor[];
+  background?: string;
+  headingBackground?: string;
+  fanpassId?: string;
+  discountForFanpassUser?: boolean;
+  type?: string;
+  authRequired?: boolean;
+  createdAt?: Date;
+  updatedAt?: Date;
+  isDeleted?: boolean;
+}

package/src/schemas/event/event.schema.ts

@@ -0,0 +1,195 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument } from 'mongoose';
+import { BaseDocument, BaseSchema, addSoftDeleteHooks, addUpdateHooks, defaultSchemaOptions } from '../index';
+import { IStatusEvent } from './event.interfaces';
+
+export type EventDocument = HydratedDocument<Event> & BaseDocument;
+
+
+@Schema({ _id: false })
+export class SchemaPaymentInfoField {
+    @Prop({ required: true })
+    key: string;
+
+    @Prop({ required: true })
+    text: string;
+
+    @Prop({ default: 'text' })
+    type: string;
+
+    @Prop({ default: false })
+    isDefault: boolean;
+
+    @Prop({ default: false })
+    isRequired: boolean;
+}
+
+@Schema({ _id: false })
+export class SchemaGeneral {
+    @Prop({ enum: ['eventista', 'agency', 'seatmap', 'seatmap_zone'], default: 'eventista' })
+    collaboration: string;
+
+    @Prop({ enum: ['e_ticket', 'hard_ticket'], default: 'hard_ticket' })
+    ticketType: string;
+
+    @Prop({ type: [SchemaPaymentInfoField], default: [] })
+    paymentInfoFields: SchemaPaymentInfoField[];
+}
+
+@Schema({ _id: false }) // Nếu bạn không cần _id riêng cho mỗi visitor
+export class SchemaVisitor {
+    @Prop() name: string;
+    @Prop() picture: string;
+    @Prop() id: string;
+}
+
+
+@Schema({
+    collection: 'events',
+    ...defaultSchemaOptions,
+})
+export class Event extends BaseSchema {
+    @Prop({ required: true })
+    eventName: string;
+
+    @Prop({ required: true })
+    location: String;
+
+    @Prop({ required: true })
+    address: string;
+
+    @Prop({ required: true })
+    pathName: string;
+
+    @Prop({ required: false })
+    thumbnail: string;
+
+    @Prop({ required: false })
+    logo: string;
+
+    @Prop({ required: false })
+    venueMap: string;
+
+    @Prop({ enum: Object.values(IStatusEvent), default: "OPEN" })
+    status: string;
+
+    @Prop({
+        type: [
+            {
+                calendarId: { type: String, required: true },
+                startDate: { type: Date, required: true },
+                endDate: { type: Date, required: true },
+                maxTicketPerUser: { type: Number, default: -1 },
+            },
+        ],
+        required: true,
+        default: [],
+    })
+    eventCalendar: {
+        calendarId: String;
+        startDate: Date;
+        endDate: Date;
+        maxTicketPerUser: number;
+    }[];
+
+    @Prop({
+        type: {
+            thumbnail: { type: String, required: false },
+            description: { type: String, required: false },
+        },
+        required: false,
+        default: {},
+    })
+    ticketCalendar: {
+        thumbnail: String;
+        description: String;
+    };
+
+    @Prop({})
+    hostedBy: String
+
+    // check lại  nếu bị lỗi khi tạo event
+    @Prop({ type: [Object], required: true, default: [] }) // Mảng các object không xác định cấu trúc
+    tickets: Record<string, any>[];
+
+    @Prop({
+        type: [
+            {
+                title: { type: String },
+                description: { type: String },
+            },
+        ],
+        required: false,
+        default: []
+    })
+    eventDescriptions: { title: string; description: string }[];
+
+    @Prop({
+        type: Number,
+        required: true,
+        default: 0,
+    })
+    maxTicketPerUser: number;
+
+    @Prop({ type: String, required: true })
+    note: string;
+
+    @Prop({ type: SchemaGeneral, default: {} })
+    general: SchemaGeneral;
+
+    @Prop({ type: String, required: true })
+    domain: string;
+
+    @Prop({
+        type: [String],
+        enum: ['concert', 'live_show', 'workshop', 'fan_meeting'],
+        default: [],
+    })
+    categories: ('concert' | 'live_show' | 'workshop' | 'fan_meeting')[];
+
+    @Prop({ type: Boolean, default: false })
+    featuredFlg: boolean;
+
+    @Prop({ type: Boolean, default: false })
+    hideInMarketPlace: boolean;
+
+    @Prop({ type: String, required: false })
+    tenantId: string;
+
+    @Prop({ type: [SchemaVisitor], default: [] })
+    visitors: SchemaVisitor[];
+
+    @Prop({ type: String, required: false })
+    background: string;
+
+    @Prop({ type: String, required: false })
+    headingBackground: string;
+
+    @Prop({ type: String, required: false })
+    fanpassId: string;
+
+    @Prop({ type: Boolean, default: false })
+    discountForFanpassUser: boolean;
+
+    @Prop({ type: String, required: false })
+    type: string;
+
+    @Prop({ type: Boolean, default: false })
+    authRequired: boolean;
+}
+
+
+
+export const EventSchema = SchemaFactory.createForClass(Event);
+
+// Thêm các hooks và middleware
+addSoftDeleteHooks(EventSchema);
+addUpdateHooks(EventSchema);
+
+//Thêm các index
+EventSchema.index({ isDeleted: 1 });
+EventSchema.index({ eventName: 1 });
+EventSchema.index({ pathName: 1 });
+EventSchema.index({ status: 1 });
+EventSchema.index({ tenantId: 1 });
+

package/src/schemas/index.ts

@@ -0,0 +1,16 @@
+export * from './base.schema';
+export * from './schema.helper';
+export * from './ticket-summary/ticket-summary.interfaces';
+export * from './ticket-summary/ticket-summary.schema';
+export * from './ticket-classes/ticket-classes.interfaces';
+export * from './ticket-classes/ticket-classes.schemas';
+export * from './rows/rows.interfaces';
+export * from './rows/rows.schema';
+export * from './order/order.interfaces';
+export * from './order/order.schema';
+export * from './event/event.interfaces';
+export * from './event/event.schema';
+export * from './user-fanpass/user-fanpass.interfaces';
+export * from './user-fanpass/user-fanpass.schemas';
+
+