feat: add achievements page

apps/api/src/achievement/achievement.controller.ts

@@ -0,0 +1,44 @@
+import { Body, Controller, Get, Post, UseGuards } from '@nestjs/common';
+import { AuthGuard } from 'src/auth/auth.guard';
+import { AchieveService } from './achievement.service';
+import {
+  FindUserDto,
+  UserAchievementDto,
+  publishAchievementDto,
+  setAchievementDto,
+} from './model/pub.dto';
+@Controller('achievement')
+export class AchievementController {
+  constructor(private readonly AchieveService: AchieveService) {}
+
+  // @UseGuards(PubAchievementGuard)
+  @Post('/publish')
+  async publishAchievement(@Body() dto: publishAchievementDto) {
+    return this.AchieveService.PubAchievement(dto);
+  }
+  // @UseGuards(AuthGuard)
+  @Get('/list')
+  async allAchievement() {
+    return this.AchieveService.AllAchievement();
+  }
+
+  @Post('/authUser')
+  async authUser(@Body() dto: FindUserDto) {
+    return this.AchieveService.authUser(dto);
+  }
+  @UseGuards(AuthGuard)
+  @Post('/set')
+  async setAchievement(@Body() dto: setAchievementDto) {
+    return this.AchieveService.setAchievement(dto);
+  }
+  @UseGuards(AuthGuard)
+  @Post('/use')
+  async useAchievement(@Body() dto: UserAchievementDto) {
+    return this.AchieveService.useAchievement(dto);
+  }
+  @UseGuards(AuthGuard)
+  @Post('/allHave')
+  async haveAchievement(@Body() dto: UserAchievementDto) {
+    return this.AchieveService.haveAchievement(dto);
+  }
+}

apps/api/src/achievement/achievement.guard.ts

@@ -0,0 +1,16 @@
+import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
+
+@Injectable()
+export class PubAchievementGuard implements CanActivate {
+  canActivate(context: ExecutionContext): boolean | Promise<boolean> {
+    const request = context.switchToHttp().getRequest();
+    const secretKey = request.body.secretKey; // 获取请求体中的密钥值
+    const compareKey = process.env.PubsecretKey; // 获取环境变量中的密钥值
+    // 在这里进行密钥验证逻辑
+    if (secretKey === compareKey) {
+      return true; // 密钥验证通过，允许使用功能
+    } else {
+      return false; // 密钥验证失败，禁止使用功能
+    }
+  }
+}

apps/api/src/achievement/achievement.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { UserModule } from '../user/user.module';
+import { AchievementController } from './achievement.controller';
+import { AchieveService } from './achievement.service';
+@Module({
+  imports: [UserModule],
+  controllers: [AchievementController],
+  providers: [AchieveService],
+})
+export class AchievementModule {}

apps/api/src/achievement/achievement.service.ts

@@ -0,0 +1,145 @@
+import { achievements, userAchievements, userProfile } from '@earthworm/schema';
+import { HttpException, HttpStatus, Inject, Injectable } from '@nestjs/common';
+import { eq } from 'drizzle-orm';
+import { UserService } from 'src/user/user.service';
+import { DB, DbType } from '../global/providers/db.provider';
+import {
+  FindUserDto,
+  UserAchievementDto,
+  publishAchievementDto,
+  setAchievementDto,
+} from './model/pub.dto';
+@Injectable()
+export class AchieveService {
+  constructor(
+    @Inject(DB) private db: DbType,
+    private userService: UserService,
+  ) {}
+  async authUser(dto: FindUserDto) {
+    const user = await this.userService.findWithPhone(dto);
+    if (!user) {
+      throw new HttpException('不存在该用户', HttpStatus.BAD_REQUEST);
+    }
+    return user;
+  }
+  async useAchievement(dto: UserAchievementDto) {
+    const userAchieve = await this.db.query.userProfile.findFirst({
+      where: eq(userProfile.userID, dto.userID),
+    });
+    if (!userAchieve) {
+      throw new HttpException('当前未设置使用中成就', HttpStatus.BAD_REQUEST);
+    }
+    return userAchieve;
+  }
+  async setAchievement(dto: setAchievementDto) {
+    const haveAchieve = await this.db.query.userAchievements.findFirst({
+      where: eq(userAchievements.achievementID, dto.achievementID),
+    });
+    if (!haveAchieve) {
+      throw new HttpException('不存在该成就', HttpStatus.BAD_REQUEST);
+    }
+    const activeAchieve = await this.db.query.userProfile.findFirst({
+      where: eq(userProfile.userID, dto.userID),
+    });
+    if (activeAchieve) {
+      if (activeAchieve.achievementID === dto.achievementID) {
+        throw new HttpException(
+          '当前成就为使用中成就，请更换其他成就',
+          HttpStatus.BAD_REQUEST,
+        );
+      } else {
+        const res = await this.db
+          .update(userProfile)
+          .set({
+            achievementID: dto.achievementID,
+          })
+          .where(eq(userProfile.userID, dto.userID));
+        if (res) {
+          throw new HttpException('更换成就成功', HttpStatus.OK);
+        }
+      }
+    } else {
+      const res = await this.db
+        .insert(userProfile)
+        .values({ userID: dto.userID, achievementID: dto.achievementID });
+      if (res) {
+        throw new HttpException('设置当前成就为使用中', HttpStatus.OK);
+      }
+    }
+  }
+  async PubAchievement(dto: publishAchievementDto) {
+    const existing = await this.db.query.userAchievements.findMany({
+      where: eq(userAchievements.userID, dto.userID),
+    });
+
+    if (existing) {
+      const existingAchievements = existing.map(
+        (record) => record.achievementID,
+      );
+      const newAchievements = dto.choiceAchievement.filter(
+        (achievementID) =>
+          !existingAchievements.includes(Number(achievementID)),
+      );
+      if (newAchievements.length > 0) {
+        const insertData = newAchievements.map((achievementID) => ({
+          userID: dto.userID,
+          achievementID: Number(achievementID), // Convert achievementID to a number
+        }));
+        const res = await this.db.insert(userAchievements).values(insertData);
+
+        if (res) {
+          throw new HttpException('添加成就完成', HttpStatus.OK);
+        }
+      } else {
+        throw new HttpException('当前用户已经拥有选中成就', HttpStatus.BAD_REQUEST);
+      }
+    } else {
+      const insertData = dto.choiceAchievement.map((achievementID) => ({
+        userID: dto.userID,
+        achievementID: Number(achievementID), // Convert achievementID to a number
+      }));
+      const res = await this.db.insert(userAchievements).values(insertData);
+
+      if (res) {
+        throw new HttpException('添加成就完成', HttpStatus.OK);
+      }
+    }
+  }
+
+  async AllAchievement() {
+    const achievementAll = await this.db
+      .select({
+        id: achievements.id,
+        name: achievements.name,
+        description: achievements.description,
+      })
+      .from(achievements);
+
+    return achievementAll;
+  }
+  async haveAchievement(dto: UserAchievementDto) {
+    const userAchieve = await this.db.query.userAchievements.findMany({
+      where: eq(userAchievements.userID, dto.userID),
+    });
+    if (!userAchieve.length) {
+      throw new HttpException('还没有获得成就', HttpStatus.BAD_REQUEST);
+    }
+    // 查询achievements表，获取详细信息
+    const promises = userAchieve.map(async (achievement) => {
+      const achievementDetails = await this.db.query.achievements.findFirst({
+        where: eq(achievements.id, achievement.achievementID),
+      });
+      if (!achievementDetails) {
+        throw new HttpException('找不到相应的成就信息', HttpStatus.BAD_REQUEST);
+      }
+      return achievementDetails;
+    });
+    const achievementDetails = await Promise.all(promises);
+    const result = userAchieve.map((achievement, index) => ({
+      ...achievementDetails[index],
+      createdAt: achievement.createdAt,
+    }));
+
+    return result;
+  }
+}

apps/api/src/achievement/model/pub.dto.ts

@@ -0,0 +1,37 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsNotEmpty, Length } from 'class-validator';
+
+export class publishAchievementDto {
+  @ApiProperty()
+  @IsNotEmpty({ message: 'secretKey不能为空' })
+  secretKey: string;
+
+  @ApiProperty()
+  @IsNotEmpty({ message: 'userID不能为空' })
+  userID: number;
+
+  @ApiProperty()
+  @IsNotEmpty({ message: 'choiceAchievement不能为空' })
+  // choiceAchievement: number;
+  choiceAchievement: number[];
+}
+export class FindUserDto {
+  @ApiProperty()
+  @IsNotEmpty({ message: '手机号码不能为空' })
+  @Length(6, 20, { message: '手机号码长度应在6到20位之间' })
+  phone: string;
+}
+export class UserAchievementDto {
+  @ApiProperty()
+  @IsNotEmpty({ message: 'userID不能为空' })
+  userID: number;
+}
+export class setAchievementDto {
+  @ApiProperty()
+  @IsNotEmpty({ message: 'userID不能为空' })
+  userID: number;
+
+  @ApiProperty()
+  @IsNotEmpty({ message: 'achievementID不能为空' })
+  achievementID: number;
+}

apps/api/src/app/app.module.ts

@@ -1,19 +1,20 @@
+import { RedisModule } from '@nestjs-modules/ioredis';
 import { Module } from '@nestjs/common';
-import { GlobalModule } from '../global/global.module';
-import { UserModule } from '../user/user.module';
+import { ScheduleModule } from '@nestjs/schedule';
+import { AchievementModule } from '../achievement/achievement.module';
 import { AuthModule } from '../auth/auth.module';
+import { CourseHistoryModule } from '../course-history/course-history.module';
 import { CourseModule } from '../course/course.module';
-import { UserProgressModule } from '../user-progress/user-progress.module';
-import { ToolModule } from '../tool/tool.module';
-import { RedisModule } from '@nestjs-modules/ioredis';
-import { RankModule } from '../rank/rank.module';
-import { GameModule } from '../game/game.module';
-import { ScheduleModule } from '@nestjs/schedule';
 import { CronJobModule } from '../cron-job/cron-job.module';
-import { CourseHistoryModule } from '../course-history/course-history.module';
-
+import { GameModule } from '../game/game.module';
+import { GlobalModule } from '../global/global.module';
+import { RankModule } from '../rank/rank.module';
+import { ToolModule } from '../tool/tool.module';
+import { UserProgressModule } from '../user-progress/user-progress.module';
+import { UserModule } from '../user/user.module';
 @Module({
   imports: [
+    AchievementModule,
     GlobalModule,
     UserModule,
     AuthModule,

apps/api/src/auth/auth.service.ts

@@ -4,11 +4,11 @@ import {
   Injectable,
   UnauthorizedException,
 } from '@nestjs/common';
-import { UserService } from '../user/user.service';
 import { JwtService } from '@nestjs/jwt';
-import { SignDto } from './model/auth.dto';
 import * as argon2 from 'argon2';
 import { CreateUserDto } from '../user/model/user.dto';
+import { UserService } from '../user/user.service';
+import { SignDto } from './model/auth.dto';
 
 @Injectable()
 export class AuthService {

apps/api/src/user-progress/user-progress.controller.ts

@@ -1,11 +1,11 @@
-import { Controller, Post, Body, UseGuards, Get, Put } from '@nestjs/common';
-import { UserProgressService } from './user-progress.service';
+import { Body, Controller, Get, Post, Put, UseGuards } from '@nestjs/common';
 import { AuthGuard } from '../auth/auth.guard';
+import { User, UserEntity } from '../user/user.decorators';
 import {
   CreateUserProgressDto,
   UpdateUserProgressDto,
 } from './model/user-progress.dto';
-import { User, UserEntity } from '../user/user.decorators';
+import { UserProgressService } from './user-progress.service';
 
 @Controller('user-progress')
 export class UserProgressController {

apps/client/api/achievement.ts

@@ -0,0 +1,54 @@
+import type { AchievementItem } from "~/composables/user/achievement";
+import { http } from "./http";
+
+interface PublishDto {
+  secretKey: string;
+  userID: number;
+  choiceAchievement: number[];
+}
+export interface AuthUserDto {
+  phone: string;
+}
+
+export interface SetDto {
+  // name: string;
+  userID: number;
+  achievementID: number;
+}
+export interface UserDto {
+  userID: number;
+}
+export interface UserInfo {
+  id: number;
+  phone: string;
+  name: string;
+  password: string;
+}
+// 颁布成就
+export async function fetchPubAchievement(dto: PublishDto) {
+  return await http.post("/achievement/publish", dto);
+}
+// 获取成就列表
+export async function fetchAllAchievements() {
+  return await http.get<AchievementItem[], AchievementItem[]>(
+    "/achievement/list"
+  );
+}
+// 验证用户 check userID
+export async function fetchAuthUser(dto: AuthUserDto) {
+  return await http.post<UserInfo, UserInfo>("/achievement/authUser", dto);
+  // return await http.get("/achievement/authUser");
+}
+// 设置成就为使用中状态
+export async function fetchSetUsing(dto: SetDto) {
+  return await http.post("/achievement/set", dto);
+}
+export async function fetchUserAchievement(dto: UserDto) {
+  return await http.post("/achievement/use", dto);
+}
+export async function fetchHaveAchievement(dto: UserDto) {
+  return await http.post<AchievementItem[], AchievementItem[]>(
+    "/achievement/allHave",
+    dto
+  );
+}