feat: order

backend/src/common/enums/ReceiptType.enum.ts

@@ -0,0 +1,4 @@
+export enum ReceiptType {
+  ORDER = 0,
+  PAYMENT = 1,
+}

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

@@ -1,4 +1,10 @@
-import { IsArray, IsNumber, IsOptional, ValidateNested } from 'class-validator';
+import {
+  IsArray,
+  IsNumber,
+  IsOptional,
+  IsString,
+  ValidateNested,
+} from 'class-validator';
 import { OrderItemsDto } from './order-items.dto.js';
 import { Type } from 'class-transformer';
 
@@ -11,4 +17,16 @@ export class UpdateOrderDto {
   @ValidateNested()
   @Type(() => OrderItemsDto)
   order_items: OrderItemsDto[];
+
+  @IsOptional()
+  @IsNumber()
+  order_status?: number;
+
+  @IsOptional()
+  @IsNumber()
+  rating?: number;
+
+  @IsOptional()
+  @IsString()
+  note?: string;
 }

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

@@ -14,6 +14,7 @@ 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';
+import { Request } from 'express';
 
 @Controller('branchs/:branchId/orders')
 export class BranchOrderController {
@@ -25,6 +26,7 @@ export class BranchOrderController {
     @Req() req: Request,
     @Body() createOrderDto: CreateOrderDto,
   ) {
+    const ipAddr = req.headers['x-forwarded-for'] || req.socket.remoteAddress;
     const userId = req['user'].sub;
     const role = req['user'].role;
     console.log(req['user']);
@@ -34,6 +36,7 @@ export class BranchOrderController {
         branchId,
         userId,
         createOrderDto,
+        ipAddr as string,
       );
     } else
       return this.orderService.createFromStaff(

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

@@ -1,13 +1,15 @@
-import { Module } from '@nestjs/common';
+import { forwardRef, Module } from '@nestjs/common';
 import { OrderService } from './order.service.js';
 import { BranchOrderController, OrderController } from './order.controller.js';
 import { BranchModule } from '../branch/branch.module.js';
 import { BranchMenusModule } from '../branch-menus/branch-menus.module.js';
+import { PaymentModule } from '../../payment/payment.module.js';
+import { PaymentService } from '../../payment/payment.service.js';
 
 @Module({
   imports: [BranchModule, BranchMenusModule],
   controllers: [BranchOrderController, OrderController],
-  providers: [OrderService],
+  providers: [OrderService, PaymentService],
   exports: [OrderService],
 })
 export class OrderModule {}

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

@@ -18,21 +18,99 @@ import {
   PaginateConfig,
   PaginateQuery,
 } from 'nestjs-paginate';
+import * as querystring from 'qs';
+import * as crypto from 'crypto';
 import { UpdateOrderDto } from './dto/update-order.dto.js';
 import { DataSource } from 'typeorm';
+import { PaymentService } from '../../payment/payment.service.js';
+import { ConfigService } from '@nestjs/config';
+import { ReceiptEntity } from '../../entities/receipt.entity.js';
+import { ReceiptType } from '../../common/enums/ReceiptType.enum.js';
 
 @Injectable()
 export class OrderService {
   constructor(
+    // @Inject(forwardRef(() => PaymentService))
+    // private readonly paymentService: PaymentService,
     private readonly branchService: BranchService,
     private readonly datasource: DataSource,
+    private readonly configService: ConfigService,
   ) {}
+  formatDate(date: Date, format: string): string {
+    const yyyymmdd = date.toISOString().slice(0, 10).replace(/-/g, ''); // YYYYMMDD
+    const hhmmss = date.toTimeString().slice(0, 8).replace(/:/g, ''); // HHMMSS
+    return format === 'yyyymmddHHmmss' ? yyyymmdd + hhmmss : hhmmss;
+  }
+
+  sortObject(obj) {
+    let sorted = {};
+    let str = [];
+    let key;
+    for (key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        str.push(encodeURIComponent(key));
+      }
+    }
+    str.sort();
+    for (key = 0; key < str.length; key++) {
+      sorted[str[key]] = encodeURIComponent(obj[str[key]]).replace(/%20/g, '+');
+    }
+    return sorted;
+  }
+  async createPaymentUrl(
+    amount: number,
+    orderId: string,
+    orderDescription: string,
+    orderType: string,
+    language: string,
+    ipAddr: string,
+  ) {
+    const tmnCode = this.configService.get<string>('vnp_TmnCode');
+    const secretKey = this.configService.get<string>('vnp_HashSecret');
+    const vnpUrl = this.configService.get<string>('vnp_Url');
+    const returnUrl = this.configService.get<string>('vnp_ReturnUrl');
+
+    const date = new Date();
+    const createDate = this.formatDate(date, 'yyyymmddHHmmss');
+    const locale = language || 'vn';
+    const currCode = 'VND';
+
+    const vnp_Params: Record<string, string> = {
+      vnp_Version: '2.1.0',
+      vnp_Command: 'pay',
+      vnp_TmnCode: tmnCode,
+      vnp_Locale: locale,
+      vnp_CurrCode: currCode,
+      vnp_TxnRef: orderId,
+      vnp_OrderInfo: orderDescription,
+      vnp_OrderType: orderType,
+      vnp_Amount: (amount * 100).toString(),
+      vnp_ReturnUrl: returnUrl,
+      vnp_IpAddr: ipAddr,
+      vnp_CreateDate: createDate,
+    };
+    console.log('3');
+
+    const sortedParams = this.sortObject(vnp_Params);
+
+    // Sign the data
+    const signData = querystring.stringify(sortedParams, { encode: false });
+    const hmac = crypto.createHmac('sha512', secretKey);
+    const signed = hmac.update(Buffer.from(signData, 'utf-8')).digest('hex');
+    sortedParams['vnp_SecureHash'] = signed;
+
+    // Create the URL
+    const res = `${vnpUrl}?${querystring.stringify(sortedParams, { encode: false })}`;
+
+    return res;
+  }
   async createFromCustomer(
     branchId: string,
     userId: string,
     createOrderDto: CreateOrderDto,
+    ipAddr: string,
   ) {
-    // Chưa được update đầy đủ, còn thiếu thông tin thanh toán.
+    // Tạo order đơn.
     if (createOrderDto.order_type != OrderType.ONLINE) {
       throw new BadRequestException('customer cannot create offline order');
     }
@@ -93,8 +171,18 @@ export class OrderService {
 
       await queryRunner.commitTransaction();
       await queryRunner.release();
-      return { ...order, order_items: orderItems };
+      // hoàn thành tạo order, lấy url thanh toán
+      const paymentUrl = await this.createPaymentUrl(
+        order.total_value,
+        '1731148499',
+        order.note || 'what',
+        'other',
+        'vn',
+        ipAddr,
+      );
+      return { ...order, order_items: orderItems, payment_url: paymentUrl };
     } catch (err) {
+      console.log(err);
       await queryRunner.rollbackTransaction();
       await queryRunner.release();
       throw err;
@@ -197,6 +285,29 @@ export class OrderService {
     // Cập nhật trạng thái
     // Cập nhật rating
     // Cập nhật note
+    const order = await this.findOrderOrError(id);
+    if (updateOrderDto.table_number) {
+      order.table_number = updateOrderDto.table_number;
+    }
+    if (updateOrderDto.note) {
+      order.note = updateOrderDto.note;
+    }
+    if (updateOrderDto.order_status) {
+      const st = updateOrderDto.order_status;
+      if (st == OrderStatus.DONE) {
+        const receipt = await ReceiptEntity.create({
+          branch_id: order.branch_id,
+          income: order.total_value,
+          type: ReceiptType.ORDER,
+          sender_id: order.customer_id,
+          receiver_id: order.staff_id,
+        }).save();
+      }
+      order.order_status = updateOrderDto.order_status;
+    }
+    if (updateOrderDto.rating) {
+      order.rating = updateOrderDto.rating;
+    }
   }
 
   async updateOrderPayment(id: number, paymentId: number) {

backend/src/payment/payment.module.ts

@@ -1,11 +1,14 @@
-import { Module } from '@nestjs/common';
+import { forwardRef, Module } from '@nestjs/common';
 import { PaymentService } from './payment.service.js';
 import { PaymentController } from './payment.controller.js';
+import { OrderModule } from '../modules/order/order.module.js';
+import { BranchModule } from '../modules/branch/branch.module.js';
 import { OrderService } from '../modules/order/order.service.js';
-import { BranchService } from '../modules/branch/branch.service.js';
 
 @Module({
+  imports: [BranchModule],
   controllers: [PaymentController],
-  providers: [PaymentService, OrderService, BranchService],
+  providers: [PaymentService, OrderService],
+  exports: [PaymentService],
 })
 export class PaymentModule {}

backend/src/payment/payment.service.ts

@@ -1,23 +1,29 @@
 // payment.service.ts
-import { HttpStatus, Injectable } from '@nestjs/common';
+import { forwardRef, HttpStatus, Inject, Injectable } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import * as querystring from 'qs';
 import * as crypto from 'crypto';
 import { OrderService } from '../modules/order/order.service.js';
 import { PaymentEntity } from '../entities/payment.entity.js';
-import { CreatePaymentUrlDto } from './dto/create-payment-url.dto.js';
 import { CreatePaymentDto } from './dto/create-payment.dto..js';
 import { VnpCardType } from '../common/enums/VnpCardType.enum.js';
 
 @Injectable()
 export class PaymentService {
   constructor(
+    @Inject(forwardRef(() => OrderService))
+    private readonly orderService: OrderService,
     private readonly configService: ConfigService,
-    private readonly orderService: OrderService
-  ) { }
-
-  async createPaymentUrl(amount: number, orderId: string, orderDescription: string, orderType: string, language: string, ipAddr: string) {
-
+  ) {}
+
+  async createPaymentUrl(
+    amount: number,
+    orderId: string,
+    orderDescription: string,
+    orderType: string,
+    language: string,
+    ipAddr: string,
+  ) {
     const tmnCode = this.configService.get<string>('vnp_TmnCode');
     const secretKey = this.configService.get<string>('vnp_HashSecret');
     const vnpUrl = this.configService.get<string>('vnp_Url');
@@ -42,7 +48,7 @@ export class PaymentService {
       vnp_IpAddr: ipAddr,
       vnp_CreateDate: createDate,
     };
-    console.log("3")
+    console.log('3');
 
     const sortedParams = this.sortObject(vnp_Params);
 
@@ -58,9 +64,8 @@ export class PaymentService {
     return res;
   }
 
-
   async vnpayIpn(reqQuery) {
-    console.log("helloooo")
+    console.log('helloooo');
     let vnp_Params = reqQuery;
     let secureHash = vnp_Params['vnp_SecureHash'];
 
@@ -73,8 +78,8 @@ export class PaymentService {
     vnp_Params = this.sortObject(vnp_Params);
     let secretKey = this.configService.get('vnp_HashSecret');
     let signData = querystring.stringify(vnp_Params, { encode: false });
-    let hmac = crypto.createHmac("sha512", secretKey);
-    let signed = hmac.update(Buffer.from(signData, 'utf-8')).digest("hex");
+    let hmac = crypto.createHmac('sha512', secretKey);
+    let signed = hmac.update(Buffer.from(signData, 'utf-8')).digest('hex');
 
     let paymentStatus = '0'; // Giả sử '0' là trạng thái khởi tạo giao dịch, chưa có IPN. Trạng thái này được lưu khi yêu cầu thanh toán chuyển hướng sang Cổng thanh toán VNPAY tại đầu khởi tạo đơn hàng.
     //let paymentStatus = '1'; // Giả sử '1' là trạng thái thành công bạn cập nhật sau IPN được gọi và trả kết quả về nó
@@ -83,31 +88,37 @@ export class PaymentService {
     let checkOrderId = true;
     let order;
     try {
-      order = await this.orderService.findOne(orderId)
+      order = await this.orderService.findOne(orderId);
     } catch (error) {
       return {
         statusCode: HttpStatus.OK,
         message: 'Order not found',
       };
     }
-    console.log("order = ", order);
-    console.log("order total value ", order.total_value);
+    console.log('order = ', order);
+    console.log('order total value ', order.total_value);
     // Kiểm tra số tiền "giá trị của vnp_Amout/100" trùng khớp với số tiền của đơn hàng trong CSDL của bạn
-    let checkAmount = order.total_value == parseFloat(vnp_Params["vnp_Amount"])/100; 
-    if (secureHash === signed) { //kiểm tra checksum
+    let checkAmount =
+      order.total_value == parseFloat(vnp_Params['vnp_Amount']) / 100;
+    if (secureHash === signed) {
+      //kiểm tra checksum
       if (checkOrderId) {
         if (checkAmount) {
-          if (paymentStatus == "0") { //kiểm tra tình trạng giao dịch trước khi cập nhật tình trạng thanh toán
-            if (rspCode == "00") {
+          if (paymentStatus == '0') {
+            //kiểm tra tình trạng giao dịch trước khi cập nhật tình trạng thanh toán
+            if (rspCode == '00') {
               //thanh cong
               //paymentStatus = '1'
               // Ở đây cập nhật trạng thái giao dịch thanh toán thành công vào CSDL của bạn
               const payment = await this.create({
                 payment_method: 2,
-                vnp_amount: parseFloat(vnp_Params["vnp_Amount"])/100,
+                vnp_amount: parseFloat(vnp_Params['vnp_Amount']) / 100,
                 vnp_bank_code: vnp_Params['vnp_BankCode'],
                 vnp_bank_tran_no: vnp_Params['vnp_BankTranNo'],
-                vnp_card_type: VnpCardType[vnp_Params['vnp_CardType'] as keyof typeof VnpCardType],
+                vnp_card_type:
+                  VnpCardType[
+                    vnp_Params['vnp_CardType'] as keyof typeof VnpCardType
+                  ],
                 vnp_order_info: vnp_Params['vnp_BankTranNo'],
                 vnp_paydate: vnp_Params['vnp_PayDate'],
                 vnp_response_code: vnp_Params['vnp_ResponseCode'],
@@ -115,13 +126,12 @@ export class PaymentService {
                 vnp_transaction_status: vnp_Params['vnp_TransactionStatus'],
               });
               await PaymentEntity.save(payment);
-              this.orderService.updateOrderPayment(orderId, payment.id)
+              this.orderService.updateOrderPayment(orderId, payment.id);
               return {
                 statusCode: HttpStatus.OK,
                 message: 'Thành công!',
               };
-            }
-            else {
+            } else {
               //that bai
               //paymentStatus = '2'
               // Ở đây cập nhật trạng thái giao dịch thanh toán thất bại vào CSDL của bạn
@@ -130,29 +140,25 @@ export class PaymentService {
                 message: 'Thất bại',
               };
             }
-          }
-          else {
+          } else {
             return {
               statusCode: HttpStatus.OK,
               message: 'This order has been updated to the payment status',
             };
           }
-        }
-        else {
+        } else {
           return {
             statusCode: HttpStatus.OK,
             message: 'Amount invalid',
           };
         }
-      }
-      else {
+      } else {
         return {
           statusCode: HttpStatus.OK,
           message: 'Order not found',
         };
       }
-    }
-    else {
+    } else {
       return {
         statusCode: HttpStatus.OK,
         message: 'Checksum failed!',
@@ -178,12 +184,14 @@ export class PaymentService {
     }
     str.sort();
     for (key = 0; key < str.length; key++) {
-      sorted[str[key]] = encodeURIComponent(obj[str[key]]).replace(/%20/g, "+");
+      sorted[str[key]] = encodeURIComponent(obj[str[key]]).replace(/%20/g, '+');
     }
     return sorted;
   }
 
-  async create(createPaymentDto: CreatePaymentDto): Promise<PaymentEntity | undefined> {
+  async create(
+    createPaymentDto: CreatePaymentDto,
+  ): Promise<PaymentEntity | undefined> {
     return PaymentEntity.create({
       payment_method: 2,
       vnp_amount: createPaymentDto.vnp_amount,
@@ -194,7 +202,7 @@ export class PaymentService {
       vnp_paydate: createPaymentDto.vnp_paydate,
       vnp_response_code: createPaymentDto.vnp_response_code,
       vnp_transaction_no: createPaymentDto.vnp_transaction_no,
-      vnp_transaction_status: createPaymentDto.vnp_transaction_status
-    })
+      vnp_transaction_status: createPaymentDto.vnp_transaction_status,
+    });
   }
 }