fix: complete backend deployment hardening

.env.example

@@ -15,11 +15,6 @@ ADMIN_BOOTSTRAP_ENABLED=false
 ADMIN_USERNAME=
 ADMIN_PASSWORD=
 ADMIN_NICKNAME=
-TEST_ADMIN_AUTO_PROVISION=true
-TEST_ADMIN_USERNAME=admin
-TEST_ADMIN_PASSWORD=
-TEST_ADMIN_NICKNAME=测试管理员
-TEST_LAB_ENABLED=false
 
 # Local storage mode
 USE_MEMORY_STORAGE=true

.env.production.example

@@ -14,7 +14,6 @@ ADMIN_BOOTSTRAP_ENABLED=false
 ADMIN_USERNAME=
 ADMIN_PASSWORD=
 ADMIN_NICKNAME=
-TEST_LAB_ENABLED=false
 
 # Persistent storage
 USE_MEMORY_STORAGE=false

DEPLOYMENT.md

@@ -1,47 +1,113 @@
-# WhaleTown V2 后端部署
+# WhaleTown End V2 部署
 
-## 1. 生产配置
+本文档覆盖 NestJS API、原生 WebSocket 服务和 React 管理端的单机部署。示例域名和目录与 `deploy/nginx` 中的模板一致，可按实际环境替换。
 
-```bash
+## 1. 环境要求
-cp .env.production.example .env
-openssl rand -hex 32 # 分别用于 JWT_SECRET、ADMIN_TOKEN_SECRET 和 ZULIP_API_KEY_ENCRYPTION_KEY
-```
 
-必须填写 MySQL、Redis 和三个随机密钥。REST API 使用 `3000` 端口，原生 WebSocket 使用 `3001` 端口。不要把两个端口配成相同值。
+- Node.js 20 或更高版本
+- pnpm 9
+- MySQL 8 和 Redis 7
+- PM2
+- Nginx
+- Python 3（仅皮肤生成功能需要）
 
-## 2. 数据库
+生产目录默认为 `/var/www/whale-town-end-v2`。所有命令均在该目录执行。
 
-部署前先备份现有数据库。v2 不会自动修改表结构（`synchronize: false`）。根据目标库的现有结构审核并执行仓库内的增量 SQL：
+## 2. 安装与配置
-
-```bash
-mysql -u <user> -p <database> < src/core/db/player_assets/create-player-assets-tables.sql
-mysql -u <user> -p <database> < src/core/db/user_wallets/create-user-wallets-tables.sql
-mysql -u <user> -p <database> < src/business/notice/migrations/create-notices-table.sql
-```
-
-## 3. 构建与启动
 
 ```bash
 pnpm install --frozen-lockfile
+cp .env.production.example .env
+chmod 600 .env
+```
+
+编辑 `.env` 并至少完成以下配置：
+
+- 为 `JWT_SECRET` 和 `ADMIN_TOKEN_SECRET` 设置独立的随机值。
+- 完整设置 `DB_HOST`、`DB_PORT`、`DB_USERNAME`、`DB_PASSWORD` 和 `DB_NAME`，避免服务回退到内存存储。
+- 完整设置 Redis 连接信息。
+- 保持 REST API 使用 `PORT=3000`，聊天 WebSocket 使用 `WEBSOCKET_PORT=3001`。
+- 使用 Zulip 时设置机器人凭据和至少 32 字节的 `ZULIP_API_KEY_ENCRYPTION_KEY`，并将 `ZULIP_DEGRADED_MODE_ENABLED` 设为 `false`。
+- 不使用 Zulip 时可将 `ZULIP_DEGRADED_MODE_ENABLED` 设为 `true` 并留空 Zulip 凭据；此时 Zulip 集成和 API Key 加密存取功能不可用。
+
+可分别生成随机密钥：
+
+```bash
+openssl rand -hex 32
+```
+
+不要把 `.env`、生成的密钥或数据库备份提交到 Git。
+
+## 3. 构建
+
+构建后端：
+
+```bash
 pnpm run build
-VITE_API_BASE_URL=https://whaletownend.xinghangee.icu pnpm --filter whale-town-admin run build
+```
+
+配置并构建管理端：
+
+```bash
+cp client/.env.example client/.env.local
+pnpm --filter whale-town-admin run build
+```
+
+确认 `client/.env.local` 中的 `VITE_API_BASE_URL` 指向实际后端 HTTPS 地址。该值在构建时写入管理端产物，修改后需要重新构建。
+
+## 4. 启动服务
+
+```bash
 pm2 start ecosystem.config.js
 pm2 save
 ```
 
-## 4. 反向代理
+服务使用仓库根目录作为工作目录，并从根目录的 `.env` 加载运行配置。查看状态和日志：
-
-`deploy/nginx/whaletownend-v2.conf.example` 将 REST 转发到 `3000`，将 `/game` WebSocket 转发到 `3001`。管理端可使用 `deploy/nginx/whaletown-admin-v2.conf.example` 作为独立静态站点。
-
-启用 HTTPS 后验证：
 
 ```bash
-curl https://whaletownend.xinghangee.icu/
+pm2 status
-curl https://whaletownend.xinghangee.icu/api-docs
+pm2 logs whale-town-end-v2
-curl --http1.1 -i \
-  -H 'Connection: Upgrade' \
-  -H 'Upgrade: websocket' \
-  -H 'Sec-WebSocket-Version: 13' \
-  -H 'Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==' \
-  https://whaletownend.xinghangee.icu/game
 ```
+
+## 5. 配置 Nginx
+
+安装后端和管理端模板：
+
+```bash
+sudo cp deploy/nginx/whaletownend-v2.conf.example /etc/nginx/conf.d/whaletownend-v2.conf
+sudo cp deploy/nginx/whaletown-admin-v2.conf.example /etc/nginx/conf.d/whaletown-admin-v2.conf
+sudo nginx -t
+sudo systemctl reload nginx
+```
+
+后端模板将 REST API 转发到 `3000`，将 `/game` 转发到独立的聊天 WebSocket 端口 `3001`，并为 `/location-broadcast` 和 `/ws/notice` 保留 REST 端口上的 WebSocket Upgrade。上线前还需在 Nginx 或上游代理配置 TLS。
+
+## 6. 验收
+
+```bash
+curl --fail https://whaletownend.xinghangee.icu/
+curl --fail https://whaletownend.xinghangee.icu/health
+curl --fail https://whaletownend.xinghangee.icu/api-docs
+```
+
+根接口应返回 `version: 2.0.0`，健康接口应返回 `status: ok`。还应分别验证以下 WebSocket 地址能够完成 `101 Switching Protocols`：
+
+- `wss://whaletownend.xinghangee.icu/game`
+- `wss://whaletownend.xinghangee.icu/location-broadcast`
+- `wss://whaletownend.xinghangee.icu/ws/notice`
+
+最后使用管理端和游戏客户端完成登录、刷新令牌、世界聊天、位置同步和通知的冒烟测试。
+
+## 7. 更新与回滚
+
+更新前备份 `.env` 和数据库，然后执行：
+
+```bash
+git pull --ff-only
+pnpm install --frozen-lockfile
+pnpm run build
+pnpm --filter whale-town-admin run build
+pm2 reload whale-town-end-v2
+```
+
+出现问题时切回上一已验证提交，重新安装锁定依赖并构建，然后执行 `pm2 reload whale-town-end-v2`。数据库结构变更必须使用对应版本的迁移或备份恢复方案，不能只回滚应用代码。

README.md

@@ -27,9 +27,9 @@ pnpm run build
 pnpm run start:prod
 ```
 
-启动前至少需要在 `.env` 中设置随机的 `JWT_SECRET`、`ADMIN_TOKEN_SECRET` 和 `ZULIP_API_KEY_ENCRYPTION_KEY`。生产环境请从 `.env.production.example` 开始配置，不要直接使用示例值。
+启动前至少需要在 `.env` 中设置随机的 `JWT_SECRET` 和 `ADMIN_TOKEN_SECRET`。启用 Zulip 时还必须设置 `ZULIP_API_KEY_ENCRYPTION_KEY`；若 `ZULIP_DEGRADED_MODE_ENABLED=true`，可以不配置 Zulip 凭据和加密密钥，但 Zulip 集成及 API Key 加密存取功能将不可用。生产环境请从 `.env.production.example` 开始配置，不要直接使用示例值。
 
-REST API 默认监听 `3000` 端口，原生 WebSocket 默认监听 `3001` 端口并使用 `/game` 路径，Swagger 地址为 `/api-docs`。生产环境的反向代理需要分别转发这两个端口。
+API 默认监听 `3000` 端口，Swagger 地址为 `/api-docs`。
 
 ## 管理端
 
@@ -39,6 +39,10 @@ pnpm --filter whale-town-admin run build
 
 管理端的 API 地址通过 `client/.env.local` 中的 `VITE_API_BASE_URL` 配置。
 
+## 部署
+
+生产部署、Nginx、PM2、验收和回滚步骤见 [DEPLOYMENT.md](DEPLOYMENT.md)。
+
 ## 安全
 
 仓库不包含 `.env`、访问令牌、SSH 私钥、数据库文件、Redis 数据、日志或生成资产。敏感配置必须通过部署环境注入。

deploy/nginx/whaletownend-v2.conf.example

@@ -17,6 +17,32 @@ server {
         proxy_send_timeout 3600s;
     }
 
+    location = /location-broadcast {
+        proxy_pass http://127.0.0.1:3000;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_read_timeout 3600s;
+        proxy_send_timeout 3600s;
+    }
+
+    location = /ws/notice {
+        proxy_pass http://127.0.0.1:3000;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_read_timeout 3600s;
+        proxy_send_timeout 3600s;
+    }
+
     location / {
         proxy_pass http://127.0.0.1:3000;
         proxy_http_version 1.1;

src/app.module.ts

@@ -30,8 +30,6 @@ import { UserWalletsModule } from './core/db/user_wallets/user_wallets.module';
 import { UserProfilesModule } from './core/db/user_profiles/user_profiles.module';
 import { MaintenanceMiddleware } from './core/security_core/maintenance.middleware';
 import { ContentTypeMiddleware } from './core/security_core/content_type.middleware';
-import { SocialModule } from './business/social/social.module';
-import { TasksModule } from './business/tasks/tasks.module';
 
 /**
  * 检查数据库配置是否完整 by angjustinl 2025-12-17
@@ -89,7 +87,6 @@ function isDatabaseConfigured(): boolean {
     UserProfilesModule.forRoot(),
     PlayerAssetsModule.forRoot(),
     UserWalletsModule.forRoot(),
-    TasksModule.forRoot(),
     // Zulip账号关联模块 - 全局单例，其他模块无需重复导入
     ZulipAccountsModule.forRoot(),
     LoginCoreModule,
@@ -109,7 +106,6 @@ function isDatabaseConfigured(): boolean {
     CafeCompanionModule,
     CourseResourcesModule,
     RankingsModule,
-    SocialModule.forRoot(),
   ],
   controllers: [AppController],
   providers: [

src/business/admin/admin.module.ts

@@ -38,12 +38,6 @@ import { AdminOperationLogMemoryService } from './admin_operation_log_memory.ser
 import { AdminOperationLog } from './admin_operation_log.entity';
 import { AdminDatabaseExceptionFilter } from './admin_database_exception.filter';
 import { AdminOperationLogInterceptor } from './admin_operation_log.interceptor';
-import { TestLabController } from './test_lab.controller';
-import { TestLabService } from './test_lab.service';
-import { TestLabGuard } from './test_lab.guard';
-import { ChatGatewayModule } from '../../gateway/chat/chat.gateway.module';
-import { AuthModule } from '../auth/auth.module';
-import { LoginCoreModule } from '../../core/login_core/login_core.module';
 
 /**
  * 检查数据库配置是否完整
@@ -61,9 +55,6 @@ function isDatabaseConfigured(): boolean {
     LoggerModule,
     UsersModule,
     SessionCoreModule,
-    AuthModule,
-    LoginCoreModule,
-    ChatGatewayModule,
     UserProfilesModule,
     // 注意：ZulipAccountsModule 是全局模块，已在 AppModule 中导入，无需重复导入
     // 注册AdminOperationLog实体
@@ -72,8 +63,7 @@ function isDatabaseConfigured(): boolean {
   controllers: [
     AdminController,
     AdminDatabaseController,
-    AdminOperationLogController,
+    AdminOperationLogController
-    TestLabController,
   ],
   providers: [
     AdminService,
@@ -85,15 +75,12 @@ function isDatabaseConfigured(): boolean {
         : AdminOperationLogMemoryService,
     },
     AdminDatabaseExceptionFilter,
-    AdminOperationLogInterceptor,
+    AdminOperationLogInterceptor
-    TestLabService,
-    TestLabGuard,
   ],
   exports: [
     AdminService,
     DatabaseManagementService,
-    AdminOperationLogService,
+    AdminOperationLogService
-    TestLabService,
   ], // 导出服务供其他模块使用
 })
 export class AdminModule {}

src/business/admin/test_lab.controller.ts

@@ -1,67 +0,0 @@
-import { Body, Controller, Delete, Get, Param, Patch, Post, UseGuards, ValidationPipe } from '@nestjs/common';
-import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
-import { TestLabService } from './test_lab.service';
-import { CreateTestLabActorDto, TestLabMessageDto, TestLabRoomPolicyDto, TestLabSocialActionDto, UpdateTestLabActorDto } from './test_lab.dto';
-import { Req } from '@nestjs/common';
-import { TestLabGuard, TestLabRequest } from './test_lab.guard';
-
-@ApiTags('admin-test-lab')
-@ApiBearerAuth('JWT-auth')
-@UseGuards(TestLabGuard)
-@Controller('admin/test-lab')
-export class TestLabController {
-  constructor(private readonly testLab: TestLabService) {}
-
-  @Get('status')
-  @ApiOperation({ summary: '获取测试实验室状态' })
-  async status() {
-    return { success: true, data: await this.testLab.status() };
-  }
-
-  @Post('actors')
-  @ApiOperation({ summary: '创建并上线测试假人' })
-  async create(@Body(new ValidationPipe({ transform: true })) dto: CreateTestLabActorDto, @Req() request: TestLabRequest) {
-    return { success: true, data: await this.testLab.createActor(dto, this.admin(request)) };
-  }
-
-  @Patch('actors/:userId')
-  @ApiOperation({ summary: '更新测试假人的在线、位置或外观' })
-  async update(@Param('userId') userId: string, @Body(new ValidationPipe({ transform: true })) dto: UpdateTestLabActorDto, @Req() request: TestLabRequest) {
-    return { success: true, data: await this.testLab.updateActor(userId, dto, this.admin(request)) };
-  }
-
-  @Patch('actors/:userId/room-policy')
-  @ApiOperation({ summary: '设置测试假人房间访问策略' })
-  async roomPolicy(@Param('userId') userId: string, @Body(new ValidationPipe({ transform: true })) dto: TestLabRoomPolicyDto, @Req() request: TestLabRequest) {
-    return { success: true, data: await this.testLab.setRoomPolicy(userId, dto, this.admin(request)) };
-  }
-
-  @Post('actors/:userId/messages')
-  @ApiOperation({ summary: '以测试假人身份发送公共消息或私聊' })
-  async message(@Param('userId') userId: string, @Body(new ValidationPipe({ transform: true })) dto: TestLabMessageDto, @Req() request: TestLabRequest) {
-    return { success: true, data: await this.testLab.sendMessage(userId, dto, this.admin(request)) };
-  }
-
-  @Post('actors/:userId/social')
-  @ApiOperation({ summary: '以测试假人身份执行好友或拉黑操作' })
-  async social(@Param('userId') userId: string, @Body(new ValidationPipe({ transform: true })) dto: TestLabSocialActionDto, @Req() request: TestLabRequest) {
-    return { success: true, data: await this.testLab.socialAction(userId, dto, this.admin(request)) };
-  }
-
-  @Delete('actors/:userId')
-  @ApiOperation({ summary: '删除单个测试假人及其测试数据' })
-  async remove(@Param('userId') userId: string, @Req() request: TestLabRequest) {
-    return { success: true, data: await this.testLab.removeActor(userId, this.admin(request)) };
-  }
-
-  @Delete('actors')
-  @ApiOperation({ summary: '清空全部测试假人及关联测试数据' })
-  async clear(@Req() request: TestLabRequest) {
-    return { success: true, data: await this.testLab.clear(this.admin(request)) };
-  }
-
-  private admin(request: TestLabRequest) {
-    if (!request.admin) throw new Error('管理员身份缺失');
-    return request.admin;
-  }
-}

src/business/admin/test_lab.dto.ts

@@ -1,92 +0,0 @@
-import { Type } from 'class-transformer';
-import { IsBoolean, IsIn, IsNotEmpty, IsNumber, IsOptional, IsString, Length, Matches, Max, Min, ValidateIf } from 'class-validator';
-import { MALL_SKIN_ITEMS } from '../mall/mall_catalog';
-
-export const TEST_LAB_MAP_IDS = ['whale_port', 'work_zone', 'whale_cafe'] as const;
-export type TestLabMapId = (typeof TEST_LAB_MAP_IDS)[number];
-export const TEST_LAB_SKIN_IDS = MALL_SKIN_ITEMS.map((item) => item.skinId).filter((skinId): skinId is string => Boolean(skinId));
-const TEST_LAB_NICKNAME_PATTERN = /^[\u4E00-\u9FFF A-Za-z0-9_-]+$/;
-
-export class CreateTestLabActorDto {
-  @IsString()
-  @IsNotEmpty()
-  @Length(1, 32)
-  @Matches(TEST_LAB_NICKNAME_PATTERN, { message: '昵称仅支持中文、字母、数字、空格、下划线和连字符' })
-  nickname: string;
-
-  @IsIn(TEST_LAB_MAP_IDS)
-  mapId: TestLabMapId;
-
-  @Type(() => Number)
-  @IsNumber()
-  @Min(-8192)
-  @Max(8192)
-  x: number;
-
-  @Type(() => Number)
-  @IsNumber()
-  @Min(-8192)
-  @Max(8192)
-  y: number;
-
-  @IsOptional()
-  @IsIn(TEST_LAB_SKIN_IDS)
-  skinId?: string;
-}
-
-export class UpdateTestLabActorDto {
-  @IsOptional()
-  @IsBoolean()
-  online?: boolean;
-
-  @ValidateIf((value) => value.mapId !== undefined)
-  @IsIn(TEST_LAB_MAP_IDS)
-  mapId?: TestLabMapId;
-
-  @IsOptional()
-  @Type(() => Number)
-  @IsNumber()
-  @Min(-8192)
-  @Max(8192)
-  x?: number;
-
-  @IsOptional()
-  @Type(() => Number)
-  @IsNumber()
-  @Min(-8192)
-  @Max(8192)
-  y?: number;
-
-  @IsOptional()
-  @IsIn(TEST_LAB_SKIN_IDS)
-  skinId?: string;
-}
-
-export class TestLabMessageDto {
-  @IsIn(['local', 'global', 'private'])
-  scope: 'local' | 'global' | 'private';
-
-  @IsString()
-  @IsNotEmpty()
-  @Length(1, 1000)
-  content: string;
-
-  @ValidateIf((value) => value.scope === 'private')
-  @IsString()
-  @IsNotEmpty()
-  targetUserId?: string;
-}
-
-export class TestLabSocialActionDto {
-  @IsIn(['friend_request', 'friend_accept', 'friend_reject', 'block'])
-  action: 'friend_request' | 'friend_accept' | 'friend_reject' | 'block';
-
-  @IsString()
-  @IsNotEmpty()
-  targetUserId: string;
-}
-
-export class TestLabRoomPolicyDto {
-  @IsIn(['friends', 'public', 'closed'])
-  roomVisitPolicy: 'friends' | 'public' | 'closed';
-}

src/business/admin/test_lab.guard.ts

@@ -1,73 +0,0 @@
-import { CanActivate, ExecutionContext, ForbiddenException, Inject, Injectable, UnauthorizedException } from '@nestjs/common';
-import { Request } from 'express';
-import { AdminAuthPayload, AdminCoreService } from '../../core/admin_core/admin_core.service';
-import { LoginCoreService, JwtPayload } from '../../core/login_core/login_core.service';
-import { Users } from '../../core/db/users/users.entity';
-
-export interface TestLabRequest extends Request {
-  admin?: AdminAuthPayload;
-  user?: JwtPayload;
-}
-
-type UsersLookup = {
-  findOne(id: bigint): Promise<Users>;
-};
-
-/**
- * 测试实验室既可由旧管理端 token 调用，也可由游戏内管理员的登录 token 调用。
- * 两条路径最终都会回查当前用户 role，避免客户端角色字段或旧 token 被单独信任。
- */
-@Injectable()
-export class TestLabGuard implements CanActivate {
-  constructor(
-    private readonly adminCore: AdminCoreService,
-    private readonly loginCore: LoginCoreService,
-    @Inject('UsersService') private readonly users: UsersLookup,
-  ) {}
-
-  async canActivate(context: ExecutionContext): Promise<boolean> {
-    const request = context.switchToHttp().getRequest<TestLabRequest>();
-    const token = this.extractBearerToken(request);
-
-    try {
-      const admin = this.adminCore.verifyToken(token);
-      await this.assertCurrentAdministrator(admin.adminId);
-      request.admin = admin;
-      return true;
-    } catch (_adminTokenError) {
-      // 继续尝试游戏登录 token；两类 token 使用不同签名，不会相互放行。
-    }
-
-    try {
-      const user = await this.loginCore.verifyToken(token, 'access');
-      if (user.role !== 9) throw new ForbiddenException('仅管理员可使用测试实验室');
-      await this.assertCurrentAdministrator(user.sub);
-      request.user = user;
-      request.admin = {
-        adminId: user.sub,
-        username: user.username,
-        role: 9,
-        iat: user.iat || Math.floor(Date.now() / 1000),
-        exp: user.exp || Math.floor(Date.now() / 1000),
-      };
-      return true;
-    } catch (error) {
-      if (error instanceof ForbiddenException) throw error;
-      throw new UnauthorizedException('需要有效的管理员登录凭据');
-    }
-  }
-
-  private extractBearerToken(request: Request): string {
-    const authorization = request.headers.authorization;
-    if (!authorization || Array.isArray(authorization)) throw new UnauthorizedException('缺少Authorization头');
-    const [scheme, token] = authorization.split(' ');
-    if (scheme !== 'Bearer' || !token) throw new UnauthorizedException('Authorization格式错误');
-    return token;
-  }
-
-  private async assertCurrentAdministrator(userId: string): Promise<void> {
-    if (!/^\d+$/.test(userId)) throw new UnauthorizedException('管理员身份无效');
-    const user = await this.users.findOne(BigInt(userId));
-    if (user.role !== 9) throw new ForbiddenException('仅管理员可使用测试实验室');
-  }
-}

src/business/admin/test_lab.service.ts

@@ -1,281 +0,0 @@
-import { BadRequestException, ForbiddenException, Inject, Injectable, Logger, OnModuleInit, Optional } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import { DataSource } from 'typeorm';
-import { randomUUID } from 'crypto';
-import { AccountProfileService } from '../auth/account_profile.service';
-import { SocialService } from '../social/social.service';
-import { ChatWebSocketGateway } from '../../gateway/chat/chat.gateway';
-import { Users } from '../../core/db/users/users.entity';
-import { AdminOperationLogService } from './admin_operation_log.service';
-import {
-  clearTestLabPresences,
-  getAllTestLabPresences,
-  getTestLabPresence,
-  TestLabPresence,
-} from './test_lab_presence.registry';
-import { CreateTestLabActorDto, TestLabMessageDto, TestLabRoomPolicyDto, TestLabSocialActionDto, UpdateTestLabActorDto } from './test_lab.dto';
-
-type UserStore = {
-  create(input: Partial<Users> & { username: string; nickname: string }): Promise<Users>;
-  findOne(id: bigint): Promise<Users>;
-  findAll(limit: number, offset: number): Promise<Users[]>;
-  remove(id: bigint): Promise<unknown>;
-};
-
-type AdminActor = { adminId: string; username: string };
-
-const MAX_TEST_ACTORS = 20;
-
-@Injectable()
-export class TestLabService implements OnModuleInit {
-  private readonly logger = new Logger(TestLabService.name);
-
-  constructor(
-    private readonly config: ConfigService,
-    @Inject('UsersService') private readonly users: UserStore,
-    private readonly accountProfiles: AccountProfileService,
-    private readonly social: SocialService,
-    private readonly gateway: ChatWebSocketGateway,
-    private readonly audit: AdminOperationLogService,
-    @Optional() private readonly dataSource?: DataSource,
-  ) {}
-
-  async onModuleInit(): Promise<void> {
-    if (this.isTestEnvironment()) {
-      await this.clearTestAccounts('startup');
-    }
-  }
-
-  isEnabled(): boolean {
-    return this.isTestEnvironment() && this.config.get<string>('TEST_LAB_ENABLED', 'false') === 'true';
-  }
-
-  async status() {
-    this.assertEnabled();
-    const actors = await this.listActorsInternal();
-    return {
-      enabled: this.isEnabled(),
-      environment: this.config.get<string>('NODE_ENV', 'development'),
-      maxActors: MAX_TEST_ACTORS,
-      actors,
-      onlinePlayers: this.gateway.getOnlineWorldPlayers(),
-    };
-  }
-
-  async createActor(dto: CreateTestLabActorDto, admin: AdminActor) {
-    this.assertEnabled();
-    const actors = await this.listActorsInternal();
-    if (actors.length >= MAX_TEST_ACTORS) throw new BadRequestException(`最多创建 ${MAX_TEST_ACTORS} 个测试假人`);
-
-    const nickname = dto.nickname.trim();
-    const user = await this.users.create({
-      username: `test_actor_${randomUUID().replace(/-/g, '').slice(0, 18)}`,
-      nickname,
-      role: 1,
-      email_verified: true,
-      is_test_account: true,
-    });
-    await this.accountProfiles.ensureProfile(user.id, dto.skinId || 'classic_whale');
-    await this.accountProfiles.updateAccountProfile(user.id, { settings: { room_visit_policy: 'public' } });
-
-    const presence: TestLabPresence = {
-      userId: user.id.toString(),
-      username: user.username,
-      nickname: user.nickname,
-      mapId: dto.mapId,
-      x: dto.x,
-      y: dto.y,
-      skinId: dto.skinId || 'classic_whale',
-      avatarId: 'default',
-      online: true,
-    };
-    this.gateway.setTestLabPresence(presence);
-    await this.record(admin, 'CREATE', 'test_lab_actor', user.id.toString(), '创建测试假人');
-    return await this.serializeActor(user, presence);
-  }
-
-  async updateActor(userId: string, dto: UpdateTestLabActorDto, admin: AdminActor) {
-    this.assertEnabled();
-    const user = await this.requireActor(userId);
-    const current = getTestLabPresence(user.id) || this.offlinePresence(user);
-    const next: TestLabPresence = {
-      ...current,
-      online: dto.online ?? current.online,
-      mapId: dto.mapId ?? current.mapId,
-      x: dto.x ?? current.x,
-      y: dto.y ?? current.y,
-      skinId: dto.skinId ?? current.skinId,
-    };
-    this.gateway.setTestLabPresence(next);
-    await this.record(admin, 'UPDATE', 'test_lab_actor', userId, '更新测试假人状态');
-    return await this.serializeActor(user, next);
-  }
-
-  async setRoomPolicy(userId: string, dto: TestLabRoomPolicyDto, admin: AdminActor) {
-    this.assertEnabled();
-    const user = await this.requireActor(userId);
-    await this.accountProfiles.updateAccountProfile(user.id, { settings: { room_visit_policy: dto.roomVisitPolicy } });
-    await this.record(admin, 'UPDATE', 'test_lab_actor', userId, '更新测试假人房间访问策略');
-    return await this.serializeActor(user, getTestLabPresence(user.id) || this.offlinePresence(user));
-  }
-
-  async sendMessage(userId: string, dto: TestLabMessageDto, admin: AdminActor) {
-    this.assertEnabled();
-    const actor = await this.requireOnlineActor(userId);
-    const content = dto.content.trim();
-    if (dto.scope === 'private') {
-      const targetId = this.requireOnlineTarget(dto.targetUserId || '');
-      await this.social.sendTestDirectMessage(actor.id, BigInt(targetId), content);
-    } else {
-      this.gateway.broadcastTestLabChat(getTestLabPresence(actor.id) as TestLabPresence, content, dto.scope);
-    }
-    await this.record(admin, 'CREATE', 'test_lab_message', userId, `测试假人发送${dto.scope === 'private' ? '私聊' : '公共消息'}`);
-    return { success: true };
-  }
-
-  async socialAction(userId: string, dto: TestLabSocialActionDto, admin: AdminActor) {
-    this.assertEnabled();
-    const actor = await this.requireOnlineActor(userId);
-    const targetId = this.requireOnlineTarget(dto.targetUserId);
-    const target = BigInt(targetId);
-    let result: unknown;
-    if (dto.action === 'friend_request') result = await this.social.createTestFriendRequest(actor.id, target);
-    else if (dto.action === 'friend_accept') result = await this.social.respondToTestFriendRequest(actor.id, target, true);
-    else if (dto.action === 'friend_reject') result = await this.social.respondToTestFriendRequest(actor.id, target, false);
-    else result = await this.social.blockUser(actor.id, target);
-    await this.record(admin, 'UPDATE', 'test_lab_social', userId, `测试假人执行${dto.action}`);
-    return result;
-  }
-
-  async removeActor(userId: string, admin: AdminActor) {
-    this.assertEnabled();
-    const user = await this.requireActor(userId);
-    this.gateway.removeTestLabActor(user.id.toString());
-    await this.removeAccounts([user]);
-    await this.record(admin, 'DELETE', 'test_lab_actor', userId, '删除测试假人');
-    return { success: true };
-  }
-
-  async clear(admin: AdminActor) {
-    this.assertEnabled();
-    const count = await this.clearTestAccounts('manual');
-    await this.record(admin, 'DELETE', 'test_lab_actor', undefined, `清空 ${count} 个测试假人`);
-    return { success: true, count };
-  }
-
-  private isTestEnvironment(): boolean {
-    const environment = this.config.get<string>('NODE_ENV', 'development');
-    return environment === 'development' || environment === 'test';
-  }
-
-  private assertEnabled(): void {
-    if (!this.isEnabled()) throw new ForbiddenException('测试实验室仅在已启用的开发/测试环境可用');
-  }
-
-  private async listActorsInternal() {
-    const users = await this.users.findAll(MAX_TEST_ACTORS + 20, 0);
-    return Promise.all(users
-      .filter((user) => user.is_test_account === true)
-      .map((user) => this.serializeActor(user, getTestLabPresence(user.id) || this.offlinePresence(user))));
-  }
-
-  private async requireActor(userId: string): Promise<Users> {
-    if (!/^\d+$/.test(userId)) throw new BadRequestException('测试假人用户 ID 无效');
-    const user = await this.users.findOne(BigInt(userId));
-    if (user.is_test_account !== true) throw new ForbiddenException('目标不是测试实验室账号');
-    return user;
-  }
-
-  private async requireOnlineActor(userId: string): Promise<Users> {
-    const actor = await this.requireActor(userId);
-    if (!getTestLabPresence(actor.id)?.online) throw new BadRequestException('测试假人当前不在线');
-    return actor;
-  }
-
-  private requireOnlineTarget(userId: string): string {
-    if (!/^\d+$/.test(userId)) throw new BadRequestException('目标用户 ID 无效');
-    if (!this.gateway.getOnlineWorldPlayers().some((player) => player.userId === userId)) {
-      throw new BadRequestException('目标玩家当前不在线');
-    }
-    return userId;
-  }
-
-  private offlinePresence(user: Users): TestLabPresence {
-    return {
-      userId: user.id.toString(), username: user.username, nickname: user.nickname,
-      mapId: 'whale_port', x: 1280, y: 960, skinId: 'classic_whale', avatarId: 'default', online: false,
-    };
-  }
-
-  private async serializeActor(user: Users, presence: TestLabPresence) {
-    const account = await this.accountProfiles.getAccountProfile(user.id);
-    const configuredPolicy = account.profile.settings?.room_visit_policy;
-    const roomVisitPolicy = configuredPolicy === 'friends' || configuredPolicy === 'public' || configuredPolicy === 'closed'
-      ? configuredPolicy
-      : 'friends';
-    return {
-      userId: user.id.toString(), username: user.username, nickname: user.nickname,
-      mapId: presence.mapId, x: presence.x, y: presence.y,
-      skinId: presence.skinId, avatarId: presence.avatarId, online: presence.online, roomVisitPolicy,
-    };
-  }
-
-  private async clearTestAccounts(reason: 'startup' | 'manual'): Promise<number> {
-    const users = (await this.users.findAll(MAX_TEST_ACTORS + 20, 0)).filter((user) => user.is_test_account === true);
-    if (users.length === 0) {
-      if (reason === 'startup') clearTestLabPresences();
-      return 0;
-    }
-    for (const presence of getAllTestLabPresences()) this.gateway.removeTestLabActor(presence.userId);
-    await this.removeAccounts(users);
-    this.logger.log(`测试实验室已清理 ${users.length} 个假人账号`, { reason });
-    return users.length;
-  }
-
-  private async removeAccounts(users: Users[]): Promise<void> {
-    const ids = users.map((user) => user.id);
-    for (const user of users) this.gateway.removeTestLabActor(user.id.toString());
-    await this.social.purgeTestUsers(ids);
-    await this.purgeDomainRows(ids);
-    for (const user of users) await this.users.remove(user.id);
-  }
-
-  private async purgeDomainRows(ids: bigint[]): Promise<void> {
-    if (!this.dataSource || ids.length === 0) return;
-    const values = ids.map((id) => id.toString());
-    const placeholders = values.map(() => '?').join(', ');
-    const runner = this.dataSource.createQueryRunner();
-    await runner.connect();
-    try {
-      for (const table of ['room_decor_placements', 'user_assets', 'wallet_transactions', 'user_wallets', 'player_task_progress', 'user_profiles']) {
-        try {
-          await runner.query(`DELETE FROM \`${table}\` WHERE \`user_id\` IN (${placeholders})`, values);
-        } catch (error) {
-          this.logger.debug(`测试实验室清理跳过不可用表 ${table}`, { error: error instanceof Error ? error.message : String(error) });
-        }
-      }
-    } finally {
-      await runner.release();
-    }
-  }
-
-  private async record(admin: AdminActor, operation: 'CREATE' | 'UPDATE' | 'DELETE', targetType: string, targetId: string | undefined, description: string): Promise<void> {
-    try {
-      await this.audit.createLog({
-        adminUserId: admin.adminId,
-        adminUsername: admin.username,
-        operationType: operation,
-        targetType,
-        targetId,
-        operationDescription: description,
-        httpMethodPath: '/admin/test-lab',
-        operationResult: 'SUCCESS',
-        durationMs: 0,
-        requestId: randomUUID(),
-        context: { testLab: true },
-      });
-    } catch (error) {
-      this.logger.warn('测试实验室操作日志写入失败', { error: error instanceof Error ? error.message : String(error) });
-    }
-  }
-}

src/business/admin/test_lab_presence.registry.ts

@@ -1,46 +0,0 @@
-export type TestLabPresence = {
-  userId: string;
-  username: string;
-  nickname: string;
-  mapId: string;
-  x: number;
-  y: number;
-  skinId: string;
-  avatarId: string;
-  online: boolean;
-};
-
-const presences = new Map<string, TestLabPresence>();
-
-export function upsertTestLabPresence(presence: TestLabPresence): TestLabPresence {
-  const normalized = { ...presence, userId: String(presence.userId), online: Boolean(presence.online) };
-  presences.set(normalized.userId, normalized);
-  return { ...normalized };
-}
-
-export function getTestLabPresence(userId: string | bigint): TestLabPresence | null {
-  const presence = presences.get(String(userId));
-  return presence ? { ...presence } : null;
-}
-
-export function getTestLabPresences(mapId?: string): TestLabPresence[] {
-  return [...presences.values()]
-    .filter((presence) => presence.online && (!mapId || presence.mapId === mapId))
-    .map((presence) => ({ ...presence }));
-}
-
-export function getAllTestLabPresences(): TestLabPresence[] {
-  return [...presences.values()].map((presence) => ({ ...presence }));
-}
-
-export function removeTestLabPresence(userId: string | bigint): TestLabPresence | null {
-  const existing = presences.get(String(userId));
-  presences.delete(String(userId));
-  return existing ? { ...existing } : null;
-}
-
-export function clearTestLabPresences(): TestLabPresence[] {
-  const existing = getTestLabPresences();
-  presences.clear();
-  return existing;
-}

src/business/auth/account_profile.service.ts

@@ -92,7 +92,6 @@ const DEFAULT_ACCOUNT_SETTINGS: AccountSettings = {
   ui_scale: 1.00,
   fullscreen: false,
   show_interaction_hints: true,
-  show_interaction_points: false,
   show_name_always: false,
   show_chat_bubbles: true,
   world_notifications: true,
@@ -100,14 +99,12 @@ const DEFAULT_ACCOUNT_SETTINGS: AccountSettings = {
   friend_request_notifications: true,
   allow_nearby_private: true,
   allow_nearby_friend_requests: true,
-  allow_nearby_profile: true,
   mute_ui_sfx: false,
 };
 const ACCOUNT_SETTING_NUMBER_KEYS = new Set(['master_volume', 'music_volume', 'effects_volume', 'ui_scale']);
 const ACCOUNT_SETTING_BOOLEAN_KEYS = new Set([
   'fullscreen',
   'show_interaction_hints',
-  'show_interaction_points',
   'show_name_always',
   'show_chat_bubbles',
   'world_notifications',
@@ -115,7 +112,6 @@ const ACCOUNT_SETTING_BOOLEAN_KEYS = new Set([
   'friend_request_notifications',
   'allow_nearby_private',
   'allow_nearby_friend_requests',
-  'allow_nearby_profile',
   'mute_ui_sfx',
 ]);
 
@@ -250,7 +246,7 @@ export class AccountProfileService {
       tags: {
         [REGISTRATION_SKIN_GENERATION_AVAILABLE_TAG_KEY]: true,
       },
-      current_map: 'whale_port',
+      current_map: 'plaza',
       pos_x: 0,
       pos_y: 0,
       status: 0,

src/business/chat/chat.service.ts

@@ -40,7 +40,6 @@ import { LoginCoreService } from '../../core/login_core/login_core.service';
 import { ZulipAccountsService } from '../../core/db/zulip_accounts/zulip_accounts.service';
 import { ZulipAccountsMemoryService } from '../../core/db/zulip_accounts/zulip_accounts_memory.service';
 import { AccountProfileService } from '../auth/account_profile.service';
-import { TaskService } from '../tasks/task.service';
 
 // ========== 接口定义 ==========
 
@@ -263,7 +262,6 @@ export class ChatService {
     @Inject('ZulipAccountsService')
     private readonly zulipAccountsService: ZulipAccountsService | ZulipAccountsMemoryService,
     private readonly accountProfileService: AccountProfileService,
-    private readonly taskService: TaskService,
   ) {
     this.logger.log('ChatService初始化完成');
   }
@@ -447,11 +445,6 @@ export class ChatService {
           .catch(e => this.logger.warn('Zulip同步失败', { error: (e as Error).message }));
       }
 
-      if (normalizedScope === 'global') {
-        await this.taskService.recordActivity(BigInt(session.userId), 'public_message_sent')
-          .catch((error: unknown) => this.logger.warn('记录公共聊天任务失败', { error: error instanceof Error ? error.message : String(error) }));
-      }
-
       this.logger.log('聊天消息发送完成', {
         operation: 'sendChatMessage',
         messageId,

src/business/mall/mall.service.ts

@@ -1,10 +1,9 @@
-import { BadRequestException, Inject, Injectable, Logger } from '@nestjs/common';
+import { BadRequestException, Inject, Injectable } from '@nestjs/common';
 import { MALL_CATEGORIES, MALL_ITEMS, findMallItem } from './mall_catalog';
 import { InventoryService } from '../player/inventory.service';
 import { EconomyService } from '../player/economy.service';
 import { PlayerStateService } from '../player/player_state.service';
 import { PlayerInventoryPayload, PlayerSnapshotPayload, PlayerWalletPayload } from '../player/player.types';
-import { TaskService } from '../tasks/task.service';
 
 interface IUserWalletsService {
   getBalance(userId: bigint): Promise<{ balance: number; currency: 'whale_coin'; user_id: string }>;
@@ -52,14 +51,11 @@ export interface MallCatalogPayload {
 
 @Injectable()
 export class MallService {
-  private readonly logger = new Logger(MallService.name);
-
   constructor(
     @Inject('IUserWalletsService') private readonly userWalletsService: IUserWalletsService,
     private readonly inventoryService: InventoryService,
     private readonly economyService: EconomyService,
     private readonly playerStateService: PlayerStateService,
-    private readonly taskService: TaskService,
   ) {}
 
   async getWallet(userId: bigint) {
@@ -127,10 +123,6 @@ export class MallService {
     }
 
     await this.inventoryService.grantAsset(userId, 'skin', item.skinId as string, 'purchase');
-    if (!alreadyOwned) {
-      await this.taskService.recordActivity(userId, 'skin_purchased', item.itemId)
-        .catch((error: unknown) => this.logger.warn(`记录首次皮肤任务失败: ${error instanceof Error ? error.message : String(error)}`));
-    }
     const [inventory, snapshot] = await Promise.all([
       this.inventoryService.listInventory(userId),
       this.playerStateService.getSnapshot(userId),

src/business/player/player.controller.ts

@@ -9,8 +9,6 @@ import { EconomyService } from './economy.service';
 import { UpdatePlayerAppearanceDto } from './dto/update_player_appearance.dto';
 import { UpdatePlayerProfileAssetsDto } from './dto/update_player_profile_assets.dto';
 import { UpdatePlayerSettingsDto } from './dto/update_player_settings.dto';
-import { SocialService } from '../social/social.service';
-import { UpdateSocialProfileDto } from '../social/dto/social.dto';
 
 @ApiTags('player')
 @ApiBearerAuth()
@@ -20,7 +18,6 @@ export class PlayerController {
   constructor(
     private readonly playerStateService: PlayerStateService,
     private readonly economyService: EconomyService,
-    private readonly socialService: SocialService,
   ) {}
 
   @ApiOperation({ summary: '获取当前玩家快照' })
@@ -80,16 +77,4 @@ export class PlayerController {
     const data = await this.playerStateService.updateProfileAssets(BigInt(user.sub), dto);
     res.status(HttpStatus.OK).json({ success: true, data, message: '玩家资源更新成功' });
   }
-
-  @ApiOperation({ summary: '更新当前玩家社区名片' })
-  @Patch('social-profile')
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  async updateSocialProfile(
-    @CurrentUser() user: JwtPayload,
-    @Body() dto: UpdateSocialProfileDto,
-    @Res() res: Response,
-  ): Promise<void> {
-    const data = await this.socialService.updateSocialProfile(BigInt(user.sub), dto);
-    res.status(HttpStatus.OK).json({ success: true, data, message: '社区名片已更新' });
-  }
 }

src/business/social/dto/social.dto.ts

@@ -1,65 +0,0 @@
-import { Type } from 'class-transformer';
-import { ArrayMaxSize, IsArray, IsBoolean, IsIn, IsNotEmpty, IsOptional, IsString, Length, Max, Min } from 'class-validator';
-
-export class UpdateSocialProfileDto {
-  @IsOptional()
-  @IsString()
-  @Length(1, 50)
-  nickname?: string;
-
-  @IsOptional()
-  @IsString()
-  @Length(0, 160)
-  bio?: string;
-
-  @IsOptional()
-  @IsArray()
-  @ArrayMaxSize(3)
-  @IsString({ each: true })
-  interests?: string[];
-}
-
-export class SocialUserActionDto {
-  @IsString()
-  @IsNotEmpty()
-  userId: string;
-}
-
-export class CreateBlockDto extends SocialUserActionDto {}
-
-export class CreateReportDto extends SocialUserActionDto {
-  @IsString()
-  @IsIn(['harassment', 'spam', 'inappropriate_content', 'impersonation', 'other'])
-  reason: string;
-
-  @IsOptional()
-  @IsString()
-  @Length(0, 500)
-  note?: string;
-
-  @IsOptional()
-  @IsString()
-  messageId?: string;
-
-  @IsOptional()
-  @IsBoolean()
-  blockAlso?: boolean;
-}
-
-export class PaginationDto {
-  @IsOptional()
-  @Type(() => Number)
-  @Min(1)
-  @Max(100)
-  limit?: number = 30;
-
-  @IsOptional()
-  @IsString()
-  before?: string;
-}
-
-export class TravelDestinationDto {
-  @IsString()
-  @IsNotEmpty()
-  destinationId: string;
-}

src/business/social/migrations/create-social-tables.sql

@@ -1,92 +0,0 @@
--- WhaleTown V2 core social infrastructure. Run after the existing users/user_profiles tables.
--- Compatible with MySQL 5.7+/MariaDB: add the column only once.
-SET @nickname_column_exists := (
-  SELECT COUNT(*) FROM information_schema.COLUMNS
-  WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = 'users' AND COLUMN_NAME = 'nickname_updated_at'
-);
-SET @nickname_column_sql := IF(
-  @nickname_column_exists = 0,
-  'ALTER TABLE users ADD COLUMN nickname_updated_at DATETIME NULL COMMENT ''社区昵称最近修改时间''',
-  'SELECT 1'
-);
-PREPARE nickname_column_statement FROM @nickname_column_sql;
-EXECUTE nickname_column_statement;
-DEALLOCATE PREPARE nickname_column_statement;
-UPDATE user_profiles SET current_map = 'whale_port' WHERE current_map = 'plaza';
-UPDATE user_profiles SET current_map = 'personal_space' WHERE current_map = 'room';
-
-CREATE TABLE IF NOT EXISTS friendships (
-  id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY,
-  user_low_id BIGINT NOT NULL,
-  user_high_id BIGINT NOT NULL,
-  created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  UNIQUE KEY uq_friendships_pair (user_low_id, user_high_id),
-  KEY idx_friendships_low (user_low_id),
-  KEY idx_friendships_high (user_high_id)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
-
-CREATE TABLE IF NOT EXISTS friend_requests (
-  id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY,
-  requester_id BIGINT NOT NULL,
-  recipient_id BIGINT NOT NULL,
-  status VARCHAR(16) NOT NULL DEFAULT 'pending',
-  created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  expires_at DATETIME NOT NULL,
-  responded_at DATETIME NULL,
-  KEY idx_friend_requests_recipient (recipient_id, status, expires_at),
-  KEY idx_friend_requests_pair (requester_id, recipient_id, status)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
-
-CREATE TABLE IF NOT EXISTS user_blocks (
-  id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY,
-  user_id BIGINT NOT NULL,
-  blocked_user_id BIGINT NOT NULL,
-  created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  UNIQUE KEY uq_user_blocks_pair (user_id, blocked_user_id)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
-
-CREATE TABLE IF NOT EXISTS direct_messages (
-  id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY,
-  sender_id BIGINT NOT NULL,
-  recipient_id BIGINT NOT NULL,
-  content VARCHAR(1000) NOT NULL,
-  created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  expires_at DATETIME NOT NULL,
-  read_at DATETIME NULL,
-  KEY idx_direct_messages_conversation (sender_id, recipient_id, created_at),
-  KEY idx_direct_messages_unread (recipient_id, read_at)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
-
-CREATE TABLE IF NOT EXISTS user_reports (
-  id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY,
-  reporter_id BIGINT NOT NULL,
-  reported_user_id BIGINT NOT NULL,
-  reason VARCHAR(32) NOT NULL,
-  note VARCHAR(500) NULL,
-  message_id BIGINT NULL,
-  status VARCHAR(24) NOT NULL DEFAULT 'received',
-  created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  KEY idx_user_reports_reporter (reporter_id, created_at)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
-
-CREATE TABLE IF NOT EXISTS player_travel_unlocks (
-  id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY,
-  user_id BIGINT NOT NULL,
-  destination_id VARCHAR(80) NOT NULL,
-  discovered_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  UNIQUE KEY uq_player_travel_unlocks (user_id, destination_id)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
-
-CREATE TABLE IF NOT EXISTS social_notifications (
-  id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY,
-  user_id BIGINT NOT NULL,
-  category VARCHAR(48) NOT NULL,
-  title VARCHAR(100) NOT NULL,
-  content VARCHAR(500) NOT NULL,
-  action_metadata JSON NULL,
-  read_at DATETIME NULL,
-  created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-  expires_at DATETIME NOT NULL,
-  updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
-  KEY idx_social_notifications_user (user_id, read_at, created_at)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

src/business/social/social.controller.ts

@@ -1,100 +0,0 @@
-import { Body, Controller, Delete, Get, Param, Patch, Post, Query, UseGuards } from '@nestjs/common';
-import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
-import { JwtPayload } from '../../core/login_core/login_core.service';
-import { CurrentUser } from '../../gateway/auth/current_user.decorator';
-import { JwtAuthGuard } from '../../gateway/auth/jwt_auth.guard';
-import { CreateBlockDto, CreateReportDto, PaginationDto, SocialUserActionDto, TravelDestinationDto, UpdateSocialProfileDto } from './dto/social.dto';
-import { SocialService } from './social.service';
-
-function id(value: string): bigint {
-  if (!/^\d+$/.test(String(value || ''))) throw new Error('用户标识无效');
-  return BigInt(value);
-}
-
-@ApiTags('social')
-@ApiBearerAuth()
-@UseGuards(JwtAuthGuard)
-@Controller('social')
-export class SocialController {
-  constructor(private readonly social: SocialService) {}
-
-  @Get('interest-tags')
-  interestTags() { return { success: true, data: this.social.getInterestTags() }; }
-
-  @Patch('profile')
-  async updateProfile(@CurrentUser() user: JwtPayload, @Body() body: UpdateSocialProfileDto) { return { success: true, data: await this.social.updateSocialProfile(id(user.sub), body) }; }
-
-  @Get('profile')
-  async ownProfile(@CurrentUser() user: JwtPayload) { return { success: true, data: await this.social.getOwnSocialProfile(id(user.sub)) }; }
-
-  @Get('profiles/:userId')
-  async profile(@CurrentUser() user: JwtPayload, @Param('userId') userId: string) { return { success: true, data: await this.social.getPublicProfile(id(user.sub), id(userId)) }; }
-
-  @Get('friends')
-  async friends(@CurrentUser() user: JwtPayload) { return { success: true, data: await this.social.getFriends(id(user.sub)) }; }
-
-  @Get('friend-requests')
-  async friendRequests(@CurrentUser() user: JwtPayload) { return { success: true, data: await this.social.getFriendRequests(id(user.sub)) }; }
-
-  @Post('friend-requests')
-  async createFriendRequest(@CurrentUser() user: JwtPayload, @Body() body: SocialUserActionDto) { return { success: true, data: await this.social.createFriendRequest(id(user.sub), id(body.userId)) }; }
-
-  @Post('friend-requests/:requestId/accept')
-  async acceptFriendRequest(@CurrentUser() user: JwtPayload, @Param('requestId') requestId: string) { return { success: true, data: await this.social.acceptFriendRequest(id(user.sub), id(requestId)) }; }
-
-  @Post('friend-requests/:requestId/reject')
-  async rejectFriendRequest(@CurrentUser() user: JwtPayload, @Param('requestId') requestId: string) { await this.social.rejectFriendRequest(id(user.sub), id(requestId)); return { success: true }; }
-
-  @Delete('friend-requests/:requestId')
-  async cancelFriendRequest(@CurrentUser() user: JwtPayload, @Param('requestId') requestId: string) { await this.social.cancelFriendRequest(id(user.sub), id(requestId)); return { success: true }; }
-
-  @Delete('friends/:userId')
-  async removeFriend(@CurrentUser() user: JwtPayload, @Param('userId') userId: string) { await this.social.removeFriend(id(user.sub), id(userId)); return { success: true }; }
-
-  @Get('blocks')
-  async blocks(@CurrentUser() user: JwtPayload) { return { success: true, data: await this.social.listBlocks(id(user.sub)) }; }
-
-  @Post('blocks')
-  async block(@CurrentUser() user: JwtPayload, @Body() body: CreateBlockDto) { return { success: true, data: await this.social.blockUser(id(user.sub), id(body.userId)) }; }
-
-  @Delete('blocks/:userId')
-  async unblock(@CurrentUser() user: JwtPayload, @Param('userId') userId: string) { return { success: true, data: await this.social.unblockUser(id(user.sub), id(userId)) }; }
-
-  @Post('reports')
-  async report(@CurrentUser() user: JwtPayload, @Body() body: CreateReportDto) { return { success: true, data: await this.social.createReport(id(user.sub), { userId: id(body.userId), reason: body.reason, note: body.note, messageId: body.messageId ? id(body.messageId) : undefined, blockAlso: body.blockAlso }) }; }
-
-  @Get('conversations')
-  async conversations(@CurrentUser() user: JwtPayload) { return { success: true, data: await this.social.listConversations(id(user.sub)) }; }
-
-  @Get('conversations/:userId/messages')
-  async conversation(@CurrentUser() user: JwtPayload, @Param('userId') userId: string, @Query() query: PaginationDto) { return { success: true, data: await this.social.listConversation(id(user.sub), id(userId), query.limit || 30, query.before ? new Date(query.before) : undefined) }; }
-
-  @Patch('conversations/:userId/read')
-  async markConversationRead(@CurrentUser() user: JwtPayload, @Param('userId') userId: string) { return { success: true, data: await this.social.markConversationRead(id(user.sub), id(userId)) }; }
-
-  @Get('notifications')
-  async notifications(@CurrentUser() user: JwtPayload, @Query() query: PaginationDto) { return { success: true, data: await this.social.getNotificationSummary(id(user.sub), query.limit || 30, query.before ? new Date(query.before) : undefined) }; }
-
-  @Patch('notifications/:notificationId/read')
-  async markNotificationRead(@CurrentUser() user: JwtPayload, @Param('notificationId') notificationId: string) { return { success: true, data: await this.social.markNotificationRead(id(user.sub), id(notificationId)) }; }
-
-  @Patch('notifications/read-all')
-  async markAllNotificationsRead(@CurrentUser() user: JwtPayload) { return { success: true, data: await this.social.markAllNotificationsRead(id(user.sub)) }; }
-}
-
-@ApiTags('world')
-@ApiBearerAuth()
-@UseGuards(JwtAuthGuard)
-@Controller('world/travel-destinations')
-export class WorldTravelController {
-  constructor(private readonly social: SocialService) {}
-
-  @Get()
-  async destinations(@CurrentUser() user: JwtPayload) { return { success: true, data: await this.social.getTravelDestinations(id(user.sub)) }; }
-
-  @Post(':destinationId/discover')
-  async discover(@CurrentUser() user: JwtPayload, @Param('destinationId') destinationId: string) { return { success: true, data: await this.social.discoverDestination(id(user.sub), destinationId) }; }
-
-  @Post(':destinationId/travel')
-  async travel(@CurrentUser() user: JwtPayload, @Param('destinationId') destinationId: string) { return { success: true, data: await this.social.travelTo(id(user.sub), destinationId) }; }
-}

src/business/social/social.database-store.ts

@@ -1,75 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Brackets, LessThan, MoreThan, Repository } from 'typeorm';
-import {
-  DirectMessage,
-  FriendRequest,
-  FriendRequestStatus,
-  Friendship,
-  PlayerTravelUnlock,
-  SocialNotification,
-  UserBlock,
-  UserReport,
-} from './social.entities';
-import { SocialStore } from './social.store';
-
-@Injectable()
-export class SocialDatabaseStore implements SocialStore {
-  constructor(
-    @InjectRepository(Friendship) private readonly friendships: Repository<Friendship>,
-    @InjectRepository(FriendRequest) private readonly requests: Repository<FriendRequest>,
-    @InjectRepository(UserBlock) private readonly blocks: Repository<UserBlock>,
-    @InjectRepository(DirectMessage) private readonly messages: Repository<DirectMessage>,
-    @InjectRepository(UserReport) private readonly reports: Repository<UserReport>,
-    @InjectRepository(PlayerTravelUnlock) private readonly unlocks: Repository<PlayerTravelUnlock>,
-    @InjectRepository(SocialNotification) private readonly notifications: Repository<SocialNotification>,
-  ) {}
-
-  async listFriendships(userId: bigint): Promise<Friendship[]> {
-    return this.friendships.find({ where: [{ user_low_id: userId }, { user_high_id: userId }], order: { created_at: 'DESC' } });
-  }
-  async findFriendship(userLowId: bigint, userHighId: bigint): Promise<Friendship | null> { return this.friendships.findOne({ where: { user_low_id: userLowId, user_high_id: userHighId } }); }
-  async createFriendship(userLowId: bigint, userHighId: bigint): Promise<Friendship> {
-    const existing = await this.findFriendship(userLowId, userHighId); return existing || this.friendships.save(this.friendships.create({ user_low_id: userLowId, user_high_id: userHighId }));
-  }
-  async deleteFriendship(userLowId: bigint, userHighId: bigint): Promise<void> { await this.friendships.delete({ user_low_id: userLowId, user_high_id: userHighId }); }
-  async findPendingFriendRequest(requesterId: bigint, recipientId: bigint): Promise<FriendRequest | null> { return this.requests.findOne({ where: { requester_id: requesterId, recipient_id: recipientId, status: FriendRequestStatus.PENDING, expires_at: MoreThan(new Date()) } }); }
-  async createFriendRequest(requesterId: bigint, recipientId: bigint, expiresAt: Date): Promise<FriendRequest> { return this.requests.save(this.requests.create({ requester_id: requesterId, recipient_id: recipientId, expires_at: expiresAt, status: FriendRequestStatus.PENDING })); }
-  async findFriendRequest(id: bigint): Promise<FriendRequest | null> { return this.requests.findOne({ where: { id } }); }
-  async saveFriendRequest(request: FriendRequest): Promise<FriendRequest> { return this.requests.save(request); }
-  async cancelPendingRequestsBetween(userA: bigint, userB: bigint): Promise<void> {
-    await this.requests.createQueryBuilder().update(FriendRequest).set({ status: FriendRequestStatus.CANCELLED, responded_at: new Date() }).where('status = :status', { status: FriendRequestStatus.PENDING }).andWhere(new Brackets((qb) => qb.where('(requester_id = :a AND recipient_id = :b)', { a: userA, b: userB }).orWhere('(requester_id = :b AND recipient_id = :a)', { a: userA, b: userB }))).execute();
-  }
-  async listFriendRequests(userId: bigint): Promise<FriendRequest[]> { return this.requests.find({ where: { recipient_id: userId, status: FriendRequestStatus.PENDING, expires_at: MoreThan(new Date()) }, order: { created_at: 'DESC' } }); }
-  async createBlock(userId: bigint, blockedUserId: bigint): Promise<UserBlock> { const found = await this.blocks.findOne({ where: { user_id: userId, blocked_user_id: blockedUserId } }); return found || this.blocks.save(this.blocks.create({ user_id: userId, blocked_user_id: blockedUserId })); }
-  async deleteBlock(userId: bigint, blockedUserId: bigint): Promise<void> { await this.blocks.delete({ user_id: userId, blocked_user_id: blockedUserId }); }
-  async isBlocked(userId: bigint, blockedUserId: bigint): Promise<boolean> { return (await this.blocks.count({ where: { user_id: userId, blocked_user_id: blockedUserId } })) > 0; }
-  async listBlocks(userId: bigint): Promise<UserBlock[]> { return this.blocks.find({ where: { user_id: userId }, order: { created_at: 'DESC' } }); }
-  async createDirectMessage(input: Pick<DirectMessage, 'sender_id' | 'recipient_id' | 'content' | 'expires_at'>): Promise<DirectMessage> { return this.messages.save(this.messages.create(input)); }
-  async listDirectMessages(userA: bigint, userB: bigint, limit: number, before?: Date): Promise<DirectMessage[]> { const query = this.messages.createQueryBuilder('message').where('message.expires_at > :now', { now: new Date() }).andWhere(new Brackets((qb) => qb.where('(message.sender_id = :a AND message.recipient_id = :b)', { a: userA, b: userB }).orWhere('(message.sender_id = :b AND message.recipient_id = :a)', { a: userA, b: userB }))); if (before) query.andWhere('message.created_at < :before', { before }); return query.orderBy('message.created_at', 'DESC').take(limit).getMany(); }
-  async markDirectMessagesRead(readerId: bigint, otherUserId: bigint): Promise<number> { const result = await this.messages.createQueryBuilder().update(DirectMessage).set({ read_at: new Date() }).where('sender_id = :otherUserId AND recipient_id = :readerId AND read_at IS NULL', { readerId, otherUserId }).execute(); return result.affected || 0; }
-  async listConversations(userId: bigint): Promise<DirectMessage[]> { const rows = await this.messages.createQueryBuilder('message').where('(message.sender_id = :userId OR message.recipient_id = :userId)', { userId }).andWhere('message.expires_at > :now', { now: new Date() }).orderBy('message.created_at', 'DESC').getMany(); const seen = new Set<string>(); return rows.filter((row) => { const other = (row.sender_id === userId ? row.recipient_id : row.sender_id).toString(); if (seen.has(other)) return false; seen.add(other); return true; }); }
-  async countUnreadDirectMessages(userId: bigint): Promise<number> { return this.messages.count({ where: { recipient_id: userId, read_at: null, expires_at: MoreThan(new Date()) } }); }
-  async createReport(input: Pick<UserReport, 'reporter_id' | 'reported_user_id' | 'reason' | 'note' | 'message_id'>): Promise<UserReport> { return this.reports.save(this.reports.create(input)); }
-  async createUnlock(userId: bigint, destinationId: string): Promise<PlayerTravelUnlock> { const found = await this.unlocks.findOne({ where: { user_id: userId, destination_id: destinationId } }); return found || this.unlocks.save(this.unlocks.create({ user_id: userId, destination_id: destinationId })); }
-  async listUnlocks(userId: bigint): Promise<PlayerTravelUnlock[]> { return this.unlocks.find({ where: { user_id: userId }, order: { discovered_at: 'ASC' } }); }
-  async createNotification(input: Pick<SocialNotification, 'user_id' | 'category' | 'title' | 'content' | 'action_metadata' | 'expires_at'>): Promise<SocialNotification> { return this.notifications.save(this.notifications.create(input)); }
-  async listNotifications(userId: bigint, limit: number, before?: Date): Promise<SocialNotification[]> { const where: any = { user_id: userId, expires_at: MoreThan(new Date()) }; if (before) where.created_at = LessThan(before); return this.notifications.find({ where, order: { created_at: 'DESC' }, take: limit }); }
-  async markNotificationRead(userId: bigint, id: bigint): Promise<SocialNotification | null> { const notification = await this.notifications.findOne({ where: { id, user_id: userId } }); if (!notification) return null; notification.read_at = new Date(); return this.notifications.save(notification); }
-  async markAllNotificationsRead(userId: bigint): Promise<number> { const result = await this.notifications.createQueryBuilder().update(SocialNotification).set({ read_at: new Date() }).where('user_id = :userId AND read_at IS NULL', { userId }).execute(); return result.affected || 0; }
-  async countUnreadNotifications(userId: bigint): Promise<number> { return this.notifications.count({ where: { user_id: userId, read_at: null, expires_at: MoreThan(new Date()) } }); }
-  async purgeUsers(userIds: bigint[]): Promise<void> {
-    if (userIds.length === 0) return;
-    const ids = userIds;
-    await Promise.all([
-      this.friendships.createQueryBuilder().delete().where('user_low_id IN (:...ids) OR user_high_id IN (:...ids)', { ids }).execute(),
-      this.requests.createQueryBuilder().delete().where('requester_id IN (:...ids) OR recipient_id IN (:...ids)', { ids }).execute(),
-      this.blocks.createQueryBuilder().delete().where('user_id IN (:...ids) OR blocked_user_id IN (:...ids)', { ids }).execute(),
-      this.messages.createQueryBuilder().delete().where('sender_id IN (:...ids) OR recipient_id IN (:...ids)', { ids }).execute(),
-      this.reports.createQueryBuilder().delete().where('reporter_id IN (:...ids) OR reported_user_id IN (:...ids)', { ids }).execute(),
-      this.unlocks.createQueryBuilder().delete().where('user_id IN (:...ids)', { ids }).execute(),
-      this.notifications.createQueryBuilder().delete().where('user_id IN (:...ids)', { ids }).orWhere("JSON_CONTAINS(action_metadata, JSON_OBJECT('testLab', true))").execute(),
-    ]);
-  }
-  async cleanupExpired(now: Date): Promise<void> { await Promise.all([this.requests.delete({ status: FriendRequestStatus.PENDING, expires_at: LessThan(now) }), this.messages.delete({ expires_at: LessThan(now) }), this.notifications.delete({ expires_at: LessThan(now) })]); }
-}

src/business/social/social.entities.ts

@@ -1,176 +0,0 @@
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  PrimaryGeneratedColumn,
-  UpdateDateColumn,
-} from 'typeorm';
-
-@Entity('friendships')
-@Index(['user_low_id', 'user_high_id'], { unique: true })
-export class Friendship {
-  @PrimaryGeneratedColumn({ type: 'bigint' })
-  id: bigint;
-
-  @Column({ type: 'bigint' })
-  user_low_id: bigint;
-
-  @Column({ type: 'bigint' })
-  user_high_id: bigint;
-
-  @CreateDateColumn({ type: 'datetime' })
-  created_at: Date;
-}
-
-export enum FriendRequestStatus {
-  PENDING = 'pending',
-  ACCEPTED = 'accepted',
-  REJECTED = 'rejected',
-  CANCELLED = 'cancelled',
-}
-
-@Entity('friend_requests')
-@Index(['requester_id', 'recipient_id', 'status'])
-export class FriendRequest {
-  @PrimaryGeneratedColumn({ type: 'bigint' })
-  id: bigint;
-
-  @Column({ type: 'bigint' })
-  requester_id: bigint;
-
-  @Column({ type: 'bigint' })
-  recipient_id: bigint;
-
-  @Column({ type: 'varchar', length: 16, default: FriendRequestStatus.PENDING })
-  status: FriendRequestStatus;
-
-  @CreateDateColumn({ type: 'datetime' })
-  created_at: Date;
-
-  @Column({ type: 'datetime' })
-  expires_at: Date;
-
-  @Column({ type: 'datetime', nullable: true })
-  responded_at?: Date | null;
-}
-
-@Entity('user_blocks')
-@Index(['user_id', 'blocked_user_id'], { unique: true })
-export class UserBlock {
-  @PrimaryGeneratedColumn({ type: 'bigint' })
-  id: bigint;
-
-  @Column({ type: 'bigint' })
-  user_id: bigint;
-
-  @Column({ type: 'bigint' })
-  blocked_user_id: bigint;
-
-  @CreateDateColumn({ type: 'datetime' })
-  created_at: Date;
-}
-
-@Entity('direct_messages')
-@Index(['sender_id', 'recipient_id', 'created_at'])
-@Index(['recipient_id', 'read_at'])
-export class DirectMessage {
-  @PrimaryGeneratedColumn({ type: 'bigint' })
-  id: bigint;
-
-  @Column({ type: 'bigint' })
-  sender_id: bigint;
-
-  @Column({ type: 'bigint' })
-  recipient_id: bigint;
-
-  @Column({ type: 'varchar', length: 1000 })
-  content: string;
-
-  @CreateDateColumn({ type: 'datetime' })
-  created_at: Date;
-
-  @Column({ type: 'datetime' })
-  expires_at: Date;
-
-  @Column({ type: 'datetime', nullable: true })
-  read_at?: Date | null;
-}
-
-@Entity('user_reports')
-@Index(['reporter_id', 'created_at'])
-export class UserReport {
-  @PrimaryGeneratedColumn({ type: 'bigint' })
-  id: bigint;
-
-  @Column({ type: 'bigint' })
-  reporter_id: bigint;
-
-  @Column({ type: 'bigint' })
-  reported_user_id: bigint;
-
-  @Column({ type: 'varchar', length: 32 })
-  reason: string;
-
-  @Column({ type: 'varchar', length: 500, nullable: true })
-  note?: string | null;
-
-  @Column({ type: 'bigint', nullable: true })
-  message_id?: bigint | null;
-
-  @Column({ type: 'varchar', length: 24, default: 'received' })
-  status: string;
-
-  @CreateDateColumn({ type: 'datetime' })
-  created_at: Date;
-}
-
-@Entity('player_travel_unlocks')
-@Index(['user_id', 'destination_id'], { unique: true })
-export class PlayerTravelUnlock {
-  @PrimaryGeneratedColumn({ type: 'bigint' })
-  id: bigint;
-
-  @Column({ type: 'bigint' })
-  user_id: bigint;
-
-  @Column({ type: 'varchar', length: 80 })
-  destination_id: string;
-
-  @CreateDateColumn({ type: 'datetime' })
-  discovered_at: Date;
-}
-
-@Entity('social_notifications')
-@Index(['user_id', 'read_at', 'created_at'])
-export class SocialNotification {
-  @PrimaryGeneratedColumn({ type: 'bigint' })
-  id: bigint;
-
-  @Column({ type: 'bigint' })
-  user_id: bigint;
-
-  @Column({ type: 'varchar', length: 48 })
-  category: string;
-
-  @Column({ type: 'varchar', length: 100 })
-  title: string;
-
-  @Column({ type: 'varchar', length: 500 })
-  content: string;
-
-  @Column({ type: 'json', nullable: true })
-  action_metadata?: Record<string, unknown> | null;
-
-  @Column({ type: 'datetime', nullable: true })
-  read_at?: Date | null;
-
-  @CreateDateColumn({ type: 'datetime' })
-  created_at: Date;
-
-  @Column({ type: 'datetime' })
-  expires_at: Date;
-
-  @UpdateDateColumn({ type: 'datetime' })
-  updated_at: Date;
-}

src/business/social/social.memory-store.ts

@@ -1,89 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import {
-  DirectMessage,
-  FriendRequest,
-  FriendRequestStatus,
-  Friendship,
-  PlayerTravelUnlock,
-  SocialNotification,
-  UserBlock,
-  UserReport,
-} from './social.entities';
-import { SocialStore } from './social.store';
-
-@Injectable()
-export class SocialMemoryStore implements SocialStore {
-  private nextId = BigInt(1);
-  private friendships: Friendship[] = [];
-  private requests: FriendRequest[] = [];
-  private blocks: UserBlock[] = [];
-  private messages: DirectMessage[] = [];
-  private reports: UserReport[] = [];
-  private unlocks: PlayerTravelUnlock[] = [];
-  private notifications: SocialNotification[] = [];
-
-  private id(): bigint { return this.nextId++; }
-
-  async listFriendships(userId: bigint): Promise<Friendship[]> {
-    return this.friendships.filter((item) => item.user_low_id === userId || item.user_high_id === userId);
-  }
-  async findFriendship(userLowId: bigint, userHighId: bigint): Promise<Friendship | null> {
-    return this.friendships.find((item) => item.user_low_id === userLowId && item.user_high_id === userHighId) || null;
-  }
-  async createFriendship(userLowId: bigint, userHighId: bigint): Promise<Friendship> {
-    const found = await this.findFriendship(userLowId, userHighId);
-    if (found) return found;
-    const record = Object.assign(new Friendship(), { id: this.id(), user_low_id: userLowId, user_high_id: userHighId, created_at: new Date() });
-    this.friendships.push(record); return record;
-  }
-  async deleteFriendship(userLowId: bigint, userHighId: bigint): Promise<void> {
-    this.friendships = this.friendships.filter((item) => item.user_low_id !== userLowId || item.user_high_id !== userHighId);
-  }
-  async findPendingFriendRequest(requesterId: bigint, recipientId: bigint): Promise<FriendRequest | null> {
-    return this.requests.find((item) => item.requester_id === requesterId && item.recipient_id === recipientId && item.status === FriendRequestStatus.PENDING && item.expires_at > new Date()) || null;
-  }
-  async createFriendRequest(requesterId: bigint, recipientId: bigint, expiresAt: Date): Promise<FriendRequest> {
-    const record = Object.assign(new FriendRequest(), { id: this.id(), requester_id: requesterId, recipient_id: recipientId, status: FriendRequestStatus.PENDING, created_at: new Date(), expires_at: expiresAt, responded_at: null });
-    this.requests.push(record); return record;
-  }
-  async findFriendRequest(id: bigint): Promise<FriendRequest | null> { return this.requests.find((item) => item.id === id) || null; }
-  async saveFriendRequest(request: FriendRequest): Promise<FriendRequest> { return request; }
-  async cancelPendingRequestsBetween(userA: bigint, userB: bigint): Promise<void> {
-    for (const request of this.requests) if (request.status === FriendRequestStatus.PENDING && ((request.requester_id === userA && request.recipient_id === userB) || (request.requester_id === userB && request.recipient_id === userA))) { request.status = FriendRequestStatus.CANCELLED; request.responded_at = new Date(); }
-  }
-  async listFriendRequests(userId: bigint): Promise<FriendRequest[]> { return this.requests.filter((item) => item.recipient_id === userId && item.status === FriendRequestStatus.PENDING && item.expires_at > new Date()).sort((a, b) => b.created_at.getTime() - a.created_at.getTime()); }
-  async createBlock(userId: bigint, blockedUserId: bigint): Promise<UserBlock> {
-    const found = this.blocks.find((item) => item.user_id === userId && item.blocked_user_id === blockedUserId); if (found) return found;
-    const record = Object.assign(new UserBlock(), { id: this.id(), user_id: userId, blocked_user_id: blockedUserId, created_at: new Date() }); this.blocks.push(record); return record;
-  }
-  async deleteBlock(userId: bigint, blockedUserId: bigint): Promise<void> { this.blocks = this.blocks.filter((item) => item.user_id !== userId || item.blocked_user_id !== blockedUserId); }
-  async isBlocked(userId: bigint, blockedUserId: bigint): Promise<boolean> { return this.blocks.some((item) => item.user_id === userId && item.blocked_user_id === blockedUserId); }
-  async listBlocks(userId: bigint): Promise<UserBlock[]> { return this.blocks.filter((item) => item.user_id === userId); }
-  async createDirectMessage(input: Pick<DirectMessage, 'sender_id' | 'recipient_id' | 'content' | 'expires_at'>): Promise<DirectMessage> {
-    const record = Object.assign(new DirectMessage(), { id: this.id(), ...input, created_at: new Date(), read_at: null }); this.messages.push(record); return record;
-  }
-  async listDirectMessages(userA: bigint, userB: bigint, limit: number, before?: Date): Promise<DirectMessage[]> { return this.messages.filter((item) => ((item.sender_id === userA && item.recipient_id === userB) || (item.sender_id === userB && item.recipient_id === userA)) && item.expires_at > new Date() && (!before || item.created_at < before)).sort((a, b) => b.created_at.getTime() - a.created_at.getTime()).slice(0, limit); }
-  async markDirectMessagesRead(readerId: bigint, otherUserId: bigint): Promise<number> { let affected = 0; for (const item of this.messages) if (item.sender_id === otherUserId && item.recipient_id === readerId && !item.read_at) { item.read_at = new Date(); affected++; } return affected; }
-  async listConversations(userId: bigint): Promise<DirectMessage[]> { const latest = new Map<string, DirectMessage>(); for (const item of this.messages) { if (item.expires_at <= new Date() || (item.sender_id !== userId && item.recipient_id !== userId)) continue; const other = item.sender_id === userId ? item.recipient_id : item.sender_id; const old = latest.get(other.toString()); if (!old || old.created_at < item.created_at) latest.set(other.toString(), item); } return [...latest.values()].sort((a, b) => b.created_at.getTime() - a.created_at.getTime()); }
-  async countUnreadDirectMessages(userId: bigint): Promise<number> { return this.messages.filter((item) => item.recipient_id === userId && !item.read_at && item.expires_at > new Date()).length; }
-  async createReport(input: Pick<UserReport, 'reporter_id' | 'reported_user_id' | 'reason' | 'note' | 'message_id'>): Promise<UserReport> { const record = Object.assign(new UserReport(), { id: this.id(), ...input, status: 'received', created_at: new Date() }); this.reports.push(record); return record; }
-  async createUnlock(userId: bigint, destinationId: string): Promise<PlayerTravelUnlock> { const found = this.unlocks.find((item) => item.user_id === userId && item.destination_id === destinationId); if (found) return found; const record = Object.assign(new PlayerTravelUnlock(), { id: this.id(), user_id: userId, destination_id: destinationId, discovered_at: new Date() }); this.unlocks.push(record); return record; }
-  async listUnlocks(userId: bigint): Promise<PlayerTravelUnlock[]> { return this.unlocks.filter((item) => item.user_id === userId); }
-  async createNotification(input: Pick<SocialNotification, 'user_id' | 'category' | 'title' | 'content' | 'action_metadata' | 'expires_at'>): Promise<SocialNotification> { const now = new Date(); const record = Object.assign(new SocialNotification(), { id: this.id(), ...input, created_at: now, updated_at: now, read_at: null }); this.notifications.push(record); return record; }
-  async listNotifications(userId: bigint, limit: number, before?: Date): Promise<SocialNotification[]> { return this.notifications.filter((item) => item.user_id === userId && item.expires_at > new Date() && (!before || item.created_at < before)).sort((a, b) => b.created_at.getTime() - a.created_at.getTime()).slice(0, limit); }
-  async markNotificationRead(userId: bigint, id: bigint): Promise<SocialNotification | null> { const item = this.notifications.find((entry) => entry.user_id === userId && entry.id === id); if (item) { item.read_at = new Date(); item.updated_at = new Date(); } return item || null; }
-  async markAllNotificationsRead(userId: bigint): Promise<number> { let affected = 0; for (const item of this.notifications) if (item.user_id === userId && !item.read_at) { item.read_at = new Date(); item.updated_at = new Date(); affected++; } return affected; }
-  async countUnreadNotifications(userId: bigint): Promise<number> { return this.notifications.filter((item) => item.user_id === userId && !item.read_at && item.expires_at > new Date()).length; }
-  async purgeUsers(userIds: bigint[]): Promise<void> {
-    const ids = new Set(userIds.map((id) => id.toString()));
-    const has = (id: bigint) => ids.has(id.toString());
-    this.friendships = this.friendships.filter((item) => !has(item.user_low_id) && !has(item.user_high_id));
-    this.requests = this.requests.filter((item) => !has(item.requester_id) && !has(item.recipient_id));
-    this.blocks = this.blocks.filter((item) => !has(item.user_id) && !has(item.blocked_user_id));
-    this.messages = this.messages.filter((item) => !has(item.sender_id) && !has(item.recipient_id));
-    this.reports = this.reports.filter((item) => !has(item.reporter_id) && !has(item.reported_user_id));
-    this.unlocks = this.unlocks.filter((item) => !has(item.user_id));
-    this.notifications = this.notifications.filter((item) => !has(item.user_id) && !(item.action_metadata as Record<string, unknown> | null)?.testLab);
-  }
-  async cleanupExpired(now: Date): Promise<void> { this.requests = this.requests.filter((item) => item.status !== FriendRequestStatus.PENDING || item.expires_at > now); this.messages = this.messages.filter((item) => item.expires_at > now); this.notifications = this.notifications.filter((item) => item.expires_at > now); }
-}

src/business/social/social.module.ts

@@ -1,34 +0,0 @@
-import { DynamicModule, Global, Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
-import { AuthModule } from '../auth/auth.module';
-import { ChatModule } from '../chat/chat.module';
-import { LoginCoreModule } from '../../core/login_core/login_core.module';
-import { SocialController, WorldTravelController } from './social.controller';
-import { SocialDatabaseStore } from './social.database-store';
-import { SocialMemoryStore } from './social.memory-store';
-import { DirectMessage, FriendRequest, Friendship, PlayerTravelUnlock, SocialNotification, UserBlock, UserReport } from './social.entities';
-import { SocialService } from './social.service';
-import { SOCIAL_STORE } from './social.store';
-
-function isDatabaseConfigured(): boolean {
-  return ['DB_HOST', 'DB_PORT', 'DB_USERNAME', 'DB_PASSWORD', 'DB_NAME'].every((key) => process.env[key]);
-}
-
-@Global()
-@Module({})
-export class SocialModule {
-  static forRoot(): DynamicModule {
-    const database = isDatabaseConfigured();
-    return {
-      module: SocialModule,
-      imports: [AuthModule, ChatModule, LoginCoreModule, ...(database ? [TypeOrmModule.forFeature([Friendship, FriendRequest, UserBlock, DirectMessage, UserReport, PlayerTravelUnlock, SocialNotification])] : [])],
-      controllers: [SocialController, WorldTravelController],
-      providers: [
-        ...(database ? [SocialDatabaseStore] : [SocialMemoryStore]),
-        { provide: SOCIAL_STORE, useExisting: database ? SocialDatabaseStore : SocialMemoryStore },
-        SocialService,
-      ],
-      exports: [SocialService],
-    };
-  }
-}

src/business/social/social.service.ts

@@ -1,531 +0,0 @@
-import {
-  BadRequestException,
-  ForbiddenException,
-  Inject,
-  Injectable,
-  Logger,
-  NotFoundException,
-} from '@nestjs/common';
-import { Cron, CronExpression } from '@nestjs/schedule';
-import { AccountProfileService } from '../auth/account_profile.service';
-import { getTestLabPresence } from '../admin/test_lab_presence.registry';
-import { ChatSessionService } from '../chat/services/chat_session.service';
-import { FriendRequestStatus } from './social.entities';
-import { SOCIAL_STORE, SocialStore } from './social.store';
-
-const NEARBY_DISTANCE = 160;
-const RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
-const FRIEND_REQUEST_MS = 30 * 24 * 60 * 60 * 1000;
-const NICKNAME_COOLDOWN_MS = 7 * 24 * 60 * 60 * 1000;
-
-export const INTEREST_TAGS = [
-  { id: 'ai', label: 'AI/大模型' },
-  { id: 'programming', label: '编程开发' },
-  { id: 'data_science', label: '数据科学' },
-  { id: 'open_source', label: '开源协作' },
-  { id: 'product', label: '产品' },
-  { id: 'design', label: '设计' },
-  { id: 'game_dev', label: '游戏开发' },
-  { id: 'content_creation', label: '内容创作' },
-  { id: 'community', label: '社区活动' },
-  { id: 'learning_partner', label: '学习搭子' },
-  { id: 'career', label: '职业成长' },
-  { id: 'casual_chat', label: '轻松闲聊' },
-] as const;
-
-const INTEREST_IDS = new Set<string>(INTEREST_TAGS.map((tag) => tag.id));
-const SOCIAL_SETTINGS_KEY = 'whaletown_settings';
-const DEFAULT_PRIVACY = {
-  allow_nearby_profile: true,
-  allow_nearby_private: true,
-  allow_nearby_friend_requests: true,
-};
-const TRAVEL_MAP_ORIGINS: Record<string, { x: number; y: number }> = {
-  whale_port: { x: 1280, y: 960 },
-  work_zone: { x: 1280, y: 960 },
-  whale_cafe: { x: 768, y: 512 },
-  personal_space: { x: 768, y: 512 },
-};
-const DISCOVERY_DISTANCE = 180;
-
-export const TRAVEL_DESTINATIONS = [
-  { id: 'square_center', mapId: 'whale_port', label: '广场中心', x: 1280, y: 990, initial: true },
-  { id: 'square_dock', mapId: 'whale_port', label: '码头', x: 410, y: 758 },
-  { id: 'square_headquarters', mapId: 'whale_port', label: '总部', x: 1293, y: 360 },
-  { id: 'square_cottage', mapId: 'whale_port', label: '小屋', x: 2125, y: 768 },
-  { id: 'square_workshop', mapId: 'whale_port', label: '工坊', x: 1925, y: 1460 },
-  { id: 'square_notice', mapId: 'whale_port', label: '公告栏', x: 738, y: 1608 },
-  { id: 'square_work_zone_gate', mapId: 'whale_port', label: '打工区入口', x: 1280, y: 1735 },
-  { id: 'work_entrance', mapId: 'work_zone', label: '打工区入口', x: 1280, y: 1715 },
-  { id: 'work_mall', mapId: 'work_zone', label: '商城', x: 1280, y: 346 },
-  { id: 'work_cafe_gate', mapId: 'work_zone', label: '咖啡馆入口', x: 236, y: 1182 },
-  { id: 'work_jobs', mapId: 'work_zone', label: '任务中心', x: 778, y: 1152 },
-  { id: 'work_courses', mapId: 'work_zone', label: '课程看板', x: 1776, y: 960 },
-  { id: 'work_ai', mapId: 'work_zone', label: 'AI 站', x: 1732, y: 1508 },
-  { id: 'work_exchange', mapId: 'work_zone', label: '鲸币兑换处', x: 2355, y: 1508 },
-  { id: 'cafe_entrance', mapId: 'whale_cafe', label: '咖啡馆入口', x: 768, y: 875 },
-  { id: 'cafe_counter', mapId: 'whale_cafe', label: '服务台', x: 768, y: 475 },
-  { id: 'cafe_companion', mapId: 'whale_cafe', label: '陪伴区', x: 370, y: 286 },
-  { id: 'personal_room', mapId: 'personal_space', label: '我的房间', x: 768, y: 512, initial: true },
-] as const;
-
-type RealtimeGateway = {
-  sendToPlayer(socketId: string, payload: Record<string, unknown>): void;
-};
-
-interface UserRecord {
-  id: bigint;
-  username: string;
-  nickname: string;
-  avatar_url?: string | null;
-  nickname_updated_at?: Date | null;
-}
-
-interface UserService {
-  findOne(id: bigint): Promise<UserRecord>;
-  update(id: bigint, payload: Record<string, unknown>): Promise<UserRecord>;
-}
-
-interface ProfileRecord {
-  id: bigint;
-  user_id: bigint;
-  bio?: string | null;
-  tags?: Record<string, unknown> | null;
-  skin_id?: string | null;
-  current_map: string;
-  pos_x: number;
-  pos_y: number;
-}
-
-interface ProfileService {
-  findByUserId(userId: bigint): Promise<ProfileRecord | null>;
-  update(id: bigint, payload: Record<string, unknown>): Promise<ProfileRecord>;
-}
-
-@Injectable()
-export class SocialService {
-  private readonly logger = new Logger(SocialService.name);
-  private realtimeGateway?: RealtimeGateway;
-
-  constructor(
-    @Inject(SOCIAL_STORE) private readonly store: SocialStore,
-    @Inject('UsersService') private readonly usersService: UserService,
-    @Inject('IUserProfilesService') private readonly profiles: ProfileService,
-    private readonly accountProfileService: AccountProfileService,
-    private readonly sessions: ChatSessionService,
-  ) {}
-
-  setRealtimeGateway(gateway: RealtimeGateway): void {
-    this.realtimeGateway = gateway;
-  }
-
-  getInterestTags() { return INTEREST_TAGS; }
-
-  async getOwnSocialProfile(userId: bigint) {
-    await this.ensureProfile(userId);
-    return this.buildProfile(userId, userId, true);
-  }
-
-  async updateSocialProfile(userId: bigint, update: { nickname?: string; bio?: string; interests?: string[] }) {
-    const user = await this.usersService.findOne(userId);
-    const profile = await this.ensureProfile(userId);
-
-    if (update.nickname !== undefined) {
-      const nickname = update.nickname.trim();
-      if (!nickname) throw new BadRequestException('昵称不能为空');
-      if (nickname !== user.nickname) {
-        const lastUpdatedAt = user.nickname_updated_at ? new Date(user.nickname_updated_at).getTime() : 0;
-        const remaining = NICKNAME_COOLDOWN_MS - (Date.now() - lastUpdatedAt);
-        if (lastUpdatedAt && remaining > 0) {
-          throw new ForbiddenException(`昵称每 7 天只能修改一次，还需等待 ${Math.ceil(remaining / 86400000)} 天`);
-        }
-        await this.usersService.update(userId, { nickname, nickname_updated_at: new Date() });
-      }
-    }
-
-    const tags = this.profileTags(profile);
-    if (update.interests !== undefined) {
-      const interests = [...new Set(update.interests.map((value) => value.trim()))];
-      if (interests.length > 3 || interests.some((value) => !INTEREST_IDS.has(value))) {
-        throw new BadRequestException('兴趣标签不在允许的目录内');
-      }
-      tags.interests = interests;
-    }
-    await this.profiles.update(profile.id, { bio: update.bio !== undefined ? update.bio.trim() : profile.bio || '', tags });
-    return this.getOwnSocialProfile(userId);
-  }
-
-  async getPublicProfile(viewerId: bigint, targetId: bigint) {
-    const self = viewerId === targetId;
-    if (!self && !(await this.areFriends(viewerId, targetId))) {
-      await this.assertNearbyAllowed(viewerId, targetId, 'profile');
-    }
-    return this.buildProfile(viewerId, targetId, self);
-  }
-
-  async getFriends(userId: bigint) {
-    const friendships = await this.store.listFriendships(userId);
-    const result = [];
-    for (const friendship of friendships) {
-      const friendId = friendship.user_low_id === userId ? friendship.user_high_id : friendship.user_low_id;
-      result.push(await this.buildProfile(userId, friendId, false));
-    }
-    return result.sort((a, b) => Number(b.online) - Number(a.online) || a.nickname.localeCompare(b.nickname));
-  }
-
-  async getFriendRequests(userId: bigint) {
-    const requests = await this.store.listFriendRequests(userId);
-    return Promise.all(requests.map(async (request) => ({
-      id: request.id.toString(),
-      createdAt: request.created_at,
-      expiresAt: request.expires_at,
-      requester: await this.buildProfile(userId, request.requester_id, false),
-    })));
-  }
-
-  async createFriendRequest(requesterId: bigint, targetId: bigint) {
-    this.assertDistinct(requesterId, targetId);
-    await this.assertNotBlockedEitherWay(requesterId, targetId);
-    if (await this.areFriends(requesterId, targetId)) throw new BadRequestException('已经是好友');
-    await this.assertNearbyAllowed(requesterId, targetId, 'friend');
-    if (await this.store.findPendingFriendRequest(requesterId, targetId)) throw new BadRequestException('好友请求已发送');
-
-    await this.usersService.findOne(targetId);
-    const request = await this.store.createFriendRequest(requesterId, targetId, new Date(Date.now() + FRIEND_REQUEST_MS));
-    const requester = await this.buildProfile(targetId, requesterId, false);
-    await this.createNotification(targetId, 'friend_request', '新的好友申请', `${requester.nickname} 想与你成为好友`, { requestId: request.id.toString(), userId: requesterId.toString() });
-    await this.sendToUser(targetId, { t: 'friend_request_received', request: { id: request.id.toString(), requester } });
-    return { id: request.id.toString(), createdAt: request.created_at, expiresAt: request.expires_at };
-  }
-
-  /** 仅供测试实验室调用：使用真实社交记录，但合成玩家无需真实 WebSocket 会话。 */
-  async createTestFriendRequest(requesterId: bigint, targetId: bigint) {
-    this.assertDistinct(requesterId, targetId);
-    await this.assertNotBlockedEitherWay(requesterId, targetId);
-    if (await this.areFriends(requesterId, targetId)) throw new BadRequestException('已经是好友');
-    if (await this.store.findPendingFriendRequest(requesterId, targetId)) throw new BadRequestException('好友请求已发送');
-
-    await this.usersService.findOne(targetId);
-    const request = await this.store.createFriendRequest(requesterId, targetId, new Date(Date.now() + FRIEND_REQUEST_MS));
-    const requester = await this.buildProfile(targetId, requesterId, false);
-    await this.createNotification(targetId, 'friend_request', '新的好友申请', `${requester.nickname} 想与你成为好友`, { requestId: request.id.toString(), userId: requesterId.toString(), testLab: true });
-    await this.sendToUser(targetId, { t: 'friend_request_received', request: { id: request.id.toString(), requester } });
-    return { id: request.id.toString(), createdAt: request.created_at, expiresAt: request.expires_at };
-  }
-
-  async respondToTestFriendRequest(actorId: bigint, requesterId: bigint, accept: boolean) {
-    const request = await this.store.findPendingFriendRequest(requesterId, actorId);
-    if (!request) throw new NotFoundException('不存在待处理的好友申请');
-    return accept
-      ? this.acceptFriendRequest(actorId, request.id)
-      : this.rejectFriendRequest(actorId, request.id);
-  }
-
-  async acceptFriendRequest(userId: bigint, requestId: bigint) {
-    const request = await this.store.findFriendRequest(requestId);
-    if (!request || request.recipient_id !== userId || request.status !== FriendRequestStatus.PENDING || request.expires_at <= new Date()) throw new NotFoundException('好友请求不存在或已过期');
-    await this.assertNotBlockedEitherWay(userId, request.requester_id);
-    const [low, high] = this.sortIds(userId, request.requester_id);
-    await this.store.createFriendship(low, high);
-    request.status = FriendRequestStatus.ACCEPTED;
-    request.responded_at = new Date();
-    await this.store.saveFriendRequest(request);
-    await this.store.cancelPendingRequestsBetween(userId, request.requester_id);
-    const accepter = await this.buildProfile(request.requester_id, userId, false);
-    await this.createNotification(request.requester_id, 'friend_accepted', '好友申请已接受', `${accepter.nickname} 已成为你的好友`, { userId: userId.toString() });
-    await this.sendToUser(request.requester_id, { t: 'friendship_changed', action: 'accepted', friend: accepter });
-    await this.sendToUser(userId, { t: 'friendship_changed', action: 'accepted', friend: await this.buildProfile(userId, request.requester_id, false) });
-    return { friend: await this.buildProfile(userId, request.requester_id, false) };
-  }
-
-  async rejectFriendRequest(userId: bigint, requestId: bigint) {
-    const request = await this.store.findFriendRequest(requestId);
-    if (!request || request.recipient_id !== userId || request.status !== FriendRequestStatus.PENDING) throw new NotFoundException('好友请求不存在');
-    request.status = FriendRequestStatus.REJECTED;
-    request.responded_at = new Date();
-    await this.store.saveFriendRequest(request);
-    const rejecter = await this.buildProfile(request.requester_id, userId, false);
-    await this.createNotification(request.requester_id, 'friend_rejected', '好友申请未通过', `${rejecter.nickname} 暂未接受你的好友申请`, { userId: userId.toString() });
-    await this.sendToUser(request.requester_id, { t: 'friendship_changed', action: 'rejected', userId: userId.toString() });
-  }
-
-  async cancelFriendRequest(userId: bigint, requestId: bigint) {
-    const request = await this.store.findFriendRequest(requestId);
-    if (!request || request.requester_id !== userId || request.status !== FriendRequestStatus.PENDING) throw new NotFoundException('好友请求不存在');
-    request.status = FriendRequestStatus.CANCELLED;
-    request.responded_at = new Date();
-    await this.store.saveFriendRequest(request);
-  }
-
-  async removeFriend(userId: bigint, friendId: bigint) {
-    const [low, high] = this.sortIds(userId, friendId);
-    await this.store.deleteFriendship(low, high);
-    await this.sendToUser(friendId, { t: 'friendship_changed', action: 'removed', userId: userId.toString() });
-  }
-
-  async listBlocks(userId: bigint) {
-    const blocks = await this.store.listBlocks(userId);
-    return Promise.all(blocks.map(async (block) => ({ createdAt: block.created_at, profile: await this.buildProfile(userId, block.blocked_user_id, false) })));
-  }
-
-  async blockUser(userId: bigint, targetId: bigint) {
-    this.assertDistinct(userId, targetId);
-    await this.usersService.findOne(targetId);
-    await this.store.createBlock(userId, targetId);
-    const [low, high] = this.sortIds(userId, targetId);
-    await this.store.deleteFriendship(low, high);
-    await this.store.cancelPendingRequestsBetween(userId, targetId);
-    await this.sendToUser(targetId, { t: 'friendship_changed', action: 'removed', userId: userId.toString() });
-    return { success: true };
-  }
-
-  async unblockUser(userId: bigint, targetId: bigint) {
-    await this.store.deleteBlock(userId, targetId);
-    return { success: true };
-  }
-
-  async createReport(reporterId: bigint, input: { userId: bigint; reason: string; note?: string; messageId?: bigint; blockAlso?: boolean }) {
-    this.assertDistinct(reporterId, input.userId);
-    const report = await this.store.createReport({ reporter_id: reporterId, reported_user_id: input.userId, reason: input.reason, note: input.note?.trim() || null, message_id: input.messageId || null });
-    if (input.blockAlso) await this.blockUser(reporterId, input.userId);
-    await this.createNotification(reporterId, 'report_receipt', '举报已提交', '我们已收到你的举报，会尽快处理。', { reportId: report.id.toString() });
-    return { id: report.id.toString(), status: report.status };
-  }
-
-  async sendDirectMessage(senderId: bigint, targetId: bigint, content: string) {
-    this.assertDistinct(senderId, targetId);
-    const normalizedContent = content.trim();
-    if (!normalizedContent || normalizedContent.length > 1000) throw new BadRequestException('私聊内容需为 1-1000 个字符');
-    await this.assertNotBlockedEitherWay(senderId, targetId);
-    const targetSocket = await this.sessions.getSocketIdByUserId(targetId.toString());
-    const targetTestPresence = getTestLabPresence(targetId.toString());
-    // 测试实验室假人没有真实 WebSocket 连接，但其合成在线状态应与普通在线玩家
-    // 一致地通过私聊在线校验。消息仍只写入现有的私聊存储，不触发外部副作用。
-    if (!targetSocket && !targetTestPresence?.online) throw new BadRequestException('对方当前不在线');
-    if (!(await this.areFriends(senderId, targetId))) await this.assertNearbyAllowed(senderId, targetId, 'private');
-
-    const message = await this.store.createDirectMessage({ sender_id: senderId, recipient_id: targetId, content: normalizedContent, expires_at: new Date(Date.now() + RETENTION_MS) });
-    const sender = await this.buildProfile(targetId, senderId, false);
-    const payload = { t: 'dm_message', message: { id: message.id.toString(), senderId: senderId.toString(), recipientId: targetId.toString(), content: message.content, createdAt: message.created_at, sender } };
-    await this.sendToUser(senderId, payload);
-    await this.sendToUser(targetId, payload);
-    return payload.message;
-  }
-
-  /** 测试假人私聊：仍写入正式私聊存储，但不要求假人拥有真实 socket。 */
-  async sendTestDirectMessage(senderId: bigint, targetId: bigint, content: string) {
-    this.assertDistinct(senderId, targetId);
-    const normalizedContent = content.trim();
-    if (!normalizedContent || normalizedContent.length > 1000) throw new BadRequestException('私聊内容需为 1-1000 个字符');
-    await this.assertNotBlockedEitherWay(senderId, targetId);
-    await this.usersService.findOne(targetId);
-    const message = await this.store.createDirectMessage({ sender_id: senderId, recipient_id: targetId, content: normalizedContent, expires_at: new Date(Date.now() + RETENTION_MS) });
-    const sender = await this.buildProfile(targetId, senderId, false);
-    const payload = { t: 'dm_message', message: { id: message.id.toString(), senderId: senderId.toString(), recipientId: targetId.toString(), content: message.content, createdAt: message.created_at, sender } };
-    await this.sendToUser(targetId, payload);
-    return payload.message;
-  }
-
-  async listConversation(userId: bigint, otherUserId: bigint, limit: number, before?: Date) {
-    await this.assertNotBlockedEitherWay(userId, otherUserId);
-    const messages = await this.store.listDirectMessages(userId, otherUserId, limit, before);
-    const other = await this.buildProfile(userId, otherUserId, false);
-    return { other, messages: messages.reverse().map((message) => this.serializeDirectMessage(message)), unreadCount: await this.store.countUnreadDirectMessages(userId) };
-  }
-
-  async listConversations(userId: bigint) {
-    const latest = await this.store.listConversations(userId);
-    return Promise.all(latest.map(async (message) => {
-      const otherId = message.sender_id === userId ? message.recipient_id : message.sender_id;
-      return { other: await this.buildProfile(userId, otherId, false), latestMessage: this.serializeDirectMessage(message) };
-    }));
-  }
-
-  async markConversationRead(userId: bigint, otherUserId: bigint) {
-    const affected = await this.store.markDirectMessagesRead(userId, otherUserId);
-    await this.sendToUser(otherUserId, { t: 'dm_read', readerId: userId.toString() });
-    return { affected };
-  }
-
-  async getNotificationSummary(userId: bigint, limit: number, before?: Date) {
-    const [notifications, unreadCount, unreadMessages] = await Promise.all([
-      this.store.listNotifications(userId, limit, before),
-      this.store.countUnreadNotifications(userId),
-      this.store.countUnreadDirectMessages(userId),
-    ]);
-    return { notifications: notifications.map((notification) => this.serializeNotification(notification)), unreadCount, unreadMessages };
-  }
-
-  async markNotificationRead(userId: bigint, notificationId: bigint) {
-    const notification = await this.store.markNotificationRead(userId, notificationId);
-    if (!notification) throw new NotFoundException('通知不存在');
-    return this.serializeNotification(notification);
-  }
-
-  async markAllNotificationsRead(userId: bigint) { return { affected: await this.store.markAllNotificationsRead(userId) }; }
-
-  async getTravelDestinations(userId: bigint) {
-    const unlocks = await this.store.listUnlocks(userId);
-    const unlocked = new Set(unlocks.map((unlock) => unlock.destination_id));
-    return TRAVEL_DESTINATIONS.map((destination) => ({ ...destination, unlocked: Boolean(('initial' in destination && destination.initial) || unlocked.has(destination.id)) }));
-  }
-
-  async discoverDestination(userId: bigint, destinationId: string) {
-    const destination = this.destination(destinationId);
-	if (!('initial' in destination && destination.initial)) await this.assertAtTravelDestination(userId, destination);
-    await this.store.createUnlock(userId, destination.id);
-    return { ...destination, unlocked: true };
-  }
-
-  async travelTo(userId: bigint, destinationId: string) {
-    const destination = this.destination(destinationId);
-    const unlocked = ('initial' in destination && destination.initial) || (await this.store.listUnlocks(userId)).some((unlock) => unlock.destination_id === destinationId);
-    if (!unlocked) throw new ForbiddenException('该地点尚未解锁');
-    return { ...destination, unlocked: true };
-  }
-
-  async canSeeChat(senderId: string, recipientId: string): Promise<boolean> {
-    if (!/^\d+$/.test(senderId) || !/^\d+$/.test(recipientId)) return false;
-    return !(await this.isBlockedEitherWay(BigInt(senderId), BigInt(recipientId)));
-  }
-
-  async notifyPresenceChanged(userId: string, online: boolean): Promise<void> {
-    if (!/^\d+$/.test(userId)) return;
-    const friends = await this.store.listFriendships(BigInt(userId));
-    for (const friendship of friends) {
-      const otherId = friendship.user_low_id === BigInt(userId) ? friendship.user_high_id : friendship.user_low_id;
-      await this.sendToUser(otherId, { t: 'friend_presence_changed', userId, online });
-    }
-  }
-
-  @Cron(CronExpression.EVERY_HOUR)
-  async cleanupExpiredData(): Promise<void> {
-    await this.store.cleanupExpired(new Date());
-  }
-
-  async purgeTestUsers(userIds: bigint[]): Promise<void> {
-    await this.store.purgeUsers(userIds);
-  }
-
-  private async buildProfile(viewerId: bigint, targetId: bigint, includePrivate: boolean) {
-    const [user, profile, socketId] = await Promise.all([
-      this.usersService.findOne(targetId),
-      this.ensureProfile(targetId),
-      this.sessions.getSocketIdByUserId(targetId.toString()),
-    ]);
-    const tags = this.profileTags(profile);
-    const session = socketId ? await this.sessions.getSession(socketId) : null;
-    const testPresence = getTestLabPresence(targetId);
-    return {
-      id: targetId.toString(),
-      username: user.username,
-      nickname: user.nickname,
-      avatarUrl: user.avatar_url || '',
-      skinId: profile.skin_id || '',
-      online: Boolean(socketId) || Boolean(testPresence?.online),
-      currentArea: testPresence?.mapId || session?.currentMap || profile.current_map,
-      bio: String(profile.bio || '').slice(0, 160),
-      interests: this.validInterests(tags.interests),
-      privacy: includePrivate ? this.privacy(profile) : undefined,
-      isFriend: includePrivate || viewerId === targetId ? false : await this.areFriends(viewerId, targetId),
-      blocked: includePrivate ? false : await this.store.isBlocked(viewerId, targetId),
-    };
-  }
-
-  private async ensureProfile(userId: bigint): Promise<ProfileRecord> {
-    const existing = await this.profiles.findByUserId(userId);
-    if (existing) return existing;
-    await this.accountProfileService.ensureProfile(userId);
-    const profile = await this.profiles.findByUserId(userId);
-    if (!profile) throw new NotFoundException('用户档案不存在');
-    return profile;
-  }
-
-  private profileTags(profile: ProfileRecord): Record<string, any> {
-    return profile.tags && typeof profile.tags === 'object' ? { ...profile.tags } : {};
-  }
-
-  private privacy(profile: ProfileRecord): Record<string, boolean> {
-    const tags = this.profileTags(profile);
-    const values = tags[SOCIAL_SETTINGS_KEY];
-    return { ...DEFAULT_PRIVACY, ...(values && typeof values === 'object' ? values : {}) };
-  }
-
-  private validInterests(value: unknown): string[] {
-    return Array.isArray(value) ? value.map(String).filter((item) => INTEREST_IDS.has(item)).slice(0, 3) : [];
-  }
-
-  private async assertNearbyAllowed(sourceId: bigint, targetId: bigint, purpose: 'profile' | 'private' | 'friend') {
-    const targetSocketId = await this.sessions.getSocketIdByUserId(targetId.toString());
-    const sourceSocketId = await this.sessions.getSocketIdByUserId(sourceId.toString());
-    const targetTestPresence = getTestLabPresence(targetId);
-    const sourceTestPresence = getTestLabPresence(sourceId);
-    const [target, source, profile] = await Promise.all([
-      targetSocketId ? this.sessions.getSession(targetSocketId) : Promise.resolve(null),
-      sourceSocketId ? this.sessions.getSession(sourceSocketId) : Promise.resolve(null),
-      this.ensureProfile(targetId),
-    ]);
-    const targetPosition = targetTestPresence?.online
-      ? { mapId: targetTestPresence.mapId, x: targetTestPresence.x, y: targetTestPresence.y }
-      : target ? { mapId: target.currentMap, x: Number(target.position?.x || 0), y: Number(target.position?.y || 0) } : null;
-    const sourcePosition = sourceTestPresence?.online
-      ? { mapId: sourceTestPresence.mapId, x: sourceTestPresence.x, y: sourceTestPresence.y }
-      : source ? { mapId: source.currentMap, x: Number(source.position?.x || 0), y: Number(source.position?.y || 0) } : null;
-    if (!targetPosition || !sourcePosition) throw new ForbiddenException('陌生玩家需要在线且在附近才能互动');
-    if (targetPosition.mapId !== sourcePosition.mapId) throw new ForbiddenException('陌生玩家仅可在同一地图互动');
-    const distance = Math.hypot(targetPosition.x - sourcePosition.x, targetPosition.y - sourcePosition.y);
-    if (distance > NEARBY_DISTANCE) throw new ForbiddenException('请靠近该玩家后再互动');
-    const privacy = this.privacy(profile);
-    const key = purpose === 'profile' ? 'allow_nearby_profile' : purpose === 'private' ? 'allow_nearby_private' : 'allow_nearby_friend_requests';
-    if (!privacy[key]) throw new ForbiddenException('对方已关闭此类附近互动');
-  }
-
-  private async areFriends(userA: bigint, userB: bigint): Promise<boolean> {
-    const [low, high] = this.sortIds(userA, userB);
-    return Boolean(await this.store.findFriendship(low, high));
-  }
-
-  private async isBlockedEitherWay(userA: bigint, userB: bigint): Promise<boolean> {
-    const [aBlocksB, bBlocksA] = await Promise.all([this.store.isBlocked(userA, userB), this.store.isBlocked(userB, userA)]);
-    return aBlocksB || bBlocksA;
-  }
-
-  private async assertNotBlockedEitherWay(userA: bigint, userB: bigint) {
-    if (await this.isBlockedEitherWay(userA, userB)) throw new ForbiddenException('该互动当前不可用');
-  }
-
-  private async createNotification(userId: bigint, category: string, title: string, content: string, actionMetadata: Record<string, unknown>) {
-    const notification = await this.store.createNotification({ user_id: userId, category, title, content, action_metadata: actionMetadata, expires_at: new Date(Date.now() + RETENTION_MS) });
-    await this.sendToUser(userId, { t: 'notification_created', notification: this.serializeNotification(notification) });
-    return notification;
-  }
-
-  private async sendToUser(userId: bigint, payload: Record<string, unknown>) {
-    const socketId = await this.sessions.getSocketIdByUserId(userId.toString());
-    if (socketId && this.realtimeGateway) this.realtimeGateway.sendToPlayer(socketId, payload);
-  }
-
-  private serializeDirectMessage(message: any) {
-    return { id: message.id.toString(), senderId: message.sender_id.toString(), recipientId: message.recipient_id.toString(), content: message.content, createdAt: message.created_at, readAt: message.read_at || null };
-  }
-  private serializeNotification(notification: any) {
-    return { id: notification.id.toString(), category: notification.category, title: notification.title, content: notification.content, actionMetadata: notification.action_metadata || {}, createdAt: notification.created_at, readAt: notification.read_at || null, expiresAt: notification.expires_at };
-  }
-  private destination(destinationId: string) {
-    const destination = TRAVEL_DESTINATIONS.find((item) => item.id === destinationId);
-    if (!destination) throw new NotFoundException('未知地点');
-    return destination;
-  }
-  private async assertAtTravelDestination(userId: bigint, destination: (typeof TRAVEL_DESTINATIONS)[number]) {
-    const socketId = await this.sessions.getSocketIdByUserId(userId.toString());
-    const session = socketId ? await this.sessions.getSession(socketId) : null;
-    if (!session || session.currentMap !== destination.mapId) throw new ForbiddenException('需要先在该地点附近探索');
-    const origin = TRAVEL_MAP_ORIGINS[destination.mapId] || { x: 0, y: 0 };
-    const targetX = destination.x - origin.x;
-    const targetY = destination.y - origin.y;
-    const distance = Math.hypot(Number(session.position?.x || 0) - targetX, Number(session.position?.y || 0) - targetY);
-    if (distance > DISCOVERY_DISTANCE) throw new ForbiddenException('需要靠近地点后才能解锁');
-  }
-  private assertDistinct(userA: bigint, userB: bigint) { if (userA === userB) throw new BadRequestException('不能对自己执行此操作'); }
-  private sortIds(userA: bigint, userB: bigint): [bigint, bigint] { return userA < userB ? [userA, userB] : [userB, userA]; }
-}

src/business/social/social.store.ts

@@ -1,43 +0,0 @@
-import {
-  DirectMessage,
-  FriendRequest,
-  Friendship,
-  PlayerTravelUnlock,
-  SocialNotification,
-  UserBlock,
-  UserReport,
-} from './social.entities';
-
-export const SOCIAL_STORE = 'SOCIAL_STORE';
-
-export interface SocialStore {
-  listFriendships(userId: bigint): Promise<Friendship[]>;
-  findFriendship(userLowId: bigint, userHighId: bigint): Promise<Friendship | null>;
-  createFriendship(userLowId: bigint, userHighId: bigint): Promise<Friendship>;
-  deleteFriendship(userLowId: bigint, userHighId: bigint): Promise<void>;
-  findPendingFriendRequest(requesterId: bigint, recipientId: bigint): Promise<FriendRequest | null>;
-  createFriendRequest(requesterId: bigint, recipientId: bigint, expiresAt: Date): Promise<FriendRequest>;
-  findFriendRequest(id: bigint): Promise<FriendRequest | null>;
-  saveFriendRequest(request: FriendRequest): Promise<FriendRequest>;
-  cancelPendingRequestsBetween(userA: bigint, userB: bigint): Promise<void>;
-  listFriendRequests(userId: bigint): Promise<FriendRequest[]>;
-  createBlock(userId: bigint, blockedUserId: bigint): Promise<UserBlock>;
-  deleteBlock(userId: bigint, blockedUserId: bigint): Promise<void>;
-  isBlocked(userId: bigint, blockedUserId: bigint): Promise<boolean>;
-  listBlocks(userId: bigint): Promise<UserBlock[]>;
-  createDirectMessage(input: Pick<DirectMessage, 'sender_id' | 'recipient_id' | 'content' | 'expires_at'>): Promise<DirectMessage>;
-  listDirectMessages(userA: bigint, userB: bigint, limit: number, before?: Date): Promise<DirectMessage[]>;
-  markDirectMessagesRead(readerId: bigint, otherUserId: bigint): Promise<number>;
-  listConversations(userId: bigint): Promise<DirectMessage[]>;
-  countUnreadDirectMessages(userId: bigint): Promise<number>;
-  createReport(input: Pick<UserReport, 'reporter_id' | 'reported_user_id' | 'reason' | 'note' | 'message_id'>): Promise<UserReport>;
-  createUnlock(userId: bigint, destinationId: string): Promise<PlayerTravelUnlock>;
-  listUnlocks(userId: bigint): Promise<PlayerTravelUnlock[]>;
-  createNotification(input: Pick<SocialNotification, 'user_id' | 'category' | 'title' | 'content' | 'action_metadata' | 'expires_at'>): Promise<SocialNotification>;
-  listNotifications(userId: bigint, limit: number, before?: Date): Promise<SocialNotification[]>;
-  markNotificationRead(userId: bigint, id: bigint): Promise<SocialNotification | null>;
-  markAllNotificationsRead(userId: bigint): Promise<number>;
-  countUnreadNotifications(userId: bigint): Promise<number>;
-  purgeUsers(userIds: bigint[]): Promise<void>;
-  cleanupExpired(now: Date): Promise<void>;
-}

src/business/tasks/dto/report_task_activity.dto.ts

@@ -1,12 +0,0 @@
-import { IsIn, IsOptional, IsString, MaxLength } from 'class-validator';
-import { TASK_ACTIVITY_TYPES } from '../task_catalog';
-
-export class ReportTaskActivityDto {
-  @IsIn(TASK_ACTIVITY_TYPES)
-  activity: typeof TASK_ACTIVITY_TYPES[number];
-
-  @IsOptional()
-  @IsString()
-  @MaxLength(64)
-  target_id?: string;
-}

src/business/tasks/migrations/create-player-task-progress.sql

@@ -1,15 +0,0 @@
-CREATE TABLE IF NOT EXISTS `player_task_progress` (
-  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键ID',
-  `user_id` bigint NOT NULL COMMENT '关联users.id',
-  `task_id` varchar(80) NOT NULL COMMENT '静态任务ID',
-  `cycle_key` varchar(32) NOT NULL COMMENT '任务周期键',
-  `progress` int NOT NULL DEFAULT 0 COMMENT '当前进度',
-  `activity_state` json NOT NULL COMMENT '去重活动目标等状态',
-  `completed_at` timestamp NULL DEFAULT NULL COMMENT '完成时间',
-  `claimed_at` timestamp NULL DEFAULT NULL COMMENT '领奖时间',
-  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
-  `updated_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
-  PRIMARY KEY (`id`),
-  UNIQUE KEY `uq_player_task_progress_task_cycle` (`user_id`, `task_id`, `cycle_key`),
-  KEY `idx_player_task_progress_user_cycle` (`user_id`, `cycle_key`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='玩家任务进度表';

src/business/tasks/player_task_progress.entity.ts

@@ -1,36 +0,0 @@
-import { Column, Entity, Index, PrimaryGeneratedColumn } from 'typeorm';
-
-@Entity('player_task_progress')
-@Index('uq_player_task_progress_task_cycle', ['user_id', 'task_id', 'cycle_key'], { unique: true })
-@Index('idx_player_task_progress_user_cycle', ['user_id', 'cycle_key'])
-export class PlayerTaskProgress {
-  @PrimaryGeneratedColumn({ type: 'bigint', comment: '主键ID' })
-  id: bigint;
-
-  @Column({ type: 'bigint', nullable: false, comment: '关联users.id' })
-  user_id: bigint;
-
-  @Column({ type: 'varchar', length: 80, nullable: false, comment: '静态任务ID' })
-  task_id: string;
-
-  @Column({ type: 'varchar', length: 32, nullable: false, comment: '任务周期键' })
-  cycle_key: string;
-
-  @Column({ type: 'int', nullable: false, default: 0, comment: '当前进度' })
-  progress: number;
-
-  @Column({ type: 'json', nullable: false, comment: '去重活动目标等状态' })
-  activity_state: Record<string, unknown>;
-
-  @Column({ type: 'timestamp', nullable: true, comment: '完成时间' })
-  completed_at: Date | null;
-
-  @Column({ type: 'timestamp', nullable: true, comment: '领奖时间' })
-  claimed_at: Date | null;
-
-  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP', comment: '创建时间' })
-  created_at: Date;
-
-  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP', onUpdate: 'CURRENT_TIMESTAMP', comment: '更新时间' })
-  updated_at: Date;
-}

src/business/tasks/task.service.ts

@@ -1,35 +0,0 @@
-import { BadRequestException, Inject, Injectable } from '@nestjs/common';
-import { TaskActivityType } from './task_catalog';
-import { TaskBoardPayload, TaskClaimResult, TaskProgressStore } from './tasks.types';
-
-const CLIENT_ACTIVITY_TYPES: TaskActivityType[] = [
-  'guide_opened',
-  'notice_viewed',
-  'map_visited',
-  'course_board_opened',
-  'facility_interacted',
-];
-
-@Injectable()
-export class TaskService {
-  constructor(@Inject('ITaskProgressStore') private readonly taskProgressStore: TaskProgressStore) {}
-
-  async getBoard(userId: bigint): Promise<TaskBoardPayload> {
-    return await this.taskProgressStore.getBoard(userId);
-  }
-
-  async recordClientActivity(userId: bigint, activity: TaskActivityType, targetId?: string): Promise<TaskBoardPayload> {
-    if (!CLIENT_ACTIVITY_TYPES.includes(activity)) {
-      throw new BadRequestException('该任务活动只能由服务器业务记录');
-    }
-    return await this.taskProgressStore.recordActivity(userId, activity, targetId?.trim());
-  }
-
-  async recordActivity(userId: bigint, activity: TaskActivityType, targetId?: string): Promise<TaskBoardPayload> {
-    return await this.taskProgressStore.recordActivity(userId, activity, targetId?.trim());
-  }
-
-  async claim(userId: bigint, taskId: string): Promise<TaskClaimResult> {
-    return await this.taskProgressStore.claim(userId, taskId.trim());
-  }
-}

src/business/tasks/task_catalog.ts

@@ -1,189 +0,0 @@
-export const NEWBIE_CYCLE_KEY = 'newbie';
-
-export const TASK_ACTIVITY_TYPES = [
-  'guide_opened',
-  'notice_viewed',
-  'map_visited',
-  'course_board_opened',
-  'facility_interacted',
-  'public_message_sent',
-  'skin_purchased',
-] as const;
-
-export type TaskActivityType = typeof TASK_ACTIVITY_TYPES[number];
-export type TaskGroup = 'newbie' | 'weekly';
-export type TaskProgressMode = 'count' | 'unique_target';
-
-export interface TaskDefinition {
-  id: string;
-  group: TaskGroup;
-  title: string;
-  description: string;
-  reward: number;
-  target: number;
-  activity?: TaskActivityType;
-  progress_mode?: TaskProgressMode;
-  allowed_targets?: string[];
-  optional?: boolean;
-  bonus?: boolean;
-  sort_order: number;
-}
-
-export interface WeeklyCycle {
-  key: string;
-  starts_at: string;
-  ends_at: string;
-}
-
-export interface TaskProgressState {
-  targets?: string[];
-}
-
-export const NEWBIE_TASKS: TaskDefinition[] = [
-  {
-    id: 'newbie_guide',
-    group: 'newbie',
-    title: '翻阅新人手册',
-    description: '打开新人引导，了解鲸镇的基本操作。',
-    reward: 40,
-    target: 1,
-    activity: 'guide_opened',
-    sort_order: 10,
-  },
-  {
-    id: 'newbie_notice',
-    group: 'newbie',
-    title: '查看镇务公告',
-    description: '在广场查看一次公告栏。',
-    reward: 60,
-    target: 1,
-    activity: 'notice_viewed',
-    sort_order: 20,
-  },
-  {
-    id: 'newbie_work_zone',
-    group: 'newbie',
-    title: '探索打工区',
-    description: '前往打工区，看看小镇的工作与学习入口。',
-    reward: 80,
-    target: 1,
-    activity: 'map_visited',
-    allowed_targets: ['work_zone'],
-    sort_order: 30,
-  },
-  {
-    id: 'newbie_course_board',
-    group: 'newbie',
-    title: '浏览课程板',
-    description: '在打工区打开 Datawhale 课程看板。',
-    reward: 120,
-    target: 1,
-    activity: 'course_board_opened',
-    sort_order: 40,
-  },
-  {
-    id: 'newbie_first_skin',
-    group: 'newbie',
-    title: '选择你的形象',
-    description: '在鲸鱼商城购买任意一款皮肤。此任务可跳过。',
-    reward: 100,
-    target: 1,
-    activity: 'skin_purchased',
-    optional: true,
-    sort_order: 50,
-  },
-];
-
-export const WEEKLY_TASKS: TaskDefinition[] = [
-  {
-    id: 'weekly_explore',
-    group: 'weekly',
-    title: '海风巡游',
-    description: '探索两个不同的开放地图。',
-    reward: 100,
-    target: 2,
-    activity: 'map_visited',
-    progress_mode: 'unique_target',
-    allowed_targets: ['square', 'work_zone', 'whale_cafe'],
-    sort_order: 10,
-  },
-  {
-    id: 'weekly_course',
-    group: 'weekly',
-    title: '本周学习计划',
-    description: '打开一次 Datawhale 课程看板。',
-    reward: 100,
-    target: 1,
-    activity: 'course_board_opened',
-    sort_order: 20,
-  },
-  {
-    id: 'weekly_interact',
-    group: 'weekly',
-    title: '和小镇打招呼',
-    description: '与两个不同的公共设施或 NPC 互动。',
-    reward: 100,
-    target: 2,
-    activity: 'facility_interacted',
-    progress_mode: 'unique_target',
-    allowed_targets: ['welcome_board', 'notice_board', 'npc'],
-    sort_order: 30,
-  },
-  {
-    id: 'weekly_public_message',
-    group: 'weekly',
-    title: '分享此刻',
-    description: '在公共频道成功发送一条消息。',
-    reward: 100,
-    target: 1,
-    activity: 'public_message_sent',
-    sort_order: 40,
-  },
-];
-
-export const WEEKLY_COMPLETION_BONUS: TaskDefinition = {
-  id: 'weekly_completion_bonus',
-  group: 'weekly',
-  title: '本周任务书结算',
-  description: '完成本周全部四项任务后领取额外奖励。',
-  reward: 200,
-  target: 1,
-  bonus: true,
-  sort_order: 90,
-};
-
-export function getCurrentWeeklyCycle(now: Date = new Date()): WeeklyCycle {
-  const formatter = new Intl.DateTimeFormat('en-CA', {
-    timeZone: 'Asia/Shanghai',
-    year: 'numeric',
-    month: '2-digit',
-    day: '2-digit',
-  });
-  const parts = Object.fromEntries(formatter.formatToParts(now)
-    .filter((part) => part.type !== 'literal')
-    .map((part) => [part.type, part.value]));
-  const year = Number(parts.year);
-  const month = Number(parts.month);
-  const day = Number(parts.day);
-  const chinaDateAsUtc = Date.UTC(year, month - 1, day);
-  const weekday = new Date(chinaDateAsUtc).getUTCDay();
-  const daysSinceMonday = (weekday + 6) % 7;
-  const mondayAsUtc = chinaDateAsUtc - daysSinceMonday * 24 * 60 * 60 * 1000;
-  const monday = new Date(mondayAsUtc);
-  const cycleDate = monday.toISOString().slice(0, 10);
-  const startsAt = new Date(mondayAsUtc - 8 * 60 * 60 * 1000);
-  const endsAt = new Date(startsAt.getTime() + 7 * 24 * 60 * 60 * 1000);
-  return {
-    key: `weekly:${cycleDate}`,
-    starts_at: startsAt.toISOString(),
-    ends_at: endsAt.toISOString(),
-  };
-}
-
-export function getTaskDefinitions(): TaskDefinition[] {
-  return [...NEWBIE_TASKS, ...WEEKLY_TASKS, WEEKLY_COMPLETION_BONUS];
-}
-
-export function getTaskCycleKey(definition: TaskDefinition, cycle: WeeklyCycle): string {
-  return definition.group === 'weekly' ? cycle.key : NEWBIE_CYCLE_KEY;
-}

src/business/tasks/task_progress_database.service.ts

@@ -1,140 +0,0 @@
-import { BadRequestException, ConflictException, Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { DataSource, In, Repository } from 'typeorm';
-import { UserWalletsService } from '../../core/db/user_wallets/user_wallets.service';
-import {
-  getCurrentWeeklyCycle,
-  getTaskCycleKey,
-  getTaskDefinitions,
-  NEWBIE_CYCLE_KEY,
-  TaskActivityType,
-  TaskDefinition,
-  TaskProgressState,
-  WEEKLY_COMPLETION_BONUS,
-  WEEKLY_TASKS,
-  WeeklyCycle,
-} from './task_catalog';
-import { PlayerTaskProgress } from './player_task_progress.entity';
-import { buildTaskBoard, TaskBoardPayload, TaskClaimResult, TaskProgressRow, TaskProgressStore } from './tasks.types';
-
-@Injectable()
-export class TaskProgressDatabaseService implements TaskProgressStore {
-  constructor(
-    @InjectRepository(PlayerTaskProgress) private readonly progressRepository: Repository<PlayerTaskProgress>,
-    private readonly dataSource: DataSource,
-    private readonly walletService: UserWalletsService,
-  ) {}
-
-  async getBoard(userId: bigint): Promise<TaskBoardPayload> {
-    const cycle = getCurrentWeeklyCycle();
-    await this.ensureRows(this.progressRepository, userId, cycle);
-    const rows = await this.findRows(this.progressRepository, userId, cycle);
-    await this.syncWeeklyBonus(this.progressRepository, rows);
-    return buildTaskBoard(rows, cycle);
-  }
-
-  async recordActivity(userId: bigint, activity: TaskActivityType, targetId?: string): Promise<TaskBoardPayload> {
-    const cycle = getCurrentWeeklyCycle();
-    return await this.dataSource.transaction(async (manager) => {
-      const repository = manager.getRepository(PlayerTaskProgress);
-      await this.ensureRows(repository, userId, cycle);
-      const rows = await this.findRows(repository, userId, cycle, true);
-      for (const definition of getTaskDefinitions()) {
-        if (definition.bonus || definition.activity !== activity) continue;
-        const row = this.findRow(rows, definition, cycle);
-        this.applyActivity(definition, row, targetId);
-      }
-      await repository.save(rows);
-      await this.syncWeeklyBonus(repository, rows);
-      return buildTaskBoard(rows, cycle);
-    });
-  }
-
-  async claim(userId: bigint, taskId: string): Promise<TaskClaimResult> {
-    const cycle = getCurrentWeeklyCycle();
-    const definition = getTaskDefinitions().find((item) => item.id === taskId);
-    if (!definition) throw new BadRequestException('任务不存在');
-    return await this.dataSource.transaction(async (manager) => {
-      const repository = manager.getRepository(PlayerTaskProgress);
-      await this.ensureRows(repository, userId, cycle);
-      const rows = await this.findRows(repository, userId, cycle, true);
-      await this.syncWeeklyBonus(repository, rows);
-      const row = this.findRow(rows, definition, cycle);
-      if (!row.completed_at) throw new BadRequestException('任务尚未完成');
-      if (row.claimed_at) throw new ConflictException('任务奖励已领取');
-      const walletResult = await this.walletService.earnInTransaction(
-        manager,
-        userId,
-        definition.reward,
-        'task_reward',
-        `${getTaskCycleKey(definition, cycle)}:${definition.id}`,
-        `任务奖励：${definition.title}`,
-      );
-      row.claimed_at = new Date();
-      await repository.save(row);
-      return {
-        board: buildTaskBoard(rows, cycle),
-        wallet: {
-          user_id: userId.toString(),
-          balance: walletResult.wallet.balance,
-          currency: 'whale_coin',
-        },
-      };
-    });
-  }
-
-  private async ensureRows(repository: Repository<PlayerTaskProgress>, userId: bigint, cycle: WeeklyCycle): Promise<void> {
-    const values = getTaskDefinitions().map((definition) => ({
-      user_id: userId,
-      task_id: definition.id,
-      cycle_key: getTaskCycleKey(definition, cycle),
-      progress: 0,
-      activity_state: {},
-      completed_at: null,
-      claimed_at: null,
-    }));
-    await repository.createQueryBuilder().insert().values(values).orIgnore().execute();
-  }
-
-  private async findRows(repository: Repository<PlayerTaskProgress>, userId: bigint, cycle: WeeklyCycle, lock = false): Promise<PlayerTaskProgress[]> {
-    return await repository.find({
-      where: { user_id: userId, cycle_key: In([cycle.key, NEWBIE_CYCLE_KEY]) },
-      ...(lock ? { lock: { mode: 'pessimistic_write' as const } } : {}),
-    });
-  }
-
-  private findRow(rows: PlayerTaskProgress[], definition: TaskDefinition, cycle: WeeklyCycle): PlayerTaskProgress {
-    const cycleKey = getTaskCycleKey(definition, cycle);
-    const row = rows.find((item) => item.task_id === definition.id && item.cycle_key === cycleKey);
-    if (!row) throw new Error(`任务进度缺失: ${definition.id}`);
-    return row;
-  }
-
-  private applyActivity(definition: TaskDefinition, row: PlayerTaskProgress, targetId?: string): void {
-    if (row.completed_at) return;
-    if (definition.allowed_targets && (!targetId || !definition.allowed_targets.includes(targetId))) return;
-    if (definition.progress_mode === 'unique_target') {
-      if (!targetId) return;
-      const state = row.activity_state as TaskProgressState;
-      const targets = Array.isArray(state.targets) ? state.targets.filter((item): item is string => typeof item === 'string') : [];
-      if (targets.includes(targetId)) return;
-      targets.push(targetId);
-      row.activity_state = { ...state, targets };
-      row.progress = Math.min(definition.target, targets.length);
-    } else {
-      row.progress = Math.min(definition.target, row.progress + 1);
-    }
-    if (row.progress >= definition.target) row.completed_at = new Date();
-  }
-
-  private async syncWeeklyBonus(repository: Repository<PlayerTaskProgress>, rows: PlayerTaskProgress[]): Promise<void> {
-    const bonus = rows.find((row) => row.task_id === WEEKLY_COMPLETION_BONUS.id);
-    if (!bonus || bonus.completed_at) return;
-    const complete = WEEKLY_TASKS.every((definition) => rows.some((row) => row.task_id === definition.id && row.completed_at));
-    if (complete) {
-      bonus.progress = 1;
-      bonus.completed_at = new Date();
-      await repository.save(bonus);
-    }
-  }
-}

src/business/tasks/task_progress_memory.service.ts

@@ -1,147 +0,0 @@
-import { BadRequestException, ConflictException, Inject, Injectable } from '@nestjs/common';
-import { PlayerWalletPayload } from '../player/player.types';
-import {
-  getCurrentWeeklyCycle,
-  getTaskCycleKey,
-  getTaskDefinitions,
-  NEWBIE_CYCLE_KEY,
-  TaskActivityType,
-  TaskDefinition,
-  TaskProgressState,
-  WEEKLY_COMPLETION_BONUS,
-  WEEKLY_TASKS,
-} from './task_catalog';
-import { buildTaskBoard, TaskBoardPayload, TaskClaimResult, TaskProgressRow, TaskProgressStore } from './tasks.types';
-
-interface IUserWalletsService {
-  earn(userId: bigint, amount: number, referenceType: string, referenceId: string, note?: string): Promise<{ wallet: { balance: number } }>;
-}
-
-interface MemoryProgressRow extends TaskProgressRow {
-  user_id: bigint;
-  created_at: Date;
-  updated_at: Date;
-}
-
-@Injectable()
-export class TaskProgressMemoryService implements TaskProgressStore {
-  private readonly rows = new Map<string, MemoryProgressRow>();
-
-  constructor(@Inject('IUserWalletsService') private readonly walletService: IUserWalletsService) {}
-
-  async getBoard(userId: bigint): Promise<TaskBoardPayload> {
-    const cycle = getCurrentWeeklyCycle();
-    const rows = this.ensureRows(userId, cycle.key);
-    this.syncWeeklyBonus(rows);
-    return buildTaskBoard(rows, cycle);
-  }
-
-  async recordActivity(userId: bigint, activity: TaskActivityType, targetId?: string): Promise<TaskBoardPayload> {
-    const cycle = getCurrentWeeklyCycle();
-    const rows = this.ensureRows(userId, cycle.key);
-    for (const definition of getTaskDefinitions()) {
-      if (definition.bonus || definition.activity !== activity) continue;
-      const row = this.findRow(rows, definition, cycle.key);
-      this.applyActivity(definition, row, targetId);
-    }
-    this.syncWeeklyBonus(rows);
-    return buildTaskBoard(rows, cycle);
-  }
-
-  async claim(userId: bigint, taskId: string): Promise<TaskClaimResult> {
-    const cycle = getCurrentWeeklyCycle();
-    const rows = this.ensureRows(userId, cycle.key);
-    this.syncWeeklyBonus(rows);
-    const definition = getTaskDefinitions().find((item) => item.id === taskId);
-    if (!definition) {
-      throw new BadRequestException('任务不存在');
-    }
-    const row = this.findRow(rows, definition, cycle.key);
-    if (!row.completed_at) {
-      throw new BadRequestException('任务尚未完成');
-    }
-    if (row.claimed_at) {
-      throw new ConflictException('任务奖励已领取');
-    }
-    const result = await this.walletService.earn(
-      userId,
-      definition.reward,
-      'task_reward',
-      `${getTaskCycleKey(definition, cycle)}:${definition.id}`,
-      `任务奖励：${definition.title}`,
-    );
-    row.claimed_at = new Date();
-    row.updated_at = new Date();
-    const wallet: PlayerWalletPayload = {
-      user_id: userId.toString(),
-      balance: result.wallet.balance,
-      currency: 'whale_coin',
-    };
-    return { board: buildTaskBoard(rows, cycle), wallet };
-  }
-
-  private ensureRows(userId: bigint, weeklyCycleKey: string): MemoryProgressRow[] {
-    for (const definition of getTaskDefinitions()) {
-      const cycleKey = definition.group === 'weekly' ? weeklyCycleKey : NEWBIE_CYCLE_KEY;
-      const key = this.rowKey(userId, definition.id, cycleKey);
-      if (!this.rows.has(key)) {
-        const now = new Date();
-        this.rows.set(key, {
-          user_id: userId,
-          task_id: definition.id,
-          cycle_key: cycleKey,
-          progress: 0,
-          activity_state: {},
-          completed_at: null,
-          claimed_at: null,
-          created_at: now,
-          updated_at: now,
-        });
-      }
-    }
-    return getTaskDefinitions().map((definition) => {
-      const cycleKey = definition.group === 'weekly' ? weeklyCycleKey : NEWBIE_CYCLE_KEY;
-      return this.rows.get(this.rowKey(userId, definition.id, cycleKey)) as MemoryProgressRow;
-    });
-  }
-
-  private findRow(rows: MemoryProgressRow[], definition: TaskDefinition, weeklyCycleKey: string): MemoryProgressRow {
-    const cycleKey = definition.group === 'weekly' ? weeklyCycleKey : NEWBIE_CYCLE_KEY;
-    const row = rows.find((item) => item.task_id === definition.id && item.cycle_key === cycleKey);
-    if (!row) throw new Error(`任务进度缺失: ${definition.id}`);
-    return row;
-  }
-
-  private applyActivity(definition: TaskDefinition, row: MemoryProgressRow, targetId?: string): void {
-    if (row.completed_at) return;
-    if (definition.allowed_targets && (!targetId || !definition.allowed_targets.includes(targetId))) return;
-    if (definition.progress_mode === 'unique_target') {
-      if (!targetId) return;
-      const state = row.activity_state as TaskProgressState;
-      const targets = Array.isArray(state.targets) ? state.targets.filter((item): item is string => typeof item === 'string') : [];
-      if (targets.includes(targetId)) return;
-      targets.push(targetId);
-      row.activity_state = { ...state, targets };
-      row.progress = Math.min(definition.target, targets.length);
-    } else {
-      row.progress = Math.min(definition.target, row.progress + 1);
-    }
-    if (row.progress >= definition.target) row.completed_at = new Date();
-    row.updated_at = new Date();
-  }
-
-  private syncWeeklyBonus(rows: MemoryProgressRow[]): void {
-    const bonus = rows.find((row) => row.task_id === WEEKLY_COMPLETION_BONUS.id);
-    if (!bonus || bonus.completed_at) return;
-    const complete = WEEKLY_TASKS.every((definition) => rows.some((row) => row.task_id === definition.id && row.completed_at));
-    if (complete) {
-      bonus.progress = 1;
-      bonus.completed_at = new Date();
-      bonus.updated_at = new Date();
-    }
-  }
-
-  private rowKey(userId: bigint, taskId: string, cycleKey: string): string {
-    return `${userId.toString()}:${taskId}:${cycleKey}`;
-  }
-}

src/business/tasks/tasks.controller.ts

@@ -1,48 +0,0 @@
-import { Body, Controller, Get, HttpStatus, Param, Post, Res, UseGuards, UsePipes, ValidationPipe } from '@nestjs/common';
-import { ApiBearerAuth, ApiBody, ApiOperation, ApiResponse as SwaggerApiResponse, ApiTags } from '@nestjs/swagger';
-import { Response } from 'express';
-import { CurrentUser } from '../../gateway/auth/current_user.decorator';
-import { JwtAuthGuard } from '../../gateway/auth/jwt_auth.guard';
-import { JwtPayload } from '../../core/login_core/login_core.service';
-import { ReportTaskActivityDto } from './dto/report_task_activity.dto';
-import { TaskService } from './task.service';
-
-@ApiTags('tasks')
-@ApiBearerAuth()
-@Controller('tasks')
-@UseGuards(JwtAuthGuard)
-export class TasksController {
-  constructor(private readonly taskService: TaskService) {}
-
-  @Get('board')
-  @ApiOperation({ summary: '获取玩家任务书' })
-  @SwaggerApiResponse({ status: 200, description: '任务书获取成功' })
-  async getBoard(@CurrentUser() user: JwtPayload, @Res() res: Response): Promise<void> {
-    const data = await this.taskService.getBoard(BigInt(user.sub));
-    res.status(HttpStatus.OK).json({ success: true, data, message: '任务书获取成功' });
-  }
-
-  @Post('activities')
-  @ApiOperation({ summary: '上报客户端白名单任务活动' })
-  @ApiBody({ type: ReportTaskActivityDto })
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  async reportActivity(
-    @CurrentUser() user: JwtPayload,
-    @Body() dto: ReportTaskActivityDto,
-    @Res() res: Response,
-  ): Promise<void> {
-    const data = await this.taskService.recordClientActivity(BigInt(user.sub), dto.activity, dto.target_id);
-    res.status(HttpStatus.OK).json({ success: true, data, message: '任务进度已更新' });
-  }
-
-  @Post(':taskId/claim')
-  @ApiOperation({ summary: '领取任务奖励' })
-  async claim(
-    @CurrentUser() user: JwtPayload,
-    @Param('taskId') taskId: string,
-    @Res() res: Response,
-  ): Promise<void> {
-    const data = await this.taskService.claim(BigInt(user.sub), taskId);
-    res.status(HttpStatus.OK).json({ success: true, data, message: '任务奖励已领取' });
-  }
-}

src/business/tasks/tasks.module.ts

@@ -1,51 +0,0 @@
-import { DynamicModule, Global, Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
-import { LoginCoreModule } from '../../core/login_core/login_core.module';
-import { PlayerTaskProgress } from './player_task_progress.entity';
-import { TaskProgressDatabaseService } from './task_progress_database.service';
-import { TaskProgressMemoryService } from './task_progress_memory.service';
-import { TaskService } from './task.service';
-import { TasksController } from './tasks.controller';
-
-@Global()
-@Module({})
-export class TasksModule {
-  static forDatabase(): DynamicModule {
-    return {
-      module: TasksModule,
-      global: true,
-      imports: [LoginCoreModule, TypeOrmModule.forFeature([PlayerTaskProgress])],
-      controllers: [TasksController],
-      providers: [
-        TaskProgressDatabaseService,
-        { provide: 'ITaskProgressStore', useExisting: TaskProgressDatabaseService },
-        TaskService,
-      ],
-      exports: [TaskService, 'ITaskProgressStore'],
-    };
-  }
-
-  static forMemory(): DynamicModule {
-    return {
-      module: TasksModule,
-      global: true,
-      imports: [LoginCoreModule],
-      controllers: [TasksController],
-      providers: [
-        TaskProgressMemoryService,
-        { provide: 'ITaskProgressStore', useExisting: TaskProgressMemoryService },
-        TaskService,
-      ],
-      exports: [TaskService, 'ITaskProgressStore'],
-    };
-  }
-
-  static forRoot(useMemory?: boolean): DynamicModule {
-    const shouldUseMemory = useMemory ?? (
-      process.env.NODE_ENV === 'test' ||
-      process.env.USE_MEMORY_STORAGE === 'true' ||
-      !process.env.DB_HOST
-    );
-    return shouldUseMemory ? this.forMemory() : this.forDatabase();
-  }
-}

src/business/tasks/tasks.types.ts

@@ -1,78 +0,0 @@
-import { PlayerWalletPayload } from '../player/player.types';
-import { getTaskCycleKey, NEWBIE_TASKS, TaskActivityType, TaskDefinition, WEEKLY_COMPLETION_BONUS, WEEKLY_TASKS, WeeklyCycle } from './task_catalog';
-
-export interface TaskProgressRow {
-  task_id: string;
-  cycle_key: string;
-  progress: number;
-  activity_state: Record<string, unknown>;
-  completed_at: Date | null;
-  claimed_at: Date | null;
-}
-
-export interface TaskPayload {
-  id: string;
-  title: string;
-  description: string;
-  reward: number;
-  target: number;
-  progress: number;
-  optional: boolean;
-  bonus: boolean;
-  completed: boolean;
-  claimed: boolean;
-  claimable: boolean;
-}
-
-export interface TaskBoardPayload {
-  weekly_cycle: WeeklyCycle;
-  newbie_tasks: TaskPayload[];
-  weekly_tasks: TaskPayload[];
-  weekly_bonus: TaskPayload;
-}
-
-export interface TaskClaimResult {
-  board: TaskBoardPayload;
-  wallet: PlayerWalletPayload;
-}
-
-export interface TaskProgressStore {
-  getBoard(userId: bigint): Promise<TaskBoardPayload>;
-  recordActivity(userId: bigint, activity: TaskActivityType, targetId?: string): Promise<TaskBoardPayload>;
-  claim(userId: bigint, taskId: string): Promise<TaskClaimResult>;
-}
-
-export function toTaskPayload(definition: TaskDefinition, row: TaskProgressRow): TaskPayload {
-  const completed = row.completed_at != null;
-  const claimed = row.claimed_at != null;
-  return {
-    id: definition.id,
-    title: definition.title,
-    description: definition.description,
-    reward: definition.reward,
-    target: definition.target,
-    progress: Math.min(definition.target, Math.max(0, row.progress)),
-    optional: Boolean(definition.optional),
-    bonus: Boolean(definition.bonus),
-    completed,
-    claimed,
-    claimable: completed && !claimed,
-  };
-}
-
-export function buildTaskBoard(rows: TaskProgressRow[], cycle: WeeklyCycle): TaskBoardPayload {
-  const rowsByKey = new Map(rows.map((row) => [`${row.task_id}:${row.cycle_key}`, row]));
-  const rowFor = (definition: TaskDefinition): TaskProgressRow => {
-    const row = rowsByKey.get(`${definition.id}:${getTaskCycleKey(definition, cycle)}`);
-    if (!row) {
-      throw new Error(`任务进度缺失: ${definition.id}`);
-    }
-    return row;
-  };
-  return {
-    weekly_cycle: cycle,
-    newbie_tasks: NEWBIE_TASKS.map((definition) => toTaskPayload(definition, rowFor(definition))),
-    weekly_tasks: WEEKLY_TASKS.map((definition) => toTaskPayload(definition, rowFor(definition))),
-    weekly_bonus: toTaskPayload(WEEKLY_COMPLETION_BONUS, rowFor(WEEKLY_COMPLETION_BONUS)),
-  };
-}

src/core/admin_core/admin_core.service.ts

@@ -100,7 +100,6 @@ export class AdminCoreService implements OnModuleInit {
    * ```
    */
   async onModuleInit(): Promise<void> {
-    await this.ensureDevelopmentTestAdmin();
     await this.bootstrapAdminIfEnabled();
   }
 
@@ -318,50 +317,6 @@ export class AdminCoreService implements OnModuleInit {
     this.logger.log(`管理员账号已创建：${username} (role=9)`);
   }
 
-  /**
-   * 开发/测试专用管理员。密码必须由本地或 CI 环境注入，不能作为生产回退值。
-   */
-  private async ensureDevelopmentTestAdmin(): Promise<void> {
-    const environment = this.configService.get<string>('NODE_ENV', 'development');
-    if (environment !== 'development' && environment !== 'test') return;
-    if (this.configService.get<string>('TEST_ADMIN_AUTO_PROVISION', 'true') !== 'true') return;
-
-    const username = this.configService.get<string>('TEST_ADMIN_USERNAME', 'admin')?.trim();
-    const password = this.configService.get<string>('TEST_ADMIN_PASSWORD')
-      || this.configService.get<string>('ADMIN_PASSWORD');
-    const nickname = this.configService.get<string>('TEST_ADMIN_NICKNAME', '测试管理员');
-
-    if (!username || !password) {
-      this.logger.warn('测试管理员未创建：请在开发/测试环境配置 TEST_ADMIN_PASSWORD');
-      return;
-    }
-
-    const existing = await this.usersService.findByUsername(username);
-    if (existing) {
-      if (existing.role !== 9) {
-        this.logger.warn(`测试管理员用户名已被普通账号占用，拒绝提权：${username}`);
-      }
-      return;
-    }
-
-    try {
-      this.validatePasswordStrength(password);
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : '密码不满足强度要求';
-      this.logger.warn(`测试管理员未创建：TEST_ADMIN_PASSWORD 配置无效（${reason}）`);
-      return;
-    }
-    await this.usersService.create({
-      username,
-      password_hash: await this.hashPassword(password),
-      nickname,
-      role: 9,
-      email_verified: true,
-      is_test_account: false,
-    });
-    this.logger.log(`开发/测试管理员账号已创建：${username}`);
-  }
-
   private getAdminTokenSecret(): string {
     const secret = this.configService.get<string>('ADMIN_TOKEN_SECRET');
     if (!secret || secret.length < 16) {

src/core/db/user_profiles/user_profiles.entity.ts

@@ -241,14 +241,14 @@ export class UserProfiles {
    *
    * 数据库设计：
    * - 类型：VARCHAR(50)，支持地图名称
-   * - 约束：非空、默认值'whale_port'
+   * - 约束：非空、默认值'plaza'
    * - 索引：用于地图用户查询
    *
    * 业务规则：
    * - 用户当前所在的游戏地图
    * - 用于位置广播系统的地图过滤
    * - 影响用户可见性和交互范围
-   * - 默认为广场(whale_port)，新用户的起始位置
+   * - 默认为广场(plaza)，新用户的起始位置
    *
    * 位置广播系统：
    * - 核心字段，用于确定用户所在区域
@@ -259,7 +259,7 @@ export class UserProfiles {
     type: 'varchar',
     length: 50,
     nullable: false,
-    default: 'whale_port',
+    default: 'plaza',
     comment: '当前所在地图'
   })
   current_map: string;

src/core/db/user_profiles/user_profiles.service.ts

@@ -128,7 +128,7 @@ export class UserProfilesService extends BaseUserProfilesService {
       userProfile.tags = createUserProfileDto.tags || null;
       userProfile.social_links = createUserProfileDto.social_links || null;
       userProfile.skin_id = createUserProfileDto.skin_id || null;
-      userProfile.current_map = createUserProfileDto.current_map || 'whale_port';
+      userProfile.current_map = createUserProfileDto.current_map || 'plaza';
       userProfile.pos_x = createUserProfileDto.pos_x || 0;
       userProfile.pos_y = createUserProfileDto.pos_y || 0;
       userProfile.status = createUserProfileDto.status || 0;
@@ -618,4 +618,4 @@ export class UserProfilesService extends BaseUserProfilesService {
     });
     return count > 0;
   }
-}
+}

src/core/db/user_profiles/user_profiles_memory.service.ts

@@ -150,7 +150,7 @@ export class UserProfilesMemoryService extends BaseUserProfilesService {
       userProfile.tags = createUserProfileDto.tags || null;
       userProfile.social_links = createUserProfileDto.social_links || null;
       userProfile.skin_id = createUserProfileDto.skin_id || null;
-      userProfile.current_map = createUserProfileDto.current_map || 'whale_port';
+      userProfile.current_map = createUserProfileDto.current_map || 'plaza';
       userProfile.pos_x = createUserProfileDto.pos_x || 0;
       userProfile.pos_y = createUserProfileDto.pos_y || 0;
       userProfile.status = createUserProfileDto.status || 0;
@@ -694,4 +694,4 @@ export class UserProfilesMemoryService extends BaseUserProfilesService {
       currentId: this.CURRENT_ID.toString()
     };
   }
-}
+}

src/core/db/user_wallets/user_wallets.service.ts

@@ -1,6 +1,6 @@
 import { BadRequestException, Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { EntityManager, Repository } from 'typeorm';
+import { Repository } from 'typeorm';
 import { UserWallets } from './user_wallets.entity';
 import { WalletTransactions } from './wallet_transactions.entity';
 
@@ -96,60 +96,6 @@ export class UserWalletsService {
     };
   }
 
-  async earnInTransaction(
-    manager: EntityManager,
-    userId: bigint,
-    amount: number,
-    referenceType: string,
-    referenceId: string,
-    note?: string,
-  ): Promise<EarnWalletResult> {
-    if (!Number.isInteger(amount) || amount < 0) {
-      throw new BadRequestException('鲸币收入数量不正确');
-    }
-
-    const walletRepository = manager.getRepository(UserWallets);
-    const transactionRepository = manager.getRepository(WalletTransactions);
-    let wallet = await walletRepository.findOne({
-      where: { user_id: userId },
-      lock: { mode: 'pessimistic_write' },
-    });
-    if (!wallet) {
-      wallet = walletRepository.create({
-        user_id: userId,
-        balance: DEFAULT_INITIAL_WHALE_COINS,
-        created_at: new Date(),
-        updated_at: new Date(),
-      });
-      wallet = await walletRepository.save(wallet);
-      await transactionRepository.save(transactionRepository.create({
-        user_id: userId,
-        type: 'grant',
-        amount: DEFAULT_INITIAL_WHALE_COINS,
-        balance_after: wallet.balance,
-        reference_type: 'registration',
-        reference_id: 'initial_wallet',
-        note: '新用户初始鲸币',
-        created_at: new Date(),
-      }));
-    }
-
-    wallet.balance += amount;
-    wallet.updated_at = new Date();
-    const savedWallet = await walletRepository.save(wallet);
-    const transaction = await transactionRepository.save(transactionRepository.create({
-      user_id: userId,
-      type: 'earn',
-      amount,
-      balance_after: savedWallet.balance,
-      reference_type: referenceType,
-      reference_id: referenceId,
-      note: note || null,
-      created_at: new Date(),
-    }));
-    return { wallet: savedWallet, transaction };
-  }
-
   private async createTransaction(
     userId: bigint,
     type: string,

src/core/db/users/migrations/add-is-test-account.sql

@@ -1,18 +0,0 @@
-ALTER TABLE `users`
-  ADD COLUMN IF NOT EXISTS `is_test_account` TINYINT(1) NOT NULL DEFAULT 0 COMMENT '是否为开发测试实验室账号' AFTER `role`;
-
-SET @test_account_index_exists := (
-  SELECT COUNT(*)
-  FROM information_schema.statistics
-  WHERE table_schema = DATABASE()
-    AND table_name = 'users'
-    AND index_name = 'idx_users_is_test_account'
-);
-SET @test_account_index_sql := IF(
-  @test_account_index_exists = 0,
-  'CREATE INDEX `idx_users_is_test_account` ON `users` (`is_test_account`)',
-  'SELECT 1'
-);
-PREPARE test_account_index_stmt FROM @test_account_index_sql;
-EXECUTE test_account_index_stmt;
-DEALLOCATE PREPARE test_account_index_stmt;

src/core/db/users/users.dto.ts

@@ -36,8 +36,7 @@ import {
   IsOptional,
   Length,
   IsNotEmpty,
-  IsEnum,
+  IsEnum
-  IsBoolean
 } from 'class-validator';
 import { UserStatus } from './user_status.enum';
 import { USER_ROLES, FIELD_LIMITS } from './users.constants';
@@ -92,10 +91,6 @@ export class CreateUserDto {
   @Length(1, FIELD_LIMITS.USERNAME_MAX_LENGTH, { message: `用户名长度需在1-${FIELD_LIMITS.USERNAME_MAX_LENGTH}字符之间` })
   username: string;
 
-  @IsOptional()
-  @IsBoolean()
-  is_test_account?: boolean;
-
   /**
    * 邮箱地址
    *
@@ -277,4 +272,4 @@ export class CreateUserDto {
   @IsOptional()
   @IsEnum(UserStatus, { message: '用户状态必须是有效的枚举值' })
   status?: UserStatus = UserStatus.ACTIVE;
-}
+}

src/core/db/users/users.entity.ts

@@ -318,13 +318,6 @@ export class Users {
   })
   avatar_url: string;
 
-  @Column({
-    type: 'datetime',
-    nullable: true,
-    comment: '社区昵称最近修改时间'
-  })
-  nickname_updated_at?: Date | null;
-
   /**
    * 用户角色
    *
@@ -358,17 +351,6 @@ export class Users {
   })
   role: number;
 
-  /**
-   * 仅供开发/测试实验室创建的合成玩家使用。生产业务不得据此授予权限。
-   */
-  @Column({
-    type: 'boolean',
-    nullable: false,
-    default: false,
-    comment: '是否为测试实验室账号'
-  })
-  is_test_account: boolean;
-
   /**
    * 用户状态
    *
@@ -512,4 +494,4 @@ export class Users {
    */
   @OneToOne(() => ZulipAccounts, zulipAccount => zulipAccount.gameUser)
   zulipAccount?: ZulipAccounts;
-}
+}

src/core/db/users/users.service.ts

@@ -157,7 +157,6 @@ export class UsersService extends BaseUsersService {
     user.github_id = createUserDto.github_id || null;
     user.avatar_url = createUserDto.avatar_url || null;
     user.role = createUserDto.role || USER_ROLES.NORMAL_USER;
-    user.is_test_account = createUserDto.is_test_account === true;
     user.email_verified = createUserDto.email_verified || false;
     user.status = createUserDto.status || UserStatus.ACTIVE;
 
@@ -712,4 +711,4 @@ export class UsersService extends BaseUsersService {
       });
     }
   }
-}
+}

src/core/db/users/users_memory.service.ts

@@ -257,7 +257,6 @@ export class UsersMemoryService extends BaseUsersService {
     user.github_id = createUserDto.github_id || null;
     user.avatar_url = createUserDto.avatar_url || null;
     user.role = createUserDto.role || USER_ROLES.NORMAL_USER;
-    user.is_test_account = createUserDto.is_test_account === true;
     user.email_verified = createUserDto.email_verified || false;
     user.status = createUserDto.status || UserStatus.ACTIVE;
     user.created_at = new Date();

src/core/zulip_core/services/config_manager.service.ts

@@ -360,7 +360,7 @@ export class ConfigManagerService implements OnModuleDestroy {
         zulipBotEmail: process.env.ZULIP_BOT_EMAIL || 'bot@example.com',
         zulipBotApiKey: process.env.ZULIP_BOT_API_KEY || '',
 
-        websocketPort: parseInt(process.env.WEBSOCKET_PORT || '3000', 10),
+        websocketPort: parseInt(process.env.WEBSOCKET_PORT || '3001', 10),
         websocketNamespace: process.env.WEBSOCKET_NAMESPACE || '/game',
 
         messageRateLimit: parseInt(process.env.MESSAGE_RATE_LIMIT || '10', 10),
@@ -1189,7 +1189,7 @@ export class ConfigManagerService implements OnModuleDestroy {
       zulipServerUrl: 'https://your-zulip-server.com',
       zulipBotEmail: 'bot@example.com',
       zulipBotApiKey: '',
-      websocketPort: 3000,
+      websocketPort: 3001,
       websocketNamespace: '/game',
       messageRateLimit: 10,
       messageMaxLength: 1000,

src/core/zulip_core/zulip.config.ts

@@ -169,7 +169,7 @@ export const DEFAULT_ZULIP_CONFIG: ZulipConfiguration = {
     botApiKey: '',
   },
   websocket: {
-    port: 3000,
+    port: 3001,
     namespace: '/game',
     pingInterval: 25000,
     pingTimeout: 5000,

src/gateway/chat/chat.gateway.ts

@@ -33,14 +33,6 @@
 import { Injectable, Logger, OnModuleInit, OnModuleDestroy } from '@nestjs/common';
 import * as WebSocket from 'ws';
 import { ChatService } from '../../business/chat/chat.service';
-import { SocialService } from '../../business/social/social.service';
-import {
-  getTestLabPresence,
-  getTestLabPresences,
-  removeTestLabPresence,
-  TestLabPresence,
-  upsertTestLabPresence,
-} from '../../business/admin/test_lab_presence.registry';
 
 /** WebSocket 服务器默认端口 */
 const DEFAULT_WEBSOCKET_PORT = 3001;
@@ -110,10 +102,7 @@ export class ChatWebSocketGateway implements OnModuleInit, OnModuleDestroy, ICha
   private mapRooms = new Map<string, Set<string>>();
   private lastWelcomeAtByUserId = new Map<string, number>();
 
-  constructor(
+  constructor(private readonly chatService: ChatService) {}
-    private readonly chatService: ChatService,
-    private readonly socialService: SocialService,
-  ) {}
 
   async onModuleInit() {
     const port = process.env.WEBSOCKET_PORT ? parseInt(process.env.WEBSOCKET_PORT) : DEFAULT_WEBSOCKET_PORT;
@@ -151,7 +140,6 @@ export class ChatWebSocketGateway implements OnModuleInit, OnModuleDestroy, ICha
 
     // 设置网关引用到业务层
     this.chatService.setWebSocketGateway(this);
-    this.socialService.setRealtimeGateway(this);
     this.logger.log(`WebSocket服务器启动成功，端口: ${port}，路径: /game`);
   }
 
@@ -198,12 +186,6 @@ export class ChatWebSocketGateway implements OnModuleInit, OnModuleDestroy, ICha
       case 'chat':
         await this.handleChat(ws, message);
         break;
-      case 'dm_send':
-        await this.handleDirectMessage(ws, message);
-        break;
-      case 'dm_read':
-        await this.handleDirectMessageRead(ws, message);
-        break;
       case 'position':
         await this.handlePosition(ws, message);
         break;
@@ -278,7 +260,6 @@ export class ChatWebSocketGateway implements OnModuleInit, OnModuleDestroy, ICha
         });
 
         this.logger.log(`用户登录成功: ${result.username} (${ws.id})`);
-        await this.socialService.notifyPresenceChanged(String(result.userId), true);
       } else {
         this.sendMessage(ws, {
           t: 'login_error',
@@ -335,12 +316,6 @@ export class ChatWebSocketGateway implements OnModuleInit, OnModuleDestroy, ICha
       return;
     }
 
-    const scope = String(message.scope || 'local').trim().toLowerCase();
-    if (scope === 'private' || scope === 'whisper' || scope === 'dm') {
-      await this.handleDirectMessage(ws, message);
-      return;
-    }
-
     try {
       const result = await this.chatService.sendChatMessage({
         socketId: ws.id,
@@ -372,43 +347,6 @@ export class ChatWebSocketGateway implements OnModuleInit, OnModuleDestroy, ICha
     }
   }
 
-  private async handleDirectMessage(ws: ExtendedWebSocket, message: any) {
-    if (!ws.authenticated || !ws.userId) {
-      this.sendError(ws, '请先登录');
-      return;
-    }
-    const targetUserId = String(message.targetUserId || message.target_user_id || message.userId || message.user_id || '').trim();
-    const content = String(message.content || message.txt || '').trim();
-    if (!/^\d+$/.test(targetUserId) || !content) {
-      this.sendMessage(ws, { t: 'chat_error', code: 'CHAT_ERROR', message: '私聊目标或内容无效' });
-      return;
-    }
-    try {
-      const result = await this.socialService.sendDirectMessage(BigInt(ws.userId), BigInt(targetUserId), content);
-      this.sendMessage(ws, { t: 'chat_sent', messageId: result.id, message: '消息发送成功' });
-    } catch (error) {
-      this.sendMessage(ws, { t: 'chat_error', code: this.toClientErrorCode((error as Error).message), message: (error as Error).message || '私聊发送失败' });
-    }
-  }
-
-  private async handleDirectMessageRead(ws: ExtendedWebSocket, message: any) {
-    if (!ws.authenticated || !ws.userId) {
-      this.sendError(ws, '请先登录');
-      return;
-    }
-    const targetUserId = String(message.userId || message.user_id || message.targetUserId || '').trim();
-    if (!/^\d+$/.test(targetUserId)) {
-      this.sendError(ws, '私聊对象无效');
-      return;
-    }
-    try {
-      const result = await this.socialService.markConversationRead(BigInt(ws.userId), BigInt(targetUserId));
-      this.sendMessage(ws, { t: 'dm_read_success', ...result, userId: targetUserId });
-    } catch (error) {
-      this.sendError(ws, (error as Error).message || '标记私聊已读失败');
-    }
-  }
-
   private async handleFriendAdd(ws: ExtendedWebSocket, message: any) {
     if (!ws.authenticated) {
       this.sendError(ws, '请先登录');
@@ -421,12 +359,26 @@ export class ChatWebSocketGateway implements OnModuleInit, OnModuleDestroy, ICha
       return;
     }
 
-    try {
+    const result = await this.chatService.addFriend({
-      const request = await this.socialService.createFriendRequest(BigInt(String(ws.userId)), BigInt(String(friendUserId)));
+      socketId: ws.id,
-      this.sendMessage(ws, { t: 'friend_request_sent', request });
+      friendUserId,
-    } catch (error) {
+      friendUsername: message.friendUsername || message.friend_username || message.username,
-      this.sendMessage(ws, { t: 'friend_error', code: 'CHAT_ERROR', message: (error as Error).message || '好友请求发送失败' });
+    });
+
+    if (result.success) {
+      this.sendMessage(ws, {
+        t: 'friend_added',
+        friend: result.friend,
+      });
+      await this.sendFriendList(ws);
+      return;
     }
+
+    this.sendMessage(ws, {
+      t: 'friend_error',
+      code: this.toClientErrorCode(result.error),
+      message: result.error || '添加好友失败',
+    });
   }
 
   private async handleFriendRequest(ws: ExtendedWebSocket, message: any) {
@@ -441,12 +393,25 @@ export class ChatWebSocketGateway implements OnModuleInit, OnModuleDestroy, ICha
       return;
     }
 
-    try {
+    const result = await this.chatService.requestFriend({
-      const request = await this.socialService.createFriendRequest(BigInt(String(ws.userId)), BigInt(String(friendUserId)));
+      socketId: ws.id,
-      this.sendMessage(ws, { t: 'friend_request_sent', request });
+      friendUserId,
-    } catch (error) {
+      friendUsername: message.friendUsername || message.friend_username || message.username,
-      this.sendMessage(ws, { t: 'friend_error', code: 'CHAT_ERROR', message: (error as Error).message || '好友请求发送失败' });
+    });
+
+    if (result.success) {
+      this.sendMessage(ws, {
+        t: 'friend_request_sent',
+        request: result.friendRequest,
+      });
+      return;
     }
+
+    this.sendMessage(ws, {
+      t: 'friend_error',
+      code: this.toClientErrorCode(result.error),
+      message: result.error || '好友请求发送失败',
+    });
   }
 
   private async handleFriendAccept(ws: ExtendedWebSocket, message: any) {
@@ -461,16 +426,26 @@ export class ChatWebSocketGateway implements OnModuleInit, OnModuleDestroy, ICha
       return;
     }
 
-    try {
+    const result = await this.chatService.acceptFriendRequest({
-      const requests = await this.socialService.getFriendRequests(BigInt(String(ws.userId)));
+      socketId: ws.id,
-      const request = requests.find((item) => item.requester.id === String(friendUserId));
+      friendUserId,
-      if (!request) throw new Error('好友请求不存在或已过期');
+      friendUsername: message.friendUsername || message.friend_username || message.username,
-      const result = await this.socialService.acceptFriendRequest(BigInt(String(ws.userId)), BigInt(request.id));
+    });
-      this.sendMessage(ws, { t: 'friend_added', friend: this.legacyFriend(result.friend) });
+
+    if (result.success) {
+      this.sendMessage(ws, {
+        t: 'friend_added',
+        friend: result.friend,
+      });
       await this.sendFriendList(ws);
-    } catch (error) {
+      return;
-      this.sendMessage(ws, { t: 'friend_error', code: 'CHAT_ERROR', message: (error as Error).message || '接受好友请求失败' });
     }
+
+    this.sendMessage(ws, {
+      t: 'friend_error',
+      code: this.toClientErrorCode(result.error),
+      message: result.error || '接受好友请求失败',
+    });
   }
 
   private async handleFriendReject(ws: ExtendedWebSocket, message: any) {
@@ -485,16 +460,26 @@ export class ChatWebSocketGateway implements OnModuleInit, OnModuleDestroy, ICha
       return;
     }
 
-    try {
+    const result = await this.chatService.rejectFriendRequest({
-      const requests = await this.socialService.getFriendRequests(BigInt(String(ws.userId)));
+      socketId: ws.id,
-      const request = requests.find((item) => item.requester.id === String(friendUserId));
+      friendUserId,
-      if (!request) throw new Error('好友请求不存在或已过期');
+      friendUsername: message.friendUsername || message.friend_username || message.username,
-      await this.socialService.rejectFriendRequest(BigInt(String(ws.userId)), BigInt(request.id));
+    });
-      this.sendMessage(ws, { t: 'friend_request_rejected', userId: String(friendUserId) });
+
+    if (result.success) {
+      this.sendMessage(ws, {
+        t: 'friend_request_rejected',
+        userId: friendUserId,
+      });
       await this.sendFriendList(ws);
-    } catch (error) {
+      return;
-      this.sendMessage(ws, { t: 'friend_error', code: 'CHAT_ERROR', message: (error as Error).message || '拒绝好友请求失败' });
     }
+
+    this.sendMessage(ws, {
+      t: 'friend_error',
+      code: this.toClientErrorCode(result.error),
+      message: result.error || '拒绝好友请求失败',
+    });
   }
 
   private async handleFriendRemove(ws: ExtendedWebSocket, message: any) {
@@ -509,13 +494,25 @@ export class ChatWebSocketGateway implements OnModuleInit, OnModuleDestroy, ICha
       return;
     }
 
-    try {
+    const result = await this.chatService.removeFriend({
-      await this.socialService.removeFriend(BigInt(String(ws.userId)), BigInt(String(friendUserId)));
+      socketId: ws.id,
-      this.sendMessage(ws, { t: 'friend_removed', friendUserId: String(friendUserId) });
+      friendUserId,
+    });
+
+    if (result.success) {
+      this.sendMessage(ws, {
+        t: 'friend_removed',
+        friendUserId,
+      });
       await this.sendFriendList(ws);
-    } catch (error) {
+      return;
-      this.sendMessage(ws, { t: 'friend_error', code: 'CHAT_ERROR', message: (error as Error).message || '移除好友失败' });
     }
+
+    this.sendMessage(ws, {
+      t: 'friend_error',
+      code: this.toClientErrorCode(result.error),
+      message: result.error || '移除好友失败',
+    });
   }
 
   private async handleFriendList(ws: ExtendedWebSocket) {
@@ -528,13 +525,21 @@ export class ChatWebSocketGateway implements OnModuleInit, OnModuleDestroy, ICha
   }
 
   private async sendFriendList(ws: ExtendedWebSocket) {
-    try {
+    const result = await this.chatService.getFriends(ws.id);
-      const userId = BigInt(String(ws.userId));
+    if (result.success) {
-      const [friends, requests] = await Promise.all([this.socialService.getFriends(userId), this.socialService.getFriendRequests(userId)]);
+      this.sendMessage(ws, {
-      this.sendMessage(ws, { t: 'friend_list', friends: friends.map((friend) => this.legacyFriend(friend)), requests: requests.map((request) => ({ userId: request.requester.id, username: request.requester.nickname, createdAt: request.createdAt, requestId: request.id })) });
+        t: 'friend_list',
-    } catch (error) {
+        friends: result.friends || [],
-      this.sendMessage(ws, { t: 'friend_error', code: 'CHAT_ERROR', message: (error as Error).message || '获取好友列表失败' });
+        requests: result.requests || [],
+      });
+      return;
     }
+
+    this.sendMessage(ws, {
+      t: 'friend_error',
+      code: this.toClientErrorCode(result.error),
+      message: result.error || '获取好友列表失败',
+    });
   }
 
   /**
@@ -863,29 +868,27 @@ export class ChatWebSocketGateway implements OnModuleInit, OnModuleDestroy, ICha
     }
   }
 
-  public async broadcastToMap(mapId: string, data: any, excludeId?: string): Promise<void> {
+  public broadcastToMap(mapId: string, data: any, excludeId?: string): void {
     const room = this.mapRooms.get(mapId);
     if (!room) return;
 
-    for (const clientId of room) {
+    room.forEach(clientId => {
       if (clientId !== excludeId) {
         const client = this.clients.get(clientId);
         if (client && client.authenticated && client.readyState === WebSocket.OPEN) {
-          if (data?.t === 'chat_render' && data?.fromUserId && client.userId && !(await this.socialService.canSeeChat(String(data.fromUserId), String(client.userId)))) continue;
           this.sendMessage(client, data);
         }
       }
-    }
+    });
   }
 
-  public async broadcastToAll(data: any, excludeId?: string): Promise<void> {
+  public broadcastToAll(data: any, excludeId?: string): void {
-    for (const [clientId, client] of this.clients) {
+    this.clients.forEach((client, clientId) => {
-      if (clientId === excludeId) continue;
+      if (clientId === excludeId) return;
       if (client.authenticated && client.readyState === WebSocket.OPEN) {
-        if (data?.t === 'chat_render' && data?.fromUserId && client.userId && !(await this.socialService.canSeeChat(String(data.fromUserId), String(client.userId)))) continue;
         this.sendMessage(client, data);
       }
-    }
+    });
   }
 
   public getConnectionCount(): number {
@@ -918,58 +921,6 @@ export class ChatWebSocketGateway implements OnModuleInit, OnModuleDestroy, ICha
     return players;
   }
 
-  /** 管理端测试实验室使用：返回真实在线玩家，绝不包含合成假人。 */
-  public getOnlineWorldPlayers(): Array<{ userId: string; username: string; mapId: string }> {
-    return [...this.clients.values()]
-      .filter((client) => client.authenticated && client.worldReady && client.userId && client.currentMap)
-      .map((client) => ({ userId: String(client.userId), username: String(client.username || ''), mapId: String(client.currentMap) }));
-  }
-
-  public setTestLabPresence(presence: TestLabPresence): void {
-    const previous = getTestLabPresence(presence.userId);
-    const current = upsertTestLabPresence(presence);
-    if (previous?.online && (!current.online || previous.mapId !== current.mapId)) {
-      this.broadcastToMap(previous.mapId, { t: 'player_left', userId: previous.userId, username: previous.nickname, mapId: previous.mapId });
-    }
-    if (!current.online) return;
-    const payload = {
-      t: previous?.online && previous.mapId === current.mapId ? 'position_update' : 'player_joined',
-      userId: current.userId,
-      username: current.nickname,
-      mapId: current.mapId,
-      x: current.x,
-      y: current.y,
-      skinId: current.skinId,
-      avatarId: current.avatarId,
-      appearance: { skinId: current.skinId, avatarId: current.avatarId },
-    };
-    this.broadcastToMap(current.mapId, payload);
-  }
-
-  public removeTestLabActor(userId: string): void {
-    const previous = removeTestLabPresence(userId);
-    if (previous?.online) {
-      this.broadcastToMap(previous.mapId, { t: 'player_left', userId: previous.userId, username: previous.nickname, mapId: previous.mapId });
-    }
-  }
-
-  public broadcastTestLabChat(actor: TestLabPresence, content: string, scope: 'local' | 'global' = 'local'): void {
-    const payload = {
-      t: 'chat_render',
-      from: actor.nickname,
-      fromUserId: actor.userId,
-      txt: content,
-      bubble: true,
-      timestamp: new Date().toISOString(),
-      messageId: `test_${Date.now()}_${actor.userId}`,
-      mapId: actor.mapId,
-      scope,
-      testLab: true,
-    };
-    if (scope === 'global') this.broadcastToAll(payload);
-    else this.broadcastToMap(actor.mapId, payload);
-  }
-
   // ========== 私有辅助方法 ==========
 
   private sendMessage(ws: ExtendedWebSocket, data: any) {
@@ -1035,22 +986,10 @@ export class ChatWebSocketGateway implements OnModuleInit, OnModuleDestroy, ICha
     });
     const players = (await this.chatService.getMapPlayerSnapshot(normalizedMapId, ws.id))
       .filter((player) => activeUserIds.has(String(player.userId)));
-    const testPlayers = getTestLabPresences(normalizedMapId).map((player) => ({
-      userId: player.userId,
-      username: player.nickname,
-      mapId: player.mapId,
-      x: player.x,
-      y: player.y,
-      skinId: player.skinId,
-      avatarId: player.avatarId,
-      appearance: { skinId: player.skinId, avatarId: player.avatarId },
-      cafeCompanion: null,
-      movementLocked: false,
-    }));
     this.sendMessage(ws, {
       t: 'map_players_snapshot',
       mapId: normalizedMapId,
-      players: [...players, ...testPlayers].filter((player) => String(player.userId) !== String(ws.userId)),
+      players,
     });
   }
 
@@ -1066,7 +1005,6 @@ export class ChatWebSocketGateway implements OnModuleInit, OnModuleDestroy, ICha
       }
       if (ws.authenticated && ws.id) {
         await this.chatService.handlePlayerLogout(ws.id, reason);
-        if (ws.userId) await this.socialService.notifyPresenceChanged(String(ws.userId), false);
       }
       if (ws.currentMap) {
         this.leaveMapRoom(ws.id, ws.currentMap);
@@ -1106,8 +1044,4 @@ export class ChatWebSocketGateway implements OnModuleInit, OnModuleDestroy, ICha
   private generateClientId(): string {
     return `ws_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
   }
-
-  private legacyFriend(profile: any) {
-    return { userId: String(profile.id), username: String(profile.nickname || profile.username || '玩家'), online: Boolean(profile.online) };
-  }
 }