Prepare Hugging Face Space deployment

.dockerignore

@@ -0,0 +1,10 @@
+frontend/node_modules
+frontend/.next
+backend/node_modules
+backend/dist
+backend/course_subscription.sqlite
+backend/uploads
+.git
+.trae
+npm-debug.log*
+yarn-error.log*

.gitignore

@@ -0,0 +1,9 @@
+frontend/node_modules
+frontend/.next
+backend/node_modules
+backend/dist
+backend/course_subscription.sqlite
+backend/uploads
+.trae
+npm-debug.log*
+yarn-error.log*

Dockerfile

@@ -0,0 +1,21 @@
+FROM node:20-bullseye-slim
+
+WORKDIR /app
+
+COPY frontend/package*.json ./frontend/
+COPY backend/package*.json ./backend/
+
+RUN npm --prefix frontend ci && npm --prefix backend ci
+
+COPY frontend ./frontend
+COPY backend ./backend
+
+RUN npm --prefix frontend run build && npm --prefix backend run build
+
+ENV NODE_ENV=production
+ENV SPACE_PORT=7860
+ENV BACKEND_INTERNAL_URL=http://127.0.0.1:3001
+
+EXPOSE 7860
+
+CMD ["sh", "-c", "PORT=3001 npm --prefix backend run start:prod & npm --prefix frontend run start -- -H 0.0.0.0 -p ${SPACE_PORT}"]

backend/.env

@@ -0,0 +1,7 @@
+DB_HOST=localhost
+DB_PORT=3306
+DB_USERNAME=root
+DB_PASSWORD=root
+DB_DATABASE=course_subscription
+JWT_SECRET=super_secret_jwt_key_for_course_subscription
+PORT=3001

backend/.eslintrc.js

@@ -0,0 +1,25 @@
+module.exports = {
+  parser: '@typescript-eslint/parser',
+  parserOptions: {
+    project: 'tsconfig.json',
+    tsconfigRootDir: __dirname,
+    sourceType: 'module',
+  },
+  plugins: ['@typescript-eslint/eslint-plugin'],
+  extends: [
+    'plugin:@typescript-eslint/recommended',
+    'plugin:prettier/recommended',
+  ],
+  root: true,
+  env: {
+    node: true,
+    jest: true,
+  },
+  ignorePatterns: ['.eslintrc.js'],
+  rules: {
+    '@typescript-eslint/interface-name-prefix': 'off',
+    '@typescript-eslint/explicit-function-return-type': 'off',
+    '@typescript-eslint/explicit-module-boundary-types': 'off',
+    '@typescript-eslint/no-explicit-any': 'off',
+  },
+};

backend/.prettierrc

@@ -0,0 +1,4 @@
+{
+  "singleQuote": true,
+  "trailingComma": "all"
+}

backend/README.md

@@ -0,0 +1,99 @@
+<p align="center">
+  <a href="http://nestjs.com/" target="blank"><img src="https://nestjs.com/img/logo-small.svg" width="120" alt="Nest Logo" /></a>
+</p>
+
+[circleci-image]: https://img.shields.io/circleci/build/github/nestjs/nest/master?token=abc123def456
+[circleci-url]: https://circleci.com/gh/nestjs/nest
+
+  <p align="center">A progressive <a href="http://nodejs.org" target="_blank">Node.js</a> framework for building efficient and scalable server-side applications.</p>
+    <p align="center">
+<a href="https://www.npmjs.com/~nestjscore" target="_blank"><img src="https://img.shields.io/npm/v/@nestjs/core.svg" alt="NPM Version" /></a>
+<a href="https://www.npmjs.com/~nestjscore" target="_blank"><img src="https://img.shields.io/npm/l/@nestjs/core.svg" alt="Package License" /></a>
+<a href="https://www.npmjs.com/~nestjscore" target="_blank"><img src="https://img.shields.io/npm/dm/@nestjs/common.svg" alt="NPM Downloads" /></a>
+<a href="https://circleci.com/gh/nestjs/nest" target="_blank"><img src="https://img.shields.io/circleci/build/github/nestjs/nest/master" alt="CircleCI" /></a>
+<a href="https://coveralls.io/github/nestjs/nest?branch=master" target="_blank"><img src="https://coveralls.io/repos/github/nestjs/nest/badge.svg?branch=master#9" alt="Coverage" /></a>
+<a href="https://discord.gg/G7Qnnhy" target="_blank"><img src="https://img.shields.io/badge/discord-online-brightgreen.svg" alt="Discord"/></a>
+<a href="https://opencollective.com/nest#backer" target="_blank"><img src="https://opencollective.com/nest/backers/badge.svg" alt="Backers on Open Collective" /></a>
+<a href="https://opencollective.com/nest#sponsor" target="_blank"><img src="https://opencollective.com/nest/sponsors/badge.svg" alt="Sponsors on Open Collective" /></a>
+  <a href="https://paypal.me/kamilmysliwiec" target="_blank"><img src="https://img.shields.io/badge/Donate-PayPal-ff3f59.svg" alt="Donate us"/></a>
+    <a href="https://opencollective.com/nest#sponsor"  target="_blank"><img src="https://img.shields.io/badge/Support%20us-Open%20Collective-41B883.svg" alt="Support us"></a>
+  <a href="https://twitter.com/nestframework" target="_blank"><img src="https://img.shields.io/twitter/follow/nestframework.svg?style=social&label=Follow" alt="Follow us on Twitter"></a>
+</p>
+  <!--[![Backers on Open Collective](https://opencollective.com/nest/backers/badge.svg)](https://opencollective.com/nest#backer)
+  [![Sponsors on Open Collective](https://opencollective.com/nest/sponsors/badge.svg)](https://opencollective.com/nest#sponsor)-->
+
+## Description
+
+[Nest](https://github.com/nestjs/nest) framework TypeScript starter repository.
+
+## Project setup
+
+```bash
+$ npm install
+```
+
+## Compile and run the project
+
+```bash
+# development
+$ npm run start
+
+# watch mode
+$ npm run start:dev
+
+# production mode
+$ npm run start:prod
+```
+
+## Run tests
+
+```bash
+# unit tests
+$ npm run test
+
+# e2e tests
+$ npm run test:e2e
+
+# test coverage
+$ npm run test:cov
+```
+
+## Deployment
+
+When you're ready to deploy your NestJS application to production, there are some key steps you can take to ensure it runs as efficiently as possible. Check out the [deployment documentation](https://docs.nestjs.com/deployment) for more information.
+
+If you are looking for a cloud-based platform to deploy your NestJS application, check out [Mau](https://mau.nestjs.com), our official platform for deploying NestJS applications on AWS. Mau makes deployment straightforward and fast, requiring just a few simple steps:
+
+```bash
+$ npm install -g mau
+$ mau deploy
+```
+
+With Mau, you can deploy your application in just a few clicks, allowing you to focus on building features rather than managing infrastructure.
+
+## Resources
+
+Check out a few resources that may come in handy when working with NestJS:
+
+- Visit the [NestJS Documentation](https://docs.nestjs.com) to learn more about the framework.
+- For questions and support, please visit our [Discord channel](https://discord.gg/G7Qnnhy).
+- To dive deeper and get more hands-on experience, check out our official video [courses](https://courses.nestjs.com/).
+- Deploy your application to AWS with the help of [NestJS Mau](https://mau.nestjs.com) in just a few clicks.
+- Visualize your application graph and interact with the NestJS application in real-time using [NestJS Devtools](https://devtools.nestjs.com).
+- Need help with your project (part-time to full-time)? Check out our official [enterprise support](https://enterprise.nestjs.com).
+- To stay in the loop and get updates, follow us on [X](https://x.com/nestframework) and [LinkedIn](https://linkedin.com/company/nestjs).
+- Looking for a job, or have a job to offer? Check out our official [Jobs board](https://jobs.nestjs.com).
+
+## Support
+
+Nest is an MIT-licensed open source project. It can grow thanks to the sponsors and support by the amazing backers. If you'd like to join them, please [read more here](https://docs.nestjs.com/support).
+
+## Stay in touch
+
+- Author - [Kamil Myśliwiec](https://twitter.com/kammysliwiec)
+- Website - [https://nestjs.com](https://nestjs.com/)
+- Twitter - [@nestframework](https://twitter.com/nestframework)
+
+## License
+
+Nest is [MIT licensed](https://github.com/nestjs/nest/blob/master/LICENSE).

backend/nest-cli.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://json.schemastore.org/nest-cli",
+  "collection": "@nestjs/schematics",
+  "sourceRoot": "src",
+  "compilerOptions": {
+    "deleteOutDir": true
+  }
+}

backend/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "backend",
+  "version": "0.0.1",
+  "description": "",
+  "author": "",
+  "private": true,
+  "license": "UNLICENSED",
+  "scripts": {
+    "build": "nest build",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "start": "nest start",
+    "start:dev": "nest start --watch",
+    "start:debug": "nest start --debug --watch",
+    "start:prod": "node dist/main",
+    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:cov": "jest --coverage",
+    "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
+    "test:e2e": "jest --config ./test/jest-e2e.json"
+  },
+  "dependencies": {
+    "@nestjs/common": "^10.0.0",
+    "@nestjs/config": "^4.0.3",
+    "@nestjs/core": "^10.0.0",
+    "@nestjs/jwt": "^11.0.2",
+    "@nestjs/passport": "^11.0.5",
+    "@nestjs/platform-express": "^10.0.0",
+    "@nestjs/typeorm": "^11.0.0",
+    "bcrypt": "^6.0.0",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.15.1",
+    "multer": "^2.1.1",
+    "mysql2": "^3.20.0",
+    "passport": "^0.7.0",
+    "passport-jwt": "^4.0.1",
+    "reflect-metadata": "^0.2.0",
+    "rxjs": "^7.8.1",
+    "sqlite3": "^5.1.7",
+    "typeorm": "^0.3.28"
+  },
+  "devDependencies": {
+    "@nestjs/cli": "^10.0.0",
+    "@nestjs/schematics": "^10.0.0",
+    "@nestjs/testing": "^10.0.0",
+    "@types/bcrypt": "^6.0.0",
+    "@types/express": "^5.0.0",
+    "@types/jest": "^29.5.2",
+    "@types/multer": "^2.1.0",
+    "@types/node": "^20.3.1",
+    "@types/passport-jwt": "^4.0.1",
+    "@types/supertest": "^6.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "eslint": "^8.0.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-prettier": "^5.0.0",
+    "jest": "^29.5.0",
+    "prettier": "^3.0.0",
+    "source-map-support": "^0.5.21",
+    "supertest": "^7.0.0",
+    "ts-jest": "^29.1.0",
+    "ts-loader": "^9.4.3",
+    "ts-node": "^10.9.1",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.1.3"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": "src",
+    "testRegex": ".*\\.spec\\.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "collectCoverageFrom": [
+      "**/*.(t|j)s"
+    ],
+    "coverageDirectory": "../coverage",
+    "testEnvironment": "node"
+  }
+}

backend/src/admin/admin.controller.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AdminController } from './admin.controller';
+
+describe('AdminController', () => {
+  let controller: AdminController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [AdminController],
+    }).compile();
+
+    controller = module.get<AdminController>(AdminController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

backend/src/admin/admin.controller.ts

@@ -0,0 +1,32 @@
+import { Controller, Post, Get, Put, Param, Body, UseGuards } from '@nestjs/common';
+import { AdminService } from './admin.service';
+import { CreateCourseDto } from './dto/create-course.dto';
+import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
+import { RolesGuard } from '../auth/guards/roles.guard';
+import { Roles } from '../auth/decorators/roles.decorator';
+import { UserRole } from '../entities/user.entity';
+
+@Controller('api/admin')
+@UseGuards(JwtAuthGuard, RolesGuard)
+@Roles(UserRole.ADMIN)
+export class AdminController {
+  constructor(private readonly adminService: AdminService) {}
+
+  @Post('courses')
+  async createCourse(@Body() createCourseDto: CreateCourseDto) {
+    const data = await this.adminService.createCourse(createCourseDto);
+    return { success: true, data };
+  }
+
+  @Put('courses/:id')
+  async updateCourse(@Param('id') id: string, @Body() updateData: Partial<CreateCourseDto>) {
+    const data = await this.adminService.updateCourse(Number(id), updateData);
+    return { success: true, data };
+  }
+
+  @Get('orders')
+  async getOrders() {
+    const data = await this.adminService.getOrders();
+    return { success: true, data };
+  }
+}

backend/src/admin/admin.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { AdminService } from './admin.service';
+import { AdminController } from './admin.controller';
+import { Course } from '../entities/course.entity';
+import { Order } from '../entities/order.entity';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Course, Order])],
+  providers: [AdminService],
+  controllers: [AdminController]
+})
+export class AdminModule {}

backend/src/admin/admin.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AdminService } from './admin.service';
+
+describe('AdminService', () => {
+  let service: AdminService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [AdminService],
+    }).compile();
+
+    service = module.get<AdminService>(AdminService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

backend/src/admin/admin.service.ts

@@ -0,0 +1,33 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { Course } from '../entities/course.entity';
+import { Order } from '../entities/order.entity';
+import { CreateCourseDto } from './dto/create-course.dto';
+
+@Injectable()
+export class AdminService {
+  constructor(
+    @InjectRepository(Course)
+    private courseRepository: Repository<Course>,
+    @InjectRepository(Order)
+    private orderRepository: Repository<Order>,
+  ) {}
+
+  async createCourse(createCourseDto: CreateCourseDto) {
+    const course = this.courseRepository.create(createCourseDto);
+    return this.courseRepository.save(course);
+  }
+
+  async updateCourse(id: number, updateData: Partial<CreateCourseDto>) {
+    await this.courseRepository.update(id, updateData);
+    return this.courseRepository.findOne({ where: { id } });
+  }
+
+  async getOrders() {
+    return this.orderRepository.find({
+      relations: ['user', 'course'],
+      order: { createdAt: 'DESC' },
+    });
+  }
+}

backend/src/admin/dto/create-course.dto.ts

@@ -0,0 +1,27 @@
+import { IsString, IsNotEmpty, IsNumber, IsOptional } from 'class-validator';
+
+export class CreateCourseDto {
+  @IsString()
+  @IsNotEmpty()
+  title: string;
+
+  @IsString()
+  @IsOptional()
+  description?: string;
+
+  @IsString()
+  @IsNotEmpty()
+  coverImage: string;
+
+  @IsString()
+  @IsNotEmpty()
+  driveLink: string;
+
+  @IsNumber()
+  @IsNotEmpty()
+  price: number;
+
+  @IsString()
+  @IsOptional()
+  category?: string;
+}

backend/src/app.controller.spec.ts

@@ -0,0 +1,22 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
+
+describe('AppController', () => {
+  let appController: AppController;
+
+  beforeEach(async () => {
+    const app: TestingModule = await Test.createTestingModule({
+      controllers: [AppController],
+      providers: [AppService],
+    }).compile();
+
+    appController = app.get<AppController>(AppController);
+  });
+
+  describe('root', () => {
+    it('should return "Hello World!"', () => {
+      expect(appController.getHello()).toBe('Hello World!');
+    });
+  });
+});

backend/src/app.controller.ts

@@ -0,0 +1,34 @@
+import { Controller, Get, Post, UseInterceptors, UploadedFile } from '@nestjs/common';
+import { FileInterceptor } from '@nestjs/platform-express';
+import { AppService } from './app.service';
+import { diskStorage } from 'multer';
+import { extname } from 'path';
+
+@Controller()
+export class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get()
+  getHello(): string {
+    return this.appService.getHello();
+  }
+
+  @Post('api/upload')
+  @UseInterceptors(FileInterceptor('file', {
+    storage: diskStorage({
+      destination: './uploads',
+      filename: (req, file, cb) => {
+        const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1e9);
+        cb(null, `${uniqueSuffix}${extname(file.originalname)}`);
+      },
+    }),
+  }))
+  uploadFile(@UploadedFile() file: Express.Multer.File) {
+    // Return the URL to access the uploaded file
+    // Note: ensure we serve this directory statically
+    return {
+      success: true,
+      url: `/uploads/${file.filename}`,
+    };
+  }
+}

backend/src/app.module.ts

@@ -0,0 +1,37 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
+import { User } from './entities/user.entity';
+import { Course } from './entities/course.entity';
+import { Order } from './entities/order.entity';
+import { Payment } from './entities/payment.entity';
+import { UserCourse } from './entities/user-course.entity';
+import { AuthModule } from './auth/auth.module';
+import { CoursesModule } from './courses/courses.module';
+import { OrdersModule } from './orders/orders.module';
+import { AdminModule } from './admin/admin.module';
+import { PaymentModule } from './payment/payment.module';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({
+      isGlobal: true,
+    }),
+    TypeOrmModule.forRoot({
+      type: 'sqlite',
+      database: 'course_subscription.sqlite',
+      entities: [User, Course, Order, Payment, UserCourse],
+      synchronize: true, // Auto-create tables in dev
+    }),
+    AuthModule,
+    CoursesModule,
+    OrdersModule,
+    AdminModule,
+    PaymentModule,
+  ],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}

backend/src/app.service.ts

@@ -0,0 +1,8 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class AppService {
+  getHello(): string {
+    return 'Hello World!';
+  }
+}

backend/src/auth/auth.controller.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AuthController } from './auth.controller';
+
+describe('AuthController', () => {
+  let controller: AuthController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [AuthController],
+    }).compile();
+
+    controller = module.get<AuthController>(AuthController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

backend/src/auth/auth.controller.ts

@@ -0,0 +1,29 @@
+import { Controller, Post, Body, Get, UseGuards, Request } from '@nestjs/common';
+import { AuthService } from './auth.service';
+import { RegisterDto } from './dto/register.dto';
+import { LoginDto } from './dto/login.dto';
+import { JwtAuthGuard } from './guards/jwt-auth.guard';
+
+@Controller('api/auth')
+export class AuthController {
+  constructor(private readonly authService: AuthService) {}
+
+  @Post('register')
+  async register(@Body() registerDto: RegisterDto) {
+    const data = await this.authService.register(registerDto);
+    return { success: true, data };
+  }
+
+  @Post('login')
+  async login(@Body() loginDto: LoginDto) {
+    const data = await this.authService.login(loginDto);
+    return { success: true, data };
+  }
+
+  @UseGuards(JwtAuthGuard)
+  @Get('profile')
+  async getProfile(@Request() req) {
+    const data = await this.authService.getProfile(req.user.userId);
+    return { success: true, data };
+  }
+}

backend/src/auth/auth.module.ts

@@ -0,0 +1,28 @@
+import { Module } from '@nestjs/common';
+import { JwtModule } from '@nestjs/jwt';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { PassportModule } from '@nestjs/passport';
+import { AuthService } from './auth.service';
+import { AuthController } from './auth.controller';
+import { User } from '../entities/user.entity';
+import { JwtStrategy } from './strategies/jwt.strategy';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([User]),
+    PassportModule,
+    JwtModule.registerAsync({
+      imports: [ConfigModule],
+      useFactory: async (configService: ConfigService) => ({
+        secret: configService.get<string>('JWT_SECRET'),
+        signOptions: { expiresIn: '7d' },
+      }),
+      inject: [ConfigService],
+    }),
+  ],
+  providers: [AuthService, JwtStrategy],
+  controllers: [AuthController],
+  exports: [AuthService],
+})
+export class AuthModule {}

backend/src/auth/auth.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AuthService } from './auth.service';
+
+describe('AuthService', () => {
+  let service: AuthService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [AuthService],
+    }).compile();
+
+    service = module.get<AuthService>(AuthService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

backend/src/auth/auth.service.ts

@@ -0,0 +1,103 @@
+import { Injectable, UnauthorizedException, BadRequestException, OnModuleInit } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import * as bcrypt from 'bcrypt';
+import { User, UserRole } from '../entities/user.entity';
+import { RegisterDto } from './dto/register.dto';
+import { LoginDto } from './dto/login.dto';
+
+@Injectable()
+export class AuthService implements OnModuleInit {
+  constructor(
+    @InjectRepository(User)
+    private userRepository: Repository<User>,
+    private jwtService: JwtService,
+  ) {}
+
+  async onModuleInit() {
+    const adminPhone = '12345678912';
+    const adminExists = await this.userRepository.findOne({ where: { phone: adminPhone } });
+    if (!adminExists) {
+      const salt = await bcrypt.genSalt();
+      const passwordHash = await bcrypt.hash('123456', salt);
+      const adminUser = this.userRepository.create({
+        phone: adminPhone,
+        passwordHash,
+        nickname: 'Admin',
+        role: UserRole.ADMIN,
+      });
+      await this.userRepository.save(adminUser);
+      console.log(`Admin user initialized: ${adminPhone}`);
+    } else {
+      // Ensure the role is ADMIN and update password if needed
+      if (adminExists.role !== UserRole.ADMIN) {
+        adminExists.role = UserRole.ADMIN;
+        await this.userRepository.save(adminExists);
+      }
+    }
+  }
+
+  async register(registerDto: RegisterDto) {
+    const { phone, password, smsCode } = registerDto;
+
+    // In a real app, verify smsCode here
+    if (smsCode !== '123456') {
+      throw new BadRequestException('Invalid SMS code');
+    }
+
+    const existingUser = await this.userRepository.findOne({ where: { phone } });
+    if (existingUser) {
+      throw new BadRequestException('User already exists');
+    }
+
+    const salt = await bcrypt.genSalt();
+    const passwordHash = await bcrypt.hash(password, salt);
+
+    const user = this.userRepository.create({
+      phone,
+      passwordHash,
+      nickname: `User_${phone.slice(-4)}`,
+      role: UserRole.USER,
+    });
+
+    await this.userRepository.save(user);
+
+    return this.login({ phone, password });
+  }
+
+  async login(loginDto: LoginDto) {
+    const { phone, password } = loginDto;
+    const user = await this.userRepository.findOne({ where: { phone } });
+
+    if (!user) {
+      throw new UnauthorizedException('Invalid credentials');
+    }
+
+    const isMatch = await bcrypt.compare(password, user.passwordHash);
+    if (!isMatch) {
+      throw new UnauthorizedException('Invalid credentials');
+    }
+
+    const payload = { sub: user.id, phone: user.phone, role: user.role };
+    return {
+      userId: user.id,
+      token: this.jwtService.sign(payload),
+      role: user.role,
+      nickname: user.nickname,
+    };
+  }
+  
+  async getProfile(userId: number) {
+    const user = await this.userRepository.findOne({ 
+      where: { id: userId },
+      select: ['id', 'phone', 'email', 'nickname', 'avatar', 'role', 'createdAt']
+    });
+    
+    if (!user) {
+      throw new UnauthorizedException('User not found');
+    }
+    
+    return user;
+  }
+}

backend/src/auth/decorators/roles.decorator.ts

@@ -0,0 +1,4 @@
+import { SetMetadata } from '@nestjs/common';
+import { UserRole } from '../../entities/user.entity';
+
+export const Roles = (...roles: UserRole[]) => SetMetadata('roles', roles);

backend/src/auth/dto/login.dto.ts

@@ -0,0 +1,11 @@
+import { IsString, IsNotEmpty } from 'class-validator';
+
+export class LoginDto {
+  @IsString()
+  @IsNotEmpty()
+  phone: string;
+
+  @IsString()
+  @IsNotEmpty()
+  password: string;
+}

backend/src/auth/dto/register.dto.ts

@@ -0,0 +1,17 @@
+import { IsString, IsNotEmpty, Length } from 'class-validator';
+
+export class RegisterDto {
+  @IsString()
+  @IsNotEmpty()
+  @Length(11, 11)
+  phone: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @Length(6, 20)
+  password: string;
+
+  @IsString()
+  @IsNotEmpty()
+  smsCode: string;
+}

backend/src/auth/guards/jwt-auth.guard.ts

@@ -0,0 +1,5 @@
+import { Injectable } from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+
+@Injectable()
+export class JwtAuthGuard extends AuthGuard('jwt') {}

backend/src/auth/guards/roles.guard.ts

@@ -0,0 +1,22 @@
+import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { UserRole } from '../../entities/user.entity';
+
+@Injectable()
+export class RolesGuard implements CanActivate {
+  constructor(private reflector: Reflector) {}
+
+  canActivate(context: ExecutionContext): boolean {
+    const requiredRoles = this.reflector.getAllAndOverride<UserRole[]>('roles', [
+      context.getHandler(),
+      context.getClass(),
+    ]);
+    
+    if (!requiredRoles) {
+      return true;
+    }
+    
+    const { user } = context.switchToHttp().getRequest();
+    return requiredRoles.some((role) => user?.role === role);
+  }
+}

backend/src/auth/strategies/jwt.strategy.ts

@@ -0,0 +1,31 @@
+import { ExtractJwt, Strategy } from 'passport-jwt';
+import { PassportStrategy } from '@nestjs/passport';
+import { Injectable, UnauthorizedException } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { User } from '../../entities/user.entity';
+
+@Injectable()
+export class JwtStrategy extends PassportStrategy(Strategy) {
+  constructor(
+    private configService: ConfigService,
+    @InjectRepository(User)
+    private userRepository: Repository<User>,
+  ) {
+    super({
+      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
+      ignoreExpiration: false,
+      secretOrKey: configService.get<string>('JWT_SECRET') || 'secret',
+    });
+  }
+
+  async validate(payload: any) {
+    const user = await this.userRepository.findOne({ where: { id: payload.sub } });
+    if (!user) {
+      throw new UnauthorizedException();
+    }
+    // Return data to be attached to the request object
+    return { userId: user.id, phone: user.phone, role: user.role };
+  }
+}

backend/src/courses/courses.controller.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { CoursesController } from './courses.controller';
+
+describe('CoursesController', () => {
+  let controller: CoursesController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [CoursesController],
+    }).compile();
+
+    controller = module.get<CoursesController>(CoursesController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

backend/src/courses/courses.controller.ts

@@ -0,0 +1,34 @@
+import { Controller, Get, Param, UseGuards, Request, ParseIntPipe } from '@nestjs/common';
+import { CoursesService } from './courses.service';
+import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
+
+@Controller('api/courses')
+export class CoursesController {
+  constructor(private readonly coursesService: CoursesService) {}
+
+  @Get()
+  async findAll() {
+    const data = await this.coursesService.findAll();
+    return { success: true, data };
+  }
+
+  @UseGuards(JwtAuthGuard)
+  @Get('my')
+  async findMyCourses(@Request() req) {
+    const data = await this.coursesService.getUserCourses(req.user.userId);
+    return { success: true, data };
+  }
+
+  @Get(':id')
+  async findOne(@Param('id', ParseIntPipe) id: number) {
+    const data = await this.coursesService.findOne(id);
+    return { success: true, data };
+  }
+
+  @UseGuards(JwtAuthGuard)
+  @Get(':id/access')
+  async getAccess(@Param('id', ParseIntPipe) id: number, @Request() req) {
+    const data = await this.coursesService.getCourseAccess(req.user.userId, id);
+    return { success: true, data };
+  }
+}

backend/src/courses/courses.module.ts

@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { CoursesService } from './courses.service';
+import { CoursesController } from './courses.controller';
+import { Course } from '../entities/course.entity';
+import { UserCourse } from '../entities/user-course.entity';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Course, UserCourse])],
+  providers: [CoursesService],
+  controllers: [CoursesController],
+  exports: [CoursesService],
+})
+export class CoursesModule {}

backend/src/courses/courses.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { CoursesService } from './courses.service';
+
+describe('CoursesService', () => {
+  let service: CoursesService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [CoursesService],
+    }).compile();
+
+    service = module.get<CoursesService>(CoursesService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

backend/src/courses/courses.service.ts

@@ -0,0 +1,71 @@
+import { Injectable, NotFoundException, ForbiddenException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { Course } from '../entities/course.entity';
+import { UserCourse } from '../entities/user-course.entity';
+
+@Injectable()
+export class CoursesService {
+  constructor(
+    @InjectRepository(Course)
+    private courseRepository: Repository<Course>,
+    @InjectRepository(UserCourse)
+    private userCourseRepository: Repository<UserCourse>,
+  ) {}
+
+  async findAll() {
+    return this.courseRepository.find({
+      where: { isActive: true },
+      select: ['id', 'title', 'description', 'coverImage', 'price', 'category'],
+      order: { createdAt: 'DESC' },
+    });
+  }
+
+  async findOne(id: number) {
+    const course = await this.courseRepository.findOne({
+      where: { id, isActive: true },
+      select: ['id', 'title', 'description', 'coverImage', 'price', 'category'],
+    });
+
+    if (!course) {
+      throw new NotFoundException('Course not found');
+    }
+
+    return course;
+  }
+
+  async getUserCourses(userId: number) {
+    const userCourses = await this.userCourseRepository.find({
+      where: { userId },
+      relations: ['course'],
+    });
+
+    return userCourses.map(uc => ({
+      id: uc.course.id,
+      title: uc.course.title,
+      coverImage: uc.course.coverImage,
+      expiredAt: uc.expiredAt,
+    }));
+  }
+
+  async getCourseAccess(userId: number, courseId: number) {
+    const userCourse = await this.userCourseRepository.findOne({
+      where: { userId, courseId },
+      relations: ['course'],
+    });
+
+    if (!userCourse) {
+      throw new ForbiddenException('You have not purchased this course');
+    }
+
+    if (userCourse.expiredAt < new Date()) {
+      throw new ForbiddenException('Your access to this course has expired');
+    }
+
+    return {
+      hasAccess: true,
+      driveLink: userCourse.course.driveLink, // In a real app, this should be a dynamic signed URL
+      expiredAt: userCourse.expiredAt,
+    };
+  }
+}

backend/src/entities/course.entity.ts

@@ -0,0 +1,49 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  OneToMany,
+} from 'typeorm';
+import { Order } from './order.entity';
+import { UserCourse } from './user-course.entity';
+
+@Entity('courses')
+export class Course {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ type: 'varchar', length: 200 })
+  title: string;
+
+  @Column({ type: 'text', nullable: true })
+  description: string;
+
+  @Column({ type: 'varchar', length: 255, name: 'cover_image' })
+  coverImage: string;
+
+  @Column({ type: 'varchar', length: 500, name: 'drive_link' })
+  driveLink: string;
+
+  @Column({ type: 'decimal', precision: 10, scale: 2 })
+  price: number;
+
+  @Column({ type: 'varchar', length: 50, nullable: true })
+  category: string;
+
+  @Column({ type: 'boolean', default: true, name: 'is_active' })
+  isActive: boolean;
+
+  @CreateDateColumn({ name: 'created_at' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: 'updated_at' })
+  updatedAt: Date;
+
+  @OneToMany(() => Order, (order) => order.course)
+  orders: Order[];
+
+  @OneToMany(() => UserCourse, (userCourse) => userCourse.course)
+  userCourses: UserCourse[];
+}

backend/src/entities/order.entity.ts

@@ -0,0 +1,57 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  ManyToOne,
+  JoinColumn,
+  OneToMany,
+} from 'typeorm';
+import { User } from './user.entity';
+import { Course } from './course.entity';
+import { Payment } from './payment.entity';
+
+export enum OrderStatus {
+  PENDING = 'pending',
+  PAID = 'paid',
+  CANCELLED = 'cancelled',
+  REFUNDED = 'refunded',
+}
+
+@Entity('orders')
+export class Order {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ type: 'varchar', length: 32, unique: true, name: 'order_no' })
+  orderNo: string;
+
+  @Column({ name: 'user_id' })
+  userId: number;
+
+  @Column({ name: 'course_id' })
+  courseId: number;
+
+  @Column({ type: 'decimal', precision: 10, scale: 2 })
+  amount: number;
+
+  @Column({ type: 'varchar', default: OrderStatus.PENDING })
+  status: OrderStatus;
+
+  @CreateDateColumn({ name: 'created_at' })
+  createdAt: Date;
+
+  @Column({ type: 'datetime', nullable: true, name: 'paid_at' })
+  paidAt: Date;
+
+  @ManyToOne(() => User, (user) => user.orders)
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+
+  @ManyToOne(() => Course, (course) => course.orders)
+  @JoinColumn({ name: 'course_id' })
+  course: Course;
+
+  @OneToMany(() => Payment, (payment) => payment.order)
+  payments: Payment[];
+}

backend/src/entities/payment.entity.ts

@@ -0,0 +1,54 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  ManyToOne,
+  JoinColumn,
+} from 'typeorm';
+import { Order } from './order.entity';
+
+export enum PayType {
+  WECHAT = 'wechat',
+  ALIPAY = 'alipay',
+}
+
+export enum PaymentStatus {
+  PENDING = 'pending',
+  SUCCESS = 'success',
+  FAILED = 'failed',
+}
+
+@Entity('payments')
+export class Payment {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ name: 'order_id' })
+  orderId: number;
+
+  @Column({ type: 'varchar', length: 64, nullable: true, name: 'payment_no' })
+  paymentNo: string;
+
+  @Column({ type: 'varchar', name: 'pay_type' })
+  payType: PayType;
+
+  @Column({ type: 'decimal', precision: 10, scale: 2 })
+  amount: number;
+
+  @Column({ type: 'varchar', default: PaymentStatus.PENDING })
+  status: PaymentStatus;
+
+  @Column({ type: 'simple-json', nullable: true, name: 'callback_data' })
+  callbackData: any;
+
+  @CreateDateColumn({ name: 'created_at' })
+  createdAt: Date;
+
+  @Column({ type: 'datetime', nullable: true, name: 'completed_at' })
+  completedAt: Date;
+
+  @ManyToOne(() => Order, (order) => order.payments)
+  @JoinColumn({ name: 'order_id' })
+  order: Order;
+}

backend/src/entities/user-course.entity.ts

@@ -0,0 +1,41 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  ManyToOne,
+  JoinColumn,
+  Index,
+} from 'typeorm';
+import { User } from './user.entity';
+import { Course } from './course.entity';
+
+@Entity('user_courses')
+@Index(['userId', 'courseId'], { unique: true })
+export class UserCourse {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ name: 'user_id' })
+  userId: number;
+
+  @Column({ name: 'course_id' })
+  courseId: number;
+
+  @Column({ type: 'varchar', length: 64, unique: true, name: 'access_token' })
+  accessToken: string;
+
+  @Column({ type: 'datetime', name: 'expired_at' })
+  expiredAt: Date;
+
+  @CreateDateColumn({ name: 'created_at' })
+  createdAt: Date;
+
+  @ManyToOne(() => User, (user) => user.userCourses)
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+
+  @ManyToOne(() => Course, (course) => course.userCourses)
+  @JoinColumn({ name: 'course_id' })
+  course: Course;
+}

backend/src/entities/user.entity.ts

@@ -0,0 +1,51 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  OneToMany,
+} from 'typeorm';
+import { Order } from './order.entity';
+import { UserCourse } from './user-course.entity';
+
+export enum UserRole {
+  USER = 'user',
+  ADMIN = 'admin',
+}
+
+@Entity('users')
+export class User {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ type: 'varchar', length: 11, unique: true })
+  phone: string;
+
+  @Column({ type: 'varchar', length: 100, unique: true, nullable: true })
+  email: string;
+
+  @Column({ type: 'varchar', length: 255, name: 'password_hash' })
+  passwordHash: string;
+
+  @Column({ type: 'varchar', length: 50 })
+  nickname: string;
+
+  @Column({ type: 'varchar', length: 255, nullable: true })
+  avatar: string;
+
+  @Column({ type: 'varchar', default: UserRole.USER })
+  role: UserRole;
+
+  @CreateDateColumn({ name: 'created_at' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ name: 'updated_at' })
+  updatedAt: Date;
+
+  @OneToMany(() => Order, (order) => order.user)
+  orders: Order[];
+
+  @OneToMany(() => UserCourse, (userCourse) => userCourse.user)
+  userCourses: UserCourse[];
+}

backend/src/main.ts

@@ -0,0 +1,20 @@
+import { NestFactory } from '@nestjs/core';
+import { ValidationPipe } from '@nestjs/common';
+import { NestExpressApplication } from '@nestjs/platform-express';
+import { join } from 'path';
+import { AppModule } from './app.module';
+
+async function bootstrap() {
+  const app = await NestFactory.create<NestExpressApplication>(AppModule);
+  app.enableCors();
+  app.useGlobalPipes(new ValidationPipe());
+  
+  // Serve static files from the uploads directory
+  app.useStaticAssets(join(__dirname, '..', 'uploads'), {
+    prefix: '/uploads/',
+  });
+
+  await app.listen(process.env.PORT ?? 3001);
+}
+bootstrap();
+

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

@@ -0,0 +1,11 @@
+import { IsNumber, IsNotEmpty } from 'class-validator';
+
+export class CreateOrderDto {
+  @IsNumber()
+  @IsNotEmpty()
+  courseId: number;
+
+  @IsNumber()
+  @IsNotEmpty()
+  price: number;
+}

backend/src/orders/orders.controller.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { OrdersController } from './orders.controller';
+
+describe('OrdersController', () => {
+  let controller: OrdersController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [OrdersController],
+    }).compile();
+
+    controller = module.get<OrdersController>(OrdersController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

backend/src/orders/orders.controller.ts

@@ -0,0 +1,28 @@
+import { Controller, Post, Body, Get, Param, UseGuards, Request, ParseIntPipe } from '@nestjs/common';
+import { OrdersService } from './orders.service';
+import { CreateOrderDto } from './dto/create-order.dto';
+import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
+
+@Controller('api/orders')
+@UseGuards(JwtAuthGuard)
+export class OrdersController {
+  constructor(private readonly ordersService: OrdersService) {}
+
+  @Post('create')
+  async create(@Request() req, @Body() createOrderDto: CreateOrderDto) {
+    const data = await this.ordersService.create(req.user.userId, createOrderDto);
+    return { success: true, data };
+  }
+
+  @Get()
+  async findAll(@Request() req) {
+    const data = await this.ordersService.findUserOrders(req.user.userId);
+    return { success: true, data };
+  }
+
+  @Get(':id')
+  async findOne(@Param('id', ParseIntPipe) id: number, @Request() req) {
+    const data = await this.ordersService.findOne(id, req.user.userId);
+    return { success: true, data };
+  }
+}

backend/src/orders/orders.module.ts

@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { OrdersService } from './orders.service';
+import { OrdersController } from './orders.controller';
+import { Order } from '../entities/order.entity';
+import { Course } from '../entities/course.entity';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Order, Course])],
+  providers: [OrdersService],
+  controllers: [OrdersController],
+  exports: [OrdersService],
+})
+export class OrdersModule {}

backend/src/orders/orders.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { OrdersService } from './orders.service';
+
+describe('OrdersService', () => {
+  let service: OrdersService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [OrdersService],
+    }).compile();
+
+    service = module.get<OrdersService>(OrdersService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

backend/src/orders/orders.service.ts

@@ -0,0 +1,67 @@
+import { Injectable, NotFoundException, BadRequestException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { Order, OrderStatus } from '../entities/order.entity';
+import { Course } from '../entities/course.entity';
+import { CreateOrderDto } from './dto/create-order.dto';
+
+@Injectable()
+export class OrdersService {
+  constructor(
+    @InjectRepository(Order)
+    private orderRepository: Repository<Order>,
+    @InjectRepository(Course)
+    private courseRepository: Repository<Course>,
+  ) {}
+
+  async create(userId: number, createOrderDto: CreateOrderDto) {
+    const course = await this.courseRepository.findOne({ where: { id: createOrderDto.courseId } });
+    if (!course) {
+      throw new NotFoundException('Course not found');
+    }
+
+    if (Number(course.price) !== Number(createOrderDto.price)) {
+      throw new BadRequestException('Price mismatch');
+    }
+
+    // Generate simple order number
+    const orderNo = `${new Date().getFullYear()}${(new Date().getMonth() + 1).toString().padStart(2, '0')}${new Date().getDate().toString().padStart(2, '0')}${Math.floor(Math.random() * 10000).toString().padStart(4, '0')}`;
+
+    const order = this.orderRepository.create({
+      orderNo,
+      userId,
+      courseId: course.id,
+      amount: course.price,
+      status: OrderStatus.PENDING,
+    });
+
+    await this.orderRepository.save(order);
+
+    return {
+      orderId: order.id,
+      orderNo: order.orderNo,
+      amount: order.amount,
+    };
+  }
+
+  async findUserOrders(userId: number) {
+    return this.orderRepository.find({
+      where: { userId },
+      relations: ['course'],
+      order: { createdAt: 'DESC' },
+    });
+  }
+
+  async findOne(id: number, userId: number) {
+    const order = await this.orderRepository.findOne({
+      where: { id, userId },
+      relations: ['course'],
+    });
+
+    if (!order) {
+      throw new NotFoundException('Order not found');
+    }
+
+    return order;
+  }
+}

backend/src/payment/dto/prepare-payment.dto.ts

@@ -0,0 +1,12 @@
+import { IsString, IsNotEmpty, IsEnum } from 'class-validator';
+import { PayType } from '../../entities/payment.entity';
+
+export class PreparePaymentDto {
+  @IsString()
+  @IsNotEmpty()
+  orderId: string; // Actually number in our system, but PRD said string, we'll convert
+
+  @IsEnum(PayType)
+  @IsNotEmpty()
+  payType: PayType;
+}

backend/src/payment/payment.controller.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { PaymentController } from './payment.controller';
+
+describe('PaymentController', () => {
+  let controller: PaymentController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [PaymentController],
+    }).compile();
+
+    controller = module.get<PaymentController>(PaymentController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});