Merge branch 'main' of https://github.com/PBL6-team-CATS/PBL6-informative-system into feature/frontend_update

Dockerfile

@@ -1,5 +1,5 @@
 # Use an official Node.js runtime as a parent image
-FROM node:22-alpine
+FROM node:22.4.0
 
 # Set the working directory
 WORKDIR /app

README.md

@@ -14,3 +14,4 @@ app_port: 3000
 
 -   [Trello](https://trello.com/w/pbl6hthngthongtin1)
 -   [Google drive](https://drive.google.com/drive/folders/19qQ5Wn4uat0hSeDX3N5c0X19abYkQLfc?usp=drive_link)
+-   [API docs](https://hackmd.io/NCILuSy3Rxif-KRVQZjNIg#Menu-item)

backend/src/app.module.ts

@@ -1,39 +1,43 @@
-import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
-import { AppController } from './app.controller.js';
-import { AppService } from './app.service.js';
-import { ConfigModule } from '@nestjs/config';
-import { TypeOrmModule } from '@nestjs/typeorm';
-import { configuration } from './config/config.js';
-import { DatabaseConfigService } from './config/database.js';
-import { AppLoggerMiddleware } from './common/middlewares/app-logger.middleware.js';
-import { DeviceInfoMiddleware } from './common/middlewares/device-info.middleware.js';
-import { UserModule } from './modules/user/user.module.js';
-import { BranchModule } from './modules/branch/branch.module.js';
-import { AuthenticationModule } from './modules/authentication/authentication.module.js';
-import { MenuItemModule } from './modules/menu-item/menu-item.module.js';
-import { FeedsModule } from './modules/feeds/feeds.module.js';
-@Module({
-  imports: [
-    ConfigModule.forRoot({
-      isGlobal: true,
-      load: [configuration],
-    }),
-    TypeOrmModule.forRootAsync({
-      imports: [ConfigModule],
-      useClass: DatabaseConfigService,
-    }),
-    UserModule,
-    BranchModule,
-    AuthenticationModule,
-    MenuItemModule,
-    FeedsModule,
-  ],
-  controllers: [AppController],
-  providers: [AppService],
-})
-export class AppModule implements NestModule {
-  configure(consumer: MiddlewareConsumer): void {
-    consumer.apply(AppLoggerMiddleware).forRoutes('*');
-    consumer.apply(DeviceInfoMiddleware).forRoutes('*');
-  }
-}
+import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
+import { AppController } from './app.controller.js';
+import { AppService } from './app.service.js';
+import { ConfigModule } from '@nestjs/config';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { configuration } from './config/config.js';
+import { DatabaseConfigService } from './config/database.js';
+import { AppLoggerMiddleware } from './common/middlewares/app-logger.middleware.js';
+import { DeviceInfoMiddleware } from './common/middlewares/device-info.middleware.js';
+import { UserModule } from './modules/user/user.module.js';
+import { BranchModule } from './modules/branch/branch.module.js';
+import { AuthenticationModule } from './modules/authentication/authentication.module.js';
+import { MenuItemModule } from './modules/menu-item/menu-item.module.js';
+import { FeedsModule } from './modules/feeds/feeds.module.js';
+import { OrderModule } from './modules/order/order.module.js';
+import { BranchMenusModule } from './modules/branch-menus/branch-menus.module.js';
+@Module({
+  imports: [
+    ConfigModule.forRoot({
+      isGlobal: true,
+      load: [configuration],
+    }),
+    TypeOrmModule.forRootAsync({
+      imports: [ConfigModule],
+      useClass: DatabaseConfigService,
+    }),
+    UserModule,
+    BranchModule,
+    AuthenticationModule,
+    MenuItemModule,
+    FeedsModule,
+    OrderModule,
+    BranchMenusModule,
+  ],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule implements NestModule {
+  configure(consumer: MiddlewareConsumer): void {
+    consumer.apply(AppLoggerMiddleware).forRoutes('*');
+    consumer.apply(DeviceInfoMiddleware).forRoutes('*');
+  }
+}

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

@@ -0,0 +1,7 @@
+export enum OrderStatus {
+  PENDING = 'pending', // KH đặt hàng đã thanh toán online, nhân viên chưa xác nhận <online>
+  CONFIRMED = 'confirmed', // nhân viên xác nhận và chuyển sang trạng thái <online>
+  PREPARING = 'preparing', // nhân viên xác nhận và sang trạng thái preparing này ngay lập tức <online/offline>
+  DELIVERING = 'delivering', // dang giao hàng <online>
+  DONE = 'done', // <online, offline>
+}

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

@@ -0,0 +1,5 @@
+export enum OrderType {
+  TAKE_AWAY = 'take_away',
+  OFFLINE = 'offline',
+  ONLINE = 'online',
+}

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

@@ -0,0 +1,5 @@
+export enum PaymentMethod {
+  CASH = 'cash',
+  CARD = 'card',
+  ONLINE_PAYMENT = 'online_payment',
+}

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

@@ -1,8 +1,8 @@
-export enum Role {
-    CUSTOMER = 'CUSTOMER',
-    ADMIN = 'ADMIN',
-    BRANCH_MANAGER = 'BRANCH_MANAGER',
-    AREA_MANAGER = 'AREA_MANAGER',
-    STAFF = 'STAFF',
-    SHIPPER = 'SHIPPER'
+export enum Role {
+    CUSTOMER = 'CUSTOMER',
+    ADMIN = 'ADMIN',
+    BRANCH_MANAGER = 'BRANCH_MANAGER',
+    AREA_MANAGER = 'AREA_MANAGER',
+    STAFF = 'STAFF',
+    SHIPPER = 'SHIPPER'
   }

backend/src/entities/branch-menu.entity.ts

@@ -2,6 +2,7 @@ import {
   BaseEntity,
   Column,
   Entity,
+  JoinColumn,
   ManyToOne,
   OneToMany,
   PrimaryGeneratedColumn,
@@ -21,15 +22,17 @@ export class BranchMenuEntity extends BaseEntity {
   @Column()
   menu_id: string;
 
-  @Column()
+  @Column({ nullable: true })
   description: string;
 
-  @Column()
+  @Column({ default: true })
   is_open: boolean;
 
   @ManyToOne(() => BranchEntity, (a) => a.menu_items)
+  @JoinColumn({ name: 'branch_id' })
   branch: Relation<BranchEntity>;
 
   @ManyToOne(() => MenuItemEntity, (a) => a.branch_menus)
+  @JoinColumn({ name: 'menu_id' })
   menu_item: Relation<MenuItemEntity>;
 }

backend/src/entities/branch.entity.ts

@@ -1,35 +1,37 @@
-import {
-  BaseEntity,
-  Column,
-  Entity,
-  ManyToOne,
-  OneToMany,
-  PrimaryGeneratedColumn,
-  Relation,
-} from 'typeorm';
-import { UserEntity } from './user.entity.js';
-import { BranchMenuEntity } from './branch-menu.entity.js';
-
-@Entity('branches')
-export class BranchEntity extends BaseEntity {
-  @PrimaryGeneratedColumn('uuid')
-  id: string;
-
-  @Column()
-  name: string;
-
-  @Column()
-  location: string;
-
-  @Column()
-  phone_number: string;
-
-  @ManyToOne(() => UserEntity, (user) => user.branches)
-  owner: Relation<UserEntity>;
-
-  @OneToMany(() => BranchMenuEntity, (a) => a.branch)
-  menu_items: Relation<BranchMenuEntity>[];
-
-  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
-  create_at: Date;
-}
+import {
+  BaseEntity,
+  Column,
+  CreateDateColumn,
+  Entity,
+  ManyToOne,
+  OneToMany,
+  PrimaryColumn,
+  PrimaryGeneratedColumn,
+  Relation,
+} from 'typeorm';
+import { UserEntity } from './user.entity.js';
+import { BranchMenuEntity } from './branch-menu.entity.js';
+
+@Entity('branches')
+export class BranchEntity extends BaseEntity {
+  @PrimaryColumn()
+  id: string;
+
+  @Column()
+  name: string;
+
+  @Column()
+  location: string;
+
+  @Column()
+  phone_number: string;
+
+  @ManyToOne(() => UserEntity, (user) => user.branches)
+  owner: Relation<UserEntity>;
+
+  @OneToMany(() => BranchMenuEntity, (a) => a.branch)
+  menu_items: Relation<BranchMenuEntity>[];
+
+  @CreateDateColumn()
+  create_at: Date;
+}

backend/src/entities/feed.entity.ts

@@ -1,4 +1,4 @@
-import { Entity, Column, BaseEntity, PrimaryGeneratedColumn } from 'typeorm';
+import { Entity, Column, BaseEntity, PrimaryGeneratedColumn, CreateDateColumn } from 'typeorm';
 
 @Entity('feeds')
 export class FeedEntity extends BaseEntity {
@@ -17,6 +17,6 @@ export class FeedEntity extends BaseEntity {
   @Column({ nullable: true })
   description: string;
 
-  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
+  @CreateDateColumn()
   create_at: Date;
 }

backend/src/entities/menu-item.entity.ts

@@ -1,6 +1,7 @@
 import {
   BaseEntity,
   Column,
+  CreateDateColumn,
   Entity,
   OneToMany,
   PrimaryColumn,
@@ -32,6 +33,6 @@ export class MenuItemEntity extends BaseEntity {
   @OneToMany(() => BranchMenuEntity, (a) => a.menu_item)
   branch_menus: Relation<BranchMenuEntity>[];
 
-  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
+  @CreateDateColumn()
   create_at: Date;
 }

backend/src/entities/order-item.entity.ts

@@ -0,0 +1,37 @@
+import {
+  BaseEntity,
+  Column,
+  Entity,
+  JoinColumn,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  Relation,
+} from 'typeorm';
+import { BranchMenuEntity } from './branch-menu.entity.js';
+import { OrderEntity } from './order.entity.js';
+
+@Entity('order_items')
+export class OrderItemEntity extends BaseEntity {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column()
+  order_id: number;
+
+  @ManyToOne(() => OrderEntity, (a) => a.order_items)
+  @JoinColumn({ name: 'order_id' })
+  order: Relation<OrderEntity>;
+
+  @Column()
+  branch_menu_id: string;
+
+  @ManyToOne(() => BranchMenuEntity)
+  @JoinColumn({ name: 'branch_menu_id' })
+  branch_menu: Relation<BranchMenuEntity>;
+
+  @Column()
+  quantity: number;
+
+  @Column()
+  price: number;
+}

backend/src/entities/order.entity.ts

@@ -0,0 +1,70 @@
+import {
+  BaseEntity,
+  Column,
+  CreateDateColumn,
+  Entity,
+  JoinColumn,
+  ManyToOne,
+  OneToMany,
+  OneToOne,
+  PrimaryGeneratedColumn,
+  Relation,
+} from 'typeorm';
+import { BranchEntity } from './branch.entity.js';
+import { UserEntity } from './user.entity.js';
+import { OrderType } from '../common/enums/OrderType.enum.js';
+import { OrderStatus } from '../common/enums/OrderStatus.enum.js';
+import { OrderItemEntity } from './order-item.entity.js';
+import { PaymentEntity } from './payment.entity.js';
+
+@Entity('orders')
+export class OrderEntity extends BaseEntity {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ nullable: true })
+  customer_id: string;
+
+  @ManyToOne(() => UserEntity, { nullable: true })
+  @JoinColumn({ name: 'customer_id' })
+  customer: Relation<UserEntity>;
+
+  @Column()
+  branch_id: string;
+
+  @ManyToOne(() => BranchEntity)
+  @JoinColumn({ name: 'branch_id' })
+  branch: Relation<BranchEntity>;
+
+  @Column({ nullable: true })
+  staff_id: string;
+
+  @ManyToOne(() => UserEntity, { nullable: true })
+  @JoinColumn({ name: 'staff_id' })
+  staff: Relation<UserEntity>;
+
+  @Column({ nullable: true })
+  table_number: number;
+
+  @Column()
+  total_value: number;
+
+  @CreateDateColumn()
+  create_at: Date;
+
+  @Column({ type: 'enum', enum: OrderType, default: OrderType.ONLINE })
+  order_type: OrderType;
+
+  @Column({ type: 'enum', enum: OrderStatus, default: OrderStatus.PENDING })
+  order_status: OrderStatus;
+
+  @OneToMany(() => OrderItemEntity, (a) => a.order)
+  order_items: Relation<OrderItemEntity>[];
+
+  @Column({ nullable: true })
+  payment_id: number;
+
+  @OneToOne(() => PaymentEntity, (a) => a.order)
+  @JoinColumn({ name: 'payment_id' })
+  payment: Relation<PaymentEntity>;
+}

backend/src/entities/payment.entity.ts

@@ -0,0 +1,28 @@
+import {
+  BaseEntity,
+  Column,
+  Entity,
+  JoinColumn,
+  ManyToOne,
+  OneToOne,
+  PrimaryGeneratedColumn,
+  Relation,
+} from 'typeorm';
+import { BranchMenuEntity } from './branch-menu.entity.js';
+import { OrderEntity } from './order.entity.js';
+import { PaymentMethod } from '../common/enums/PaymentMethod.enum.js';
+
+@Entity('payments')
+export class PaymentEntity extends BaseEntity {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @OneToOne(() => OrderEntity, (a) => a.payment)
+  order: Relation<OrderEntity>;
+
+  @Column({ type: 'enum', enum: PaymentMethod, default: PaymentMethod.CASH })
+  payment_method: PaymentMethod; // E.g., 'Cash', 'Credit Card', 'Online Payment'
+
+  @Column()
+  value: number;
+}

backend/src/entities/user.entity.ts

@@ -1,54 +1,55 @@
-import {
-  Entity,
-  Column,
-  BaseEntity,
-  PrimaryGeneratedColumn,
-  OneToMany,
-  ManyToOne,
-  Relation,
-  JoinColumn,
-} from 'typeorm';
-import { BranchEntity } from './branch.entity.js';
-import { IsOptional } from 'class-validator';
-import { Role } from '../common/enums/role.enum.js';
-
-@Entity('users')
-export class UserEntity extends BaseEntity {
-  @PrimaryGeneratedColumn('uuid')
-  id: string;
-
-  @IsOptional()
-  @Column({ nullable: true })
-  avatar: string;
-
-  @Column()
-  full_name: string;
-
-  @Column({ unique: true })
-  phone_number: string;
-
-  @IsOptional()
-  @Column({ nullable: true })
-  address: string;
-
-  @Column({ nullable: true, unique: true })
-  email: string;
-
-  @Column({ type: 'enum', enum: Role, default: 'CUSTOMER' })
-  role: Role;
-  
-  @Column()
-  hash_password: string;
-
-  @IsOptional()
-  @Column({ default: true })
-  is_valid: boolean;
-
-  @IsOptional()
-  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
-  create_at: Date;
-
-  @IsOptional()
-  @OneToMany(() => BranchEntity, (branch) => branch.owner)
-  branches: Relation<BranchEntity>[];
-}
+import {
+  Entity,
+  Column,
+  BaseEntity,
+  PrimaryGeneratedColumn,
+  OneToMany,
+  ManyToOne,
+  Relation,
+  JoinColumn,
+  CreateDateColumn,
+} from 'typeorm';
+import { BranchEntity } from './branch.entity.js';
+import { IsOptional } from 'class-validator';
+import { Role } from '../common/enums/role.enum.js';
+
+@Entity('users')
+export class UserEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @IsOptional()
+  @Column({ nullable: true })
+  avatar: string;
+
+  @Column()
+  full_name: string;
+
+  @Column({ unique: true })
+  phone_number: string;
+
+  @IsOptional()
+  @Column({ nullable: true })
+  address: string;
+
+  @Column({ nullable: true, unique: true })
+  email: string;
+
+  @Column({ type: 'enum', enum: Role, default: 'CUSTOMER' })
+  role: Role;
+  
+  @Column()
+  hash_password: string;
+
+  @IsOptional()
+  @Column({ default: true })
+  is_valid: boolean;
+
+  @IsOptional()
+  @CreateDateColumn()
+  create_at: Date;
+
+  @IsOptional()
+  @OneToMany(() => BranchEntity, (branch) => branch.owner)
+  branches: Relation<BranchEntity>[];
+}

backend/src/migrations/1729963419864-enum-role.ts

@@ -1,22 +0,0 @@
-import { MigrationInterface, QueryRunner } from "typeorm";
-
-export class EnumRole1729963419864 implements MigrationInterface {
-    name = 'EnumRole1729963419864'
-
-    public async up(queryRunner: QueryRunner): Promise<void> {
-        await queryRunner.query(`ALTER TABLE "users" DROP CONSTRAINT "FK_a2cecd1a3531c0b041e29ba46e1"`);
-        await queryRunner.query(`ALTER TABLE "users" RENAME COLUMN "role_id" TO "role"`);
-        await queryRunner.query(`ALTER TABLE "users" DROP COLUMN "role"`);
-        await queryRunner.query(`CREATE TYPE "public"."users_role_enum" AS ENUM('CUSTOMER', 'ADMIN', 'BRANCH_MANAGER', 'AREA_MANAGER', 'STAFF', 'SHIPPER')`);
-        await queryRunner.query(`ALTER TABLE "users" ADD "role" "public"."users_role_enum" NOT NULL DEFAULT 'CUSTOMER'`);
-    }
-
-    public async down(queryRunner: QueryRunner): Promise<void> {
-        await queryRunner.query(`ALTER TABLE "users" DROP COLUMN "role"`);
-        await queryRunner.query(`DROP TYPE "public"."users_role_enum"`);
-        await queryRunner.query(`ALTER TABLE "users" ADD "role" uuid NOT NULL DEFAULT 'f3750930-48ab-4c30-8681-d50e68e2bda7'`);
-        await queryRunner.query(`ALTER TABLE "users" RENAME COLUMN "role" TO "role_id"`);
-        await queryRunner.query(`ALTER TABLE "users" ADD CONSTRAINT "FK_a2cecd1a3531c0b041e29ba46e1" FOREIGN KEY ("role_id") REFERENCES "role"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`);
-    }
-
-}

backend/src/migrations/1730474673934-RefactorAll.ts

@@ -0,0 +1,56 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class RefactorAll1730474673934 implements MigrationInterface {
+    name = 'RefactorAll1730474673934'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`CREATE TABLE "feeds" ("id" SERIAL NOT NULL, "author_id" character varying, "image_url" character varying, "title" character varying NOT NULL, "description" character varying, "create_at" TIMESTAMP NOT NULL DEFAULT now(), CONSTRAINT "PK_3dafbf766ecbb1eb2017732153f" PRIMARY KEY ("id"))`);
+        await queryRunner.query(`CREATE TYPE "public"."users_role_enum" AS ENUM('CUSTOMER', 'ADMIN', 'BRANCH_MANAGER', 'AREA_MANAGER', 'STAFF', 'SHIPPER')`);
+        await queryRunner.query(`CREATE TABLE "users" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "avatar" character varying, "full_name" character varying NOT NULL, "phone_number" character varying NOT NULL, "address" character varying, "email" character varying, "role" "public"."users_role_enum" NOT NULL DEFAULT 'CUSTOMER', "hash_password" character varying NOT NULL, "is_valid" boolean NOT NULL DEFAULT true, "create_at" TIMESTAMP NOT NULL DEFAULT now(), CONSTRAINT "UQ_17d1817f241f10a3dbafb169fd2" UNIQUE ("phone_number"), CONSTRAINT "UQ_97672ac88f789774dd47f7c8be3" UNIQUE ("email"), CONSTRAINT "PK_a3ffb1c0c8416b9fc6f907b7433" PRIMARY KEY ("id"))`);
+        await queryRunner.query(`CREATE TABLE "branches" ("id" character varying NOT NULL, "name" character varying NOT NULL, "location" character varying NOT NULL, "phone_number" character varying NOT NULL, "create_at" TIMESTAMP NOT NULL DEFAULT now(), "ownerId" uuid, CONSTRAINT "PK_7f37d3b42defea97f1df0d19535" PRIMARY KEY ("id"))`);
+        await queryRunner.query(`CREATE TYPE "public"."menu_items_item_type_enum" AS ENUM('monchinh', 'trangmieng', 'giaikhat', 'khac')`);
+        await queryRunner.query(`CREATE TABLE "menu_items" ("id" character varying NOT NULL, "item_name" character varying NOT NULL, "image_url" character varying, "item_type" "public"."menu_items_item_type_enum" NOT NULL DEFAULT 'khac', "description" character varying NOT NULL, "price" integer NOT NULL, "create_at" TIMESTAMP NOT NULL DEFAULT now(), CONSTRAINT "PK_57e6188f929e5dc6919168620c8" PRIMARY KEY ("id"))`);
+        await queryRunner.query(`CREATE TABLE "branch_menu" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "branch_id" character varying NOT NULL, "menu_id" character varying NOT NULL, "description" character varying, "is_open" boolean NOT NULL DEFAULT true, CONSTRAINT "PK_977becffe98bbc626a56031b9e7" PRIMARY KEY ("id"))`);
+        await queryRunner.query(`CREATE TYPE "public"."payments_payment_method_enum" AS ENUM('cash', 'card', 'online_payment')`);
+        await queryRunner.query(`CREATE TABLE "payments" ("id" SERIAL NOT NULL, "payment_method" "public"."payments_payment_method_enum" NOT NULL DEFAULT 'cash', "value" integer NOT NULL, CONSTRAINT "PK_197ab7af18c93fbb0c9b28b4a59" PRIMARY KEY ("id"))`);
+        await queryRunner.query(`CREATE TYPE "public"."orders_order_type_enum" AS ENUM('take_away', 'offline', 'online')`);
+        await queryRunner.query(`CREATE TYPE "public"."orders_order_status_enum" AS ENUM('pending', 'confirmed', 'preparing', 'delivering', 'done')`);
+        await queryRunner.query(`CREATE TABLE "orders" ("id" SERIAL NOT NULL, "customer_id" uuid, "branch_id" character varying NOT NULL, "staff_id" uuid, "table_number" integer, "total_value" integer NOT NULL, "create_at" TIMESTAMP NOT NULL DEFAULT now(), "order_type" "public"."orders_order_type_enum" NOT NULL DEFAULT 'online', "order_status" "public"."orders_order_status_enum" NOT NULL DEFAULT 'pending', "payment_id" integer, CONSTRAINT "REL_5b3e94bd2aedc184f9ad8c1043" UNIQUE ("payment_id"), CONSTRAINT "PK_710e2d4957aa5878dfe94e4ac2f" PRIMARY KEY ("id"))`);
+        await queryRunner.query(`CREATE TABLE "order_items" ("id" SERIAL NOT NULL, "order_id" integer NOT NULL, "branch_menu_id" uuid NOT NULL, "quantity" integer NOT NULL, "price" integer NOT NULL, CONSTRAINT "PK_005269d8574e6fac0493715c308" PRIMARY KEY ("id"))`);
+        await queryRunner.query(`ALTER TABLE "branches" ADD CONSTRAINT "FK_8c6ae9f9c654c4fac71bccbb7ed" FOREIGN KEY ("ownerId") REFERENCES "users"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`);
+        await queryRunner.query(`ALTER TABLE "branch_menu" ADD CONSTRAINT "FK_96fd74bed807987cf2ee5d8f168" FOREIGN KEY ("branch_id") REFERENCES "branches"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`);
+        await queryRunner.query(`ALTER TABLE "branch_menu" ADD CONSTRAINT "FK_703aa953158d2e80f3fbb0eb9ea" FOREIGN KEY ("menu_id") REFERENCES "menu_items"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`);
+        await queryRunner.query(`ALTER TABLE "orders" ADD CONSTRAINT "FK_772d0ce0473ac2ccfa26060dbe9" FOREIGN KEY ("customer_id") REFERENCES "users"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`);
+        await queryRunner.query(`ALTER TABLE "orders" ADD CONSTRAINT "FK_17b723da2c12837f4bc21e33398" FOREIGN KEY ("branch_id") REFERENCES "branches"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`);
+        await queryRunner.query(`ALTER TABLE "orders" ADD CONSTRAINT "FK_40337bbb0e0cc7113dc3037fc60" FOREIGN KEY ("staff_id") REFERENCES "users"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`);
+        await queryRunner.query(`ALTER TABLE "orders" ADD CONSTRAINT "FK_5b3e94bd2aedc184f9ad8c10439" FOREIGN KEY ("payment_id") REFERENCES "payments"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`);
+        await queryRunner.query(`ALTER TABLE "order_items" ADD CONSTRAINT "FK_145532db85752b29c57d2b7b1f1" FOREIGN KEY ("order_id") REFERENCES "orders"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`);
+        await queryRunner.query(`ALTER TABLE "order_items" ADD CONSTRAINT "FK_927879f38b3098216737427d2f0" FOREIGN KEY ("branch_menu_id") REFERENCES "branch_menu"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "order_items" DROP CONSTRAINT "FK_927879f38b3098216737427d2f0"`);
+        await queryRunner.query(`ALTER TABLE "order_items" DROP CONSTRAINT "FK_145532db85752b29c57d2b7b1f1"`);
+        await queryRunner.query(`ALTER TABLE "orders" DROP CONSTRAINT "FK_5b3e94bd2aedc184f9ad8c10439"`);
+        await queryRunner.query(`ALTER TABLE "orders" DROP CONSTRAINT "FK_40337bbb0e0cc7113dc3037fc60"`);
+        await queryRunner.query(`ALTER TABLE "orders" DROP CONSTRAINT "FK_17b723da2c12837f4bc21e33398"`);
+        await queryRunner.query(`ALTER TABLE "orders" DROP CONSTRAINT "FK_772d0ce0473ac2ccfa26060dbe9"`);
+        await queryRunner.query(`ALTER TABLE "branch_menu" DROP CONSTRAINT "FK_703aa953158d2e80f3fbb0eb9ea"`);
+        await queryRunner.query(`ALTER TABLE "branch_menu" DROP CONSTRAINT "FK_96fd74bed807987cf2ee5d8f168"`);
+        await queryRunner.query(`ALTER TABLE "branches" DROP CONSTRAINT "FK_8c6ae9f9c654c4fac71bccbb7ed"`);
+        await queryRunner.query(`DROP TABLE "order_items"`);
+        await queryRunner.query(`DROP TABLE "orders"`);
+        await queryRunner.query(`DROP TYPE "public"."orders_order_status_enum"`);
+        await queryRunner.query(`DROP TYPE "public"."orders_order_type_enum"`);
+        await queryRunner.query(`DROP TABLE "payments"`);
+        await queryRunner.query(`DROP TYPE "public"."payments_payment_method_enum"`);
+        await queryRunner.query(`DROP TABLE "branch_menu"`);
+        await queryRunner.query(`DROP TABLE "menu_items"`);
+        await queryRunner.query(`DROP TYPE "public"."menu_items_item_type_enum"`);
+        await queryRunner.query(`DROP TABLE "branches"`);
+        await queryRunner.query(`DROP TABLE "users"`);
+        await queryRunner.query(`DROP TYPE "public"."users_role_enum"`);
+        await queryRunner.query(`DROP TABLE "feeds"`);
+    }
+
+}

backend/src/modules/branch-menus/branch-menus.controller.ts

@@ -0,0 +1,55 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Body,
+  Patch,
+  Param,
+  Delete,
+} from '@nestjs/common';
+import { BranchMenusService } from './branch-menus.service.js';
+import { CreateBranchMenuDto } from './dto/create-branch-menu.dto.js';
+import { UpdateBranchMenuDto } from './dto/update-branch-menu.dto.js';
+import { Public } from '../authentication/authentication.decorator.js';
+import { Paginate, PaginateQuery } from 'nestjs-paginate';
+
+@Public()
+@Controller('branchs/:branchId/menus')
+export class BranchMenusController {
+  constructor(private readonly branchMenusService: BranchMenusService) {}
+
+  @Post() // thêm menu vào branch
+  create(
+    @Param('branchId') branchId: string,
+    @Body() createBranchMenuDto: CreateBranchMenuDto,
+  ) {
+    return this.branchMenusService.create(branchId, createBranchMenuDto);
+  }
+
+  @Get() // lấy danh sách menu trong branch
+  findAll(
+    @Param('branchId') branchId: string,
+    @Paginate() query: PaginateQuery,
+  ) {
+    // console.log('branchId', branchId);
+    return this.branchMenusService.findAll(branchId, query);
+  }
+
+  @Get(':id') // lấy một menu trong branch
+  findOne(@Param('branchId') branchId: string, @Param('id') id: string) {
+    return this.branchMenusService.findOne(branchId, id);
+  }
+
+  @Patch(':id')
+  update(
+    @Param('id') id: string,
+    @Body() updateBranchMenuDto: UpdateBranchMenuDto,
+  ) {
+    return this.branchMenusService.update(+id, updateBranchMenuDto);
+  }
+
+  @Delete(':id')
+  remove(@Param('id') id: string) {
+    return this.branchMenusService.remove(+id);
+  }
+}

backend/src/modules/branch-menus/branch-menus.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { BranchMenusService } from './branch-menus.service.js';
+import { BranchMenusController } from './branch-menus.controller.js';
+import { BranchModule } from '../branch/branch.module.js';
+import { MenuItemModule } from '../menu-item/menu-item.module.js';
+
+@Module({
+  imports: [BranchModule, MenuItemModule],
+  controllers: [BranchMenusController],
+  providers: [BranchMenusService],
+  exports: [BranchMenusService],
+})
+export class BranchMenusModule {}

backend/src/modules/branch-menus/branch-menus.service.ts

@@ -0,0 +1,72 @@
+import { Injectable } from '@nestjs/common';
+import { CreateBranchMenuDto } from './dto/create-branch-menu.dto.js';
+import { UpdateBranchMenuDto } from './dto/update-branch-menu.dto.js';
+import { BranchService } from '../branch/branch.service.js';
+import { MenuItemService } from '../menu-item/menu-item.service.js';
+import { BranchMenuEntity } from '../../entities/branch-menu.entity.js';
+import { paginate, PaginateConfig, PaginateQuery } from 'nestjs-paginate';
+import { isUUID } from 'class-validator';
+
+@Injectable()
+export class BranchMenusService {
+  constructor(
+    private readonly branchService: BranchService,
+    private readonly menuItemService: MenuItemService,
+  ) {}
+  async create(branchId: string, createBranchMenuDto: CreateBranchMenuDto) {
+    const branch = await this.branchService.getBranchOrError(branchId);
+    const menuItem = await this.menuItemService.getMenuItemOrError(
+      createBranchMenuDto.menu_id,
+    );
+    if (createBranchMenuDto.description) {
+      return await BranchMenuEntity.create({
+        ...createBranchMenuDto,
+        branch_id: branchId,
+      }).save();
+    } else {
+      return await BranchMenuEntity.create({
+        ...createBranchMenuDto,
+        branch_id: branchId,
+        description: menuItem.description,
+      }).save();
+    }
+  }
+
+  async findAll(branchId: string, query: PaginateQuery) {
+    const paginateConfig: PaginateConfig<BranchMenuEntity> = {
+      sortableColumns: ['id', 'branch_id', 'menu_id', 'description'],
+      nullSort: 'last',
+      defaultSortBy: [['id', 'DESC']],
+      searchableColumns: ['description'],
+      filterableColumns: {
+        // price: [],
+        // item_type: [FilterOperator.EQ],
+      },
+    };
+    return paginate(
+      query,
+      BranchMenuEntity.createQueryBuilder('bm')
+        .leftJoinAndSelect('bm.menu_item', 'menu_item')
+        .where('bm.branch_id = :branchId', { branchId: branchId }),
+      paginateConfig,
+    );
+  }
+
+  async findOne(branchId: string, id: string) {
+    if (isUUID(id)) return await BranchMenuEntity.findOneBy({ id });
+    else {
+      return await BranchMenuEntity.findOne({
+        where: { branch_id: branchId, menu_id: id },
+        relations: ['menu_item'],
+      });
+    }
+  }
+
+  update(id: number, updateBranchMenuDto: UpdateBranchMenuDto) {
+    return `This action updates a #${id} branchMenu`;
+  }
+
+  remove(id: number) {
+    return `This action removes a #${id} branchMenu`;
+  }
+}

backend/src/modules/branch-menus/dto/create-branch-menu.dto.ts

@@ -0,0 +1,10 @@
+import { IsOptional, IsString } from 'class-validator';
+
+export class CreateBranchMenuDto {
+  @IsString()
+  menu_id: string;
+
+  @IsString()
+  @IsOptional()
+  description?: string;
+}

backend/src/modules/branch-menus/dto/update-branch-menu.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateBranchMenuDto } from './create-branch-menu.dto.js';
+
+export class UpdateBranchMenuDto extends PartialType(CreateBranchMenuDto) {}

backend/src/modules/branch/branch.controller.ts

@@ -10,8 +10,10 @@ import {
 import { BranchService } from './branch.service.js';
 import { CreateBranchDto } from './dto/create-branch.dto.js';
 import { UpdateBranchDto } from './dto/update-branch.dto.js';
+import { Public } from '../authentication/authentication.decorator.js';
 
-@Controller('branch')
+@Public()
+@Controller('branchs')
 export class BranchController {
   constructor(private readonly branchService: BranchService) {}
 
@@ -47,7 +49,5 @@ export class BranchController {
   async addMenuItemToBranch(@Param('id') id: string) {}
 
   @Get(':id/menu-items')
-  async getMenuItemWithBranchId(@Param('id') id: string) {
-    
-  }
+  async getMenuItemWithBranchId(@Param('id') id: string) {}
 }

backend/src/modules/branch/branch.module.ts

@@ -5,5 +5,6 @@ import { BranchController } from './branch.controller.js';
 @Module({
   controllers: [BranchController],
   providers: [BranchService],
+  exports: [BranchService],
 })
 export class BranchModule {}

backend/src/modules/branch/branch.service.ts

@@ -1,4 +1,8 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
+import {
+  BadRequestException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
 import { CreateBranchDto } from './dto/create-branch.dto.js';
 import { BranchEntity } from '../../entities/branch.entity.js';
 import { Public } from '../authentication/authentication.decorator.js';
@@ -9,6 +13,10 @@ import { plainToClass } from 'class-transformer';
 @Injectable()
 export class BranchService {
   async create(createBranchDto: CreateBranchDto) {
+    const branch = await BranchEntity.findOneBy({ id: createBranchDto.id });
+    if (branch) {
+      throw new BadRequestException('Branch already exists');
+    }
     return await BranchEntity.create({ ...createBranchDto }).save();
   }
 
@@ -21,9 +29,10 @@ export class BranchService {
   }
 
   async getBranchOrError(id: string) {
+    console.log(id);
     const branch = await BranchEntity.findOneBy({ id });
     if (!branch) {
-      throw new NotFoundException('Menu item not found');
+      throw new NotFoundException('Branch not found');
     }
     return branch;
   }

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

@@ -1,6 +1,9 @@
 import { IsString } from 'class-validator';
 
 export class CreateBranchDto {
+  @IsString()
+  id: string;
+
   @IsString()
   name: string;
 

backend/src/modules/menu-item/menu-item.module.ts

@@ -5,5 +5,6 @@ import { MenuItemController } from './menu-item.controller.js';
 @Module({
   controllers: [MenuItemController],
   providers: [MenuItemService],
+  exports: [MenuItemService],
 })
 export class MenuItemModule {}

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

@@ -0,0 +1,26 @@
+import {
+  IsArray,
+  IsEnum,
+  IsNumber,
+  IsObject,
+  IsOptional,
+  IsString,
+  ValidateNested,
+} from 'class-validator';
+import { OrderType } from '../../../common/enums/OrderType.enum.js';
+import { OrderItemsDto } from './order-items.dto.js';
+import { Type } from 'class-transformer';
+
+export class CreateOrderDto {
+  @IsOptional()
+  @IsNumber()
+  table_number?: number;
+
+  @IsEnum(OrderType)
+  order_type: OrderType;
+
+  @IsArray()
+  @ValidateNested()
+  @Type(() => OrderItemsDto)
+  order_items: OrderItemsDto[];
+}

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

@@ -0,0 +1,9 @@
+import { IsNumber, IsString } from 'class-validator';
+
+export class OrderItemsDto {
+  @IsString()
+  menu_id: string;
+
+  @IsNumber()
+  quantity: number;
+}

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

@@ -0,0 +1,66 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Body,
+  Patch,
+  Param,
+  Delete,
+  Req,
+} from '@nestjs/common';
+import { OrderService } from './order.service.js';
+import { CreateOrderDto } from './dto/create-order.dto.js';
+import { Role } from '../../common/enums/role.enum.js';
+
+@Controller('branchs/:branchId/orders')
+export class OrderController {
+  constructor(private readonly orderService: OrderService) {}
+
+  @Post()
+  async create(
+    @Param('branchId') branchId: string,
+    @Req() req: Request,
+    @Body() createOrderDto: CreateOrderDto,
+  ) {
+    const userId = req['user'].sub;
+    const role = req['user'].roles;
+    console.log(req['user']);
+    if (role == Role.CUSTOMER)
+      return this.orderService.createFromCustomer(
+        branchId,
+        userId,
+        createOrderDto,
+      );
+    else
+      return this.orderService.createFromStaff(
+        branchId,
+        userId,
+        createOrderDto,
+      );
+  }
+
+  @Get()
+  async findAll(@Req() req: Request) {
+    const userId = req['user'].sub;
+    console.log(req['user']);
+    return this.orderService.findAll();
+  }
+
+  @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);
+  // }
+
+  @Delete(':id')
+  remove(@Param('id') id: string) {
+    return this.orderService.remove(+id);
+  }
+}

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

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { OrderService } from './order.service.js';
+import { 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],
+  providers: [OrderService],
+})
+export class OrderModule {}

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

@@ -0,0 +1,137 @@
+import { BadRequestException, Injectable } from '@nestjs/common';
+import { CreateOrderDto } from './dto/create-order.dto.js';
+import { UserEntity } from '../../entities/user.entity.js';
+import { OrderEntity } from '../../entities/order.entity.js';
+import { BranchService } from '../branch/branch.service.js';
+import { OrderType } from '../../common/enums/OrderType.enum.js';
+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';
+
+@Injectable()
+export class OrderService {
+  constructor(private readonly branchService: BranchService) {}
+  async createFromCustomer(
+    branchId: string,
+    userId: string,
+    createOrderDto: CreateOrderDto,
+  ) {
+    console.log('??');
+    if (createOrderDto.order_type != OrderType.ONLINE) {
+      throw new BadRequestException('customer cannot create offline order');
+    }
+
+    const user = await UserEntity.findOneBy({ id: userId });
+    if (!user) {
+      throw new BadRequestException('User not found');
+    }
+    const branch = await this.branchService.getBranchOrError(branchId);
+    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();
+
+    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);
+    }
+    await order.save();
+    order.total_value = totalValue;
+    await OrderItemEntity.save(orderItems);
+    return { ...order, order_items: orderItems };
+  }
+
+  async createFromStaff(
+    branchId: string,
+    userId: string,
+    createOrderDto: CreateOrderDto,
+  ) {
+    if (createOrderDto.order_type == OrderType.ONLINE) {
+      throw new BadRequestException('staff cannot create online order');
+    }
+    // staff
+    const staff = await UserEntity.findOneBy({ id: userId });
+    const branch = await this.branchService.getBranchOrError(branchId);
+    const order = OrderEntity.create();
+
+    order.branch = branch;
+    order.staff = staff;
+    order.order_type = createOrderDto.order_type;
+    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 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 order.save();
+    order.total_value = totalValue;
+    await OrderItemEntity.save(orderItems);
+    return { ...order, order_items: orderItems };
+  }
+
+  findAll() {
+    return `This action returns all order`;
+  }
+
+  findOne(id: number) {
+    return `This action returns a #${id} order`;
+  }
+
+  remove(id: number) {
+    return `This action removes a #${id} order`;
+  }
+}