feat: update order

backend/src/common/interfaces/jwt-payload.interface.ts

@@ -0,0 +1,5 @@
+interface JwtPayload {
+  sub: string; // id người dùng
+  roles: string; // quyền người dùng
+  username: string;
+}

backend/src/entities/order.entity.ts

@@ -2,6 +2,7 @@ import {
   BaseEntity,
   Column,
   CreateDateColumn,
+  DeleteDateColumn,
   Entity,
   JoinColumn,
   ManyToOne,
@@ -9,6 +10,7 @@ import {
   OneToOne,
   PrimaryGeneratedColumn,
   Relation,
+  UpdateDateColumn,
 } from 'typeorm';
 import { BranchEntity } from './branch.entity.js';
 import { UserEntity } from './user.entity.js';
@@ -55,9 +57,6 @@ export class OrderEntity extends BaseEntity {
   @Column()
   total_value: number;
 
-  @CreateDateColumn()
-  create_at: Date;
-
   @Column({ default: 0 })
   order_type: number;
 
@@ -73,4 +72,13 @@ export class OrderEntity extends BaseEntity {
   @OneToOne(() => PaymentEntity, (a) => a.order)
   @JoinColumn({ name: 'payment_id' })
   payment: Relation<PaymentEntity>;
+
+  @CreateDateColumn()
+  created_at: Date;
+
+  @UpdateDateColumn()
+  updated_at: Date;
+
+  @DeleteDateColumn()
+  deleted_at: Date;
 }

backend/src/migrations/1730895089788-UpdateOrderFieldTime.ts

@@ -0,0 +1,25 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class UpdateOrderFieldTime1730895089788 implements MigrationInterface {
+  name = 'UpdateOrderFieldTime1730895089788';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "orders" DROP COLUMN "create_at"`);
+    await queryRunner.query(
+      `ALTER TABLE "orders" ADD "created_at" TIMESTAMP NOT NULL DEFAULT now()`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "orders" ADD "updated_at" TIMESTAMP NOT NULL DEFAULT now()`,
+    );
+    await queryRunner.query(`ALTER TABLE "orders" ADD "deleted_at" TIMESTAMP`);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "orders" ADD "create_at" TIMESTAMP NOT NULL DEFAULT now()`,
+    );
+    await queryRunner.query(`ALTER TABLE "orders" DROP COLUMN "deleted_at"`);
+    await queryRunner.query(`ALTER TABLE "orders" DROP COLUMN "updated_at"`);
+    await queryRunner.query(`ALTER TABLE "orders" DROP COLUMN "created_at"`);
+  }
+}

backend/src/modules/order/dto/create-order.dto.ts

@@ -16,6 +16,10 @@ export class CreateOrderDto {
   @IsNumber()
   table_number?: number;
 
+  @IsOptional()
+  @IsString()
+  note?: string;
+
   @IsNumber()
   order_type: number;
 

backend/src/modules/order/dto/update-order.dto.ts

@@ -0,0 +1,14 @@
+import { IsArray, IsNumber, IsOptional, ValidateNested } from 'class-validator';
+import { OrderItemsDto } from './order-items.dto.js';
+import { Type } from 'class-transformer';
+
+export class UpdateOrderDto {
+  @IsOptional()
+  @IsNumber()
+  table_number?: number;
+
+  @IsArray()
+  @ValidateNested()
+  @Type(() => OrderItemsDto)
+  order_items: OrderItemsDto[];
+}

backend/src/modules/order/order.controller.ts

@@ -11,9 +11,12 @@ import {
 import { OrderService } from './order.service.js';
 import { CreateOrderDto } from './dto/create-order.dto.js';
 import { Role } from '../../common/enums/role.enum.js';
+import { paginate, Paginate, PaginateQuery } from 'nestjs-paginate';
+import { Roles } from '../authentication/authorization/roles.decorator.js';
+import { UpdateOrderDto } from './dto/update-order.dto.js';
 
 @Controller('branchs/:branchId/orders')
-export class OrderController {
+export class BranchOrderController {
   constructor(private readonly orderService: OrderService) {}
 
   @Post()
@@ -25,13 +28,14 @@ export class OrderController {
     const userId = req['user'].sub;
     const role = req['user'].roles;
     console.log(req['user']);
-    if (role == Role.CUSTOMER)
+    if (role === Role.CUSTOMER) {
+      console.log('customer');
       return this.orderService.createFromCustomer(
         branchId,
         userId,
         createOrderDto,
       );
-    else
+    } else
       return this.orderService.createFromStaff(
         branchId,
         userId,
@@ -39,30 +43,50 @@ export class OrderController {
       );
   }
 
-  @Get()
-  async findAll(@Req() req: Request) {
-    // order  history of user.
-    // if customer, view history.
+  @Get('history')
+  async findHistory(
+    @Req() req: Request,
+    @Param('branchId') branchId: string,
+    @Paginate() paginateQuery: PaginateQuery,
+  ) {
+    // order history of user.
     const userId = req['user'].sub;
     console.log(req['user']);
-    return this.orderService.findAll();
+    return this.orderService.findHistory(paginateQuery, userId, branchId);
   }
 
   @Get(':id')
   async findOne(@Param('id') id: string) {
     return this.orderService.findOne(+id);
   }
-
-  // @Patch(':id')
-  // async update(
-  //   @Param('id') id: string,
-  //   @Body() updateOrderDto: UpdateOrderDto,
-  // ) {
-  //   return this.orderService.update(+id, updateOrderDto);
-  // }
+  @Patch(':id')
+  update(@Param('id') id: string, @Body() updateOrderDto: UpdateOrderDto) {
+    return this.orderService.updateOrder(+id, updateOrderDto);
+  }
 
   @Delete(':id')
   remove(@Param('id') id: string) {
     return this.orderService.remove(+id);
   }
 }
+
+@Roles(Role.ADMIN, Role.STAFF, Role.BRANCH_MANAGER, Role.SHIPPER)
+@Controller('orders')
+export class OrderController {
+  constructor(private readonly orderService: OrderService) {}
+
+  @Get()
+  async findAll(@Paginate() paginateQuery: PaginateQuery) {
+    return this.orderService.findAll(paginateQuery);
+  }
+
+  @Get(':id')
+  async findOne(@Param('id') id: string) {
+    return this.orderService.findOne(+id);
+  }
+
+  @Patch(':id')
+  update(@Param('id') id: string, @Body() updateOrderDto: UpdateOrderDto) {
+    return this.orderService.updateOrder(+id, updateOrderDto);
+  }
+}

backend/src/modules/order/order.module.ts

@@ -1,12 +1,12 @@
 import { Module } from '@nestjs/common';
 import { OrderService } from './order.service.js';
-import { OrderController } from './order.controller.js';
+import { BranchOrderController, OrderController } from './order.controller.js';
 import { BranchModule } from '../branch/branch.module.js';
 import { BranchMenusModule } from '../branch-menus/branch-menus.module.js';
 
 @Module({
   imports: [BranchModule, BranchMenusModule],
-  controllers: [OrderController],
+  controllers: [BranchOrderController, OrderController],
   providers: [OrderService],
   exports: [OrderService],
 })

backend/src/modules/order/order.service.ts

@@ -12,10 +12,21 @@ import { isUUID } from 'class-validator';
 import { OrderItemEntity } from '../../entities/order-item.entity.js';
 import { BranchMenuEntity } from '../../entities/branch-menu.entity.js';
 import { OrderStatus } from '../../common/enums/OrderStatus.enum.js';
+import {
+  FilterOperator,
+  paginate,
+  PaginateConfig,
+  PaginateQuery,
+} from 'nestjs-paginate';
+import { UpdateOrderDto } from './dto/update-order.dto.js';
+import { DataSource } from 'typeorm';
 
 @Injectable()
 export class OrderService {
-  constructor(private readonly branchService: BranchService) {}
+  constructor(
+    private readonly branchService: BranchService,
+    private readonly datasource: DataSource,
+  ) {}
   async createFromCustomer(
     branchId: string,
     userId: string,
@@ -34,44 +45,60 @@ export class OrderService {
     if (!branch) {
       throw new BadRequestException('Branch not found');
     }
-    const order = OrderEntity.create();
-    order.branch = branch;
-    order.customer = user;
-    order.order_type = createOrderDto.order_type;
-    order.order_status = OrderStatus.PENDING;
-    order.total_value = 0;
-    await order.save();
+    const queryRunner = this.datasource.createQueryRunner();
 
-    let orderItems: OrderItemEntity[] = [];
-    let totalValue = 0;
-    for (const item of createOrderDto.order_items) {
-      let branchMenu: BranchMenuEntity;
-      if (!isUUID(item.menu_id)) {
-        branchMenu = await BranchMenuEntity.findOne({
-          where: { branch_id: branchId, menu_id: item.menu_id },
-          relations: ['menu_item'],
-        });
-      } else {
-        branchMenu = await BranchMenuEntity.findOne({
-          where: { branch_id: branchId, id: item.menu_id },
-          relations: ['menu_item'],
-        });
-      }
-      if (!branchMenu) {
-        throw new BadRequestException('Item not found in branch menu');
+    // Start a new transaction
+    await queryRunner.connect();
+    await queryRunner.startTransaction();
+
+    try {
+      console.log('Customer create order');
+      const order = OrderEntity.create();
+      order.branch = branch;
+      order.customer = user;
+      order.order_type = createOrderDto.order_type;
+      order.order_status = OrderStatus.PENDING;
+      order.total_value = 0;
+      await queryRunner.manager.save(order);
+
+      let orderItems: OrderItemEntity[] = [];
+      let totalValue = 0;
+      for (const item of createOrderDto.order_items) {
+        let branchMenu: BranchMenuEntity;
+        if (!isUUID(item.menu_id)) {
+          branchMenu = await BranchMenuEntity.findOne({
+            where: { branch_id: branchId, menu_id: item.menu_id },
+            relations: ['menu_item'],
+          });
+        } else {
+          branchMenu = await BranchMenuEntity.findOne({
+            where: { branch_id: branchId, id: item.menu_id },
+            relations: ['menu_item'],
+          });
+        }
+        if (!branchMenu) {
+          throw new BadRequestException('Item not found in branch menu');
+        }
+        const orderItem = OrderItemEntity.create();
+        orderItem.branch_menu = branchMenu;
+        orderItem.price = branchMenu.menu_item.price;
+        orderItem.quantity = item.quantity;
+        orderItem.order_id = order.id;
+        totalValue += orderItem.price * orderItem.quantity;
+        orderItems.push(orderItem);
       }
-      const orderItem = OrderItemEntity.create();
-      orderItem.branch_menu = branchMenu;
-      orderItem.price = branchMenu.menu_item.price;
-      orderItem.quantity = item.quantity;
-      orderItem.order_id = order.id;
-      totalValue += orderItem.price * orderItem.quantity;
-      orderItems.push(orderItem);
+      await queryRunner.manager.save(order);
+      order.total_value = totalValue;
+      await queryRunner.manager.save(orderItems);
+
+      await queryRunner.commitTransaction();
+      await queryRunner.release();
+      return { ...order, order_items: orderItems };
+    } catch (err) {
+      await queryRunner.rollbackTransaction();
+      await queryRunner.release();
+      throw err;
     }
-    await order.save();
-    order.total_value = totalValue;
-    await OrderItemEntity.save(orderItems);
-    return { ...order, order_items: orderItems };
   }
 
   async createFromStaff(
@@ -93,38 +120,55 @@ export class OrderService {
     order.table_number = createOrderDto.table_number;
     order.order_status = OrderStatus.PREPARING;
     order.total_value = 0;
-    await order.save();
 
-    let orderItems: OrderItemEntity[] = [];
-    let totalValue = 0;
-    for (const item of createOrderDto.order_items) {
-      let branchMenu: BranchMenuEntity;
-      if (!isUUID(item.menu_id)) {
-        branchMenu = await BranchMenuEntity.findOne({
-          where: { branch_id: branchId, menu_id: item.menu_id },
-          relations: ['menu_item'],
-        });
-      } else {
-        branchMenu = await BranchMenuEntity.findOne({
-          where: { branch_id: branchId, id: item.menu_id },
-          relations: ['menu_item'],
-        });
-      }
-      if (!branchMenu) {
-        throw new BadRequestException('Item not found in branch menu');
+    const queryRunner = this.datasource.createQueryRunner();
+
+    // Start a new transaction
+    await queryRunner.connect();
+    await queryRunner.startTransaction();
+
+    try {
+      await queryRunner.manager.save(order);
+
+      let orderItems: OrderItemEntity[] = [];
+      let totalValue = 0;
+      for (const item of createOrderDto.order_items) {
+        let branchMenu: BranchMenuEntity;
+        if (!isUUID(item.menu_id)) {
+          branchMenu = await BranchMenuEntity.findOne({
+            where: { branch_id: branchId, menu_id: item.menu_id },
+            relations: ['menu_item'],
+          });
+        } else {
+          branchMenu = await BranchMenuEntity.findOne({
+            where: { branch_id: branchId, id: item.menu_id },
+            relations: ['menu_item'],
+          });
+        }
+        if (!branchMenu) {
+          throw new BadRequestException('Item not found in branch menu');
+        }
+        const orderItem = OrderItemEntity.create();
+        orderItem.branch_menu = branchMenu;
+        orderItem.price = branchMenu.menu_item.price;
+        orderItem.quantity = item.quantity;
+        orderItem.order_id = order.id;
+        totalValue += orderItem.price * orderItem.quantity;
+        orderItems.push(orderItem);
       }
-      const orderItem = OrderItemEntity.create();
-      orderItem.branch_menu = branchMenu;
-      orderItem.price = branchMenu.menu_item.price;
-      orderItem.quantity = item.quantity;
-      orderItem.order_id = order.id;
-      totalValue += orderItem.price * orderItem.quantity;
-      orderItems.push(orderItem);
+      await queryRunner.manager.save(order);
+      order.total_value = totalValue;
+      await queryRunner.manager.save(orderItems);
+
+      await queryRunner.commitTransaction();
+      await queryRunner.release();
+
+      return { ...order, order_items: orderItems };
+    } catch (err) {
+      await queryRunner.rollbackTransaction();
+      await queryRunner.release();
+      throw err;
     }
-    await order.save();
-    order.total_value = totalValue;
-    await OrderItemEntity.save(orderItems);
-    return { ...order, order_items: orderItems };
   }
 
   /**
@@ -133,7 +177,11 @@ export class OrderService {
   async findOrderOrError(id: number) {
     const order = await OrderEntity.findOne({
       where: { id },
-      relations: ['menu_item'],
+      relations: [
+        'order_items',
+        'order_items.branch_menu',
+        'order_items.branch_menu.menu_item',
+      ],
     });
     if (!order) {
       throw new NotFoundException('Order id not found');
@@ -141,33 +189,81 @@ export class OrderService {
     return order;
   }
 
-  /**
-   * Xem cụ thể OrderStatus để biết trạng thái,
-   */
-  async updateOrderStatus(id: number, status: OrderStatus) {
-    // cập nhật trạng thái paid
+  async updateOrder(id: number, updateOrderDto: UpdateOrderDto) {
+    // update vì
+    // Offline
+    // Người dùng chuyển bàn
+    // Người dùng thêm/xoá món
+    // Cập nhật trạng thái
+    // Cập nhật rating
+    // Cập nhật note
+  }
+
+  async updateOrderPayment(id: number, paymentId: number) {
     const order = await this.findOrderOrError(id);
-    order.order_status = status;
+    order.payment_id = paymentId; // i'm trust that paymentId existed.
+    order.order_status = OrderStatus.ONLINE_PAID;
     await order.save();
   }
 
-  /**
-   * Lấy danh sách order theo
-   * - Chi nhánh
-   * - Nhân viên duyệt
-   * - Trạng thái
-   * 
-   */
-  findAll() {
+  getOrderPaginteConfig() {
+    const paginateConfig: PaginateConfig<OrderEntity> = {
+      sortableColumns: ['id', 'created_at', 'total_value'],
+      filterableColumns: {
+        order_status: [FilterOperator.EQ],
+        create_at: [FilterOperator.GTE, FilterOperator.LTE],
+        updated_at: [FilterOperator.GTE, FilterOperator.LTE],
+        customer_id: [FilterOperator.EQ],
+        branch_id: [FilterOperator.EQ],
+        staff_id: [FilterOperator.EQ],
+        table_number: [FilterOperator.EQ],
+        rating: [FilterOperator.EQ, FilterOperator.GTE, FilterOperator.LTE],
+        total_value: [
+          FilterOperator.EQ,
+          FilterOperator.GTE,
+          FilterOperator.LTE,
+        ],
+      },
+      defaultSortBy: [['id', 'DESC']],
+    };
+    return paginateConfig;
+  }
+
+  getOrderQueryBuilder(branchId?: string) {
     //
-    return `This action returns all order`;
+    let queryBuilder = OrderEntity.createQueryBuilder('od')
+      .leftJoinAndSelect('od.order_items', 'order_items')
+      .leftJoinAndSelect('order_items.branch_menu', 'branch_menu')
+      .leftJoinAndSelect('branch_menu.menu_item', 'menu_item');
+    if (branchId) {
+      queryBuilder.andWhere('od.branch_id = :branchId', { branchId });
+    }
+    // console.log(queryBuilder.getQuery());
+    return queryBuilder;
+  }
+
+  async findAll(query: PaginateQuery, branchId?: string) {
+    const paginateConfig = this.getOrderPaginteConfig();
+    let queryBuilder = this.getOrderQueryBuilder(branchId);
+    if (branchId) {
+      queryBuilder.andWhere('od.branch_id = :branchId', { branchId });
+    }
+    return paginate(query, queryBuilder, paginateConfig);
+  }
+
+  async findHistory(query: PaginateQuery, userId: string, branchId?: string) {
+    const paginateConfig = this.getOrderPaginteConfig();
+    let queryBuilder = this.getOrderQueryBuilder(branchId);
+    queryBuilder.andWhere('od.customer_id = :userId', { userId });
+    return paginate(query, queryBuilder, paginateConfig);
   }
 
-  findOne(id: number) {
-    return `This action returns a #${id} order`;
+  async findOne(id: number) {
+    return this.findOrderOrError(id);
   }
 
-  remove(id: number) {
-    return `This action removes a #${id} order`;
+  async remove(id: number) {
+    const order = await this.findOrderOrError(id);
+    return await OrderEntity.softRemove(order);
   }
 }