格式化

apps/server/src/app.module.ts

@@ -23,12 +23,12 @@ import { UploadModule } from './upload/upload.module';
   imports: [
     ConfigModule.forRoot({
       isGlobal: true, // 全局可用
-      envFilePath: '.env'
+      envFilePath: '.env',
     }),
     ScheduleModule.forRoot(),
     JwtModule.register({
       global: true,
-      secret: env.JWT_SECRET
+      secret: env.JWT_SECRET,
     }),
     WebSocketModule,
     TrpcModule,
@@ -42,11 +42,13 @@ import { UploadModule } from './upload/upload.module';
     MinioModule,
     CollaborationModule,
     RealTimeModule,
-    UploadModule
+    UploadModule,
+  ],
+  providers: [
+    {
+      provide: APP_FILTER,
+      useClass: ExceptionsFilter,
+    },
   ],
-  providers: [{
-    provide: APP_FILTER,
-    useClass: ExceptionsFilter,
-  }],
 })
-export class AppModule { }
+export class AppModule {}

apps/server/src/auth/auth.controller.ts

@@ -43,8 +43,9 @@ export class AuthController {
         authorization,
       };
 
-      const authResult =
+      const authResult = await this.authService.validateFileRequest(
-        await this.authService.validateFileRequest(fileRequest);
+        fileRequest,
+      );
       if (!authResult.isValid) {
         // 使用枚举类型进行错误处理
         switch (authResult.error) {

apps/server/src/auth/auth.guard.ts

@@ -1,8 +1,8 @@
 import {
-    CanActivate,
+  CanActivate,
-    ExecutionContext,
+  ExecutionContext,
-    Injectable,
+  Injectable,
-    UnauthorizedException,
+  UnauthorizedException,
 } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
 import { env } from '@server/env';
@@ -12,26 +12,21 @@ import { extractTokenFromHeader } from './utils';
 
 @Injectable()
 export class AuthGuard implements CanActivate {
-    constructor(private jwtService: JwtService) { }
+  constructor(private jwtService: JwtService) {}
-    async canActivate(context: ExecutionContext): Promise<boolean> {
+  async canActivate(context: ExecutionContext): Promise<boolean> {
-        const request = context.switchToHttp().getRequest();
+    const request = context.switchToHttp().getRequest();
-        const token = extractTokenFromHeader(request);
+    const token = extractTokenFromHeader(request);
-        if (!token) {
+    if (!token) {
-            throw new UnauthorizedException();
+      throw new UnauthorizedException();
-        }
-        try {
-            const payload: JwtPayload = await this.jwtService.verifyAsync(
-                token,
-                {
-                    secret: env.JWT_SECRET
-                }
-            );
-            request['user'] = payload;
-        } catch {
-            throw new UnauthorizedException();
-        }
-        return true;
     }
-
+    try {
-
+      const payload: JwtPayload = await this.jwtService.verifyAsync(token, {
+        secret: env.JWT_SECRET,
+      });
+      request['user'] = payload;
+    } catch {
+      throw new UnauthorizedException();
+    }
+    return true;
+  }
 }

apps/server/src/auth/auth.module.ts

@@ -8,12 +8,8 @@ import { SessionService } from './session.service';
 import { RoleMapModule } from '@server/models/rbac/rbac.module';
 @Module({
   imports: [StaffModule, RoleMapModule],
-  providers: [
+  providers: [AuthService, TrpcService, DepartmentService, SessionService],
-    AuthService,
-    TrpcService,
-    DepartmentService,
-    SessionService],
   exports: [AuthService],
   controllers: [AuthController],
 })
-export class AuthModule { }
+export class AuthModule {}

apps/server/src/auth/config.ts

@@ -1,9 +1,9 @@
 export const tokenConfig = {
-    accessToken: {
+  accessToken: {
-        expirationMs: 7 * 24 * 3600000, // 7 days
+    expirationMs: 7 * 24 * 3600000, // 7 days
-        expirationTTL: 7 * 24 * 60 * 60, // 7 days in seconds
+    expirationTTL: 7 * 24 * 60 * 60, // 7 days in seconds
-    },
+  },
-    refreshToken: {
+  refreshToken: {
-        expirationMs: 30 * 24 * 3600000, // 30 days
+    expirationMs: 30 * 24 * 3600000, // 30 days
-    },
+  },
 };

apps/server/src/auth/session.service.ts

@@ -4,58 +4,63 @@ import { redis } from '@server/utils/redis/redis.service';
 import { v4 as uuidv4 } from 'uuid';
 
 export interface SessionInfo {
-    session_id: string;
+  session_id: string;
-    access_token: string;
+  access_token: string;
-    access_token_expires_at: number;
+  access_token_expires_at: number;
-    refresh_token: string;
+  refresh_token: string;
-    refresh_token_expires_at: number;
+  refresh_token_expires_at: number;
 }
 
 @Injectable()
 export class SessionService {
-    private getSessionKey(userId: string, sessionId: string): string {
+  private getSessionKey(userId: string, sessionId: string): string {
-        return `session-${userId}-${sessionId}`;
+    return `session-${userId}-${sessionId}`;
-    }
+  }
-    async createSession(
+  async createSession(
-        userId: string,
+    userId: string,
-        accessToken: string,
+    accessToken: string,
-        refreshToken: string,
+    refreshToken: string,
-        expirationConfig: {
+    expirationConfig: {
-            accessTokenExpirationMs: number;
+      accessTokenExpirationMs: number;
-            refreshTokenExpirationMs: number;
+      refreshTokenExpirationMs: number;
-            sessionTTL: number;
+      sessionTTL: number;
-        },
+    },
-    ): Promise<SessionInfo> {
+  ): Promise<SessionInfo> {
-        const sessionInfo: SessionInfo = {
+    const sessionInfo: SessionInfo = {
-            session_id: uuidv4(),
+      session_id: uuidv4(),
-            access_token: accessToken,
+      access_token: accessToken,
-            access_token_expires_at: Date.now() + expirationConfig.accessTokenExpirationMs,
+      access_token_expires_at:
-            refresh_token: refreshToken,
+        Date.now() + expirationConfig.accessTokenExpirationMs,
-            refresh_token_expires_at: Date.now() + expirationConfig.refreshTokenExpirationMs,
+      refresh_token: refreshToken,
-        };
+      refresh_token_expires_at:
+        Date.now() + expirationConfig.refreshTokenExpirationMs,
+    };
 
-        await this.saveSession(userId, sessionInfo, expirationConfig.sessionTTL);
+    await this.saveSession(userId, sessionInfo, expirationConfig.sessionTTL);
-        return sessionInfo;
+    return sessionInfo;
-    }
+  }
 
-    async getSession(userId: string, sessionId: string): Promise<SessionInfo | null> {
+  async getSession(
-        const sessionData = await redis.get(this.getSessionKey(userId, sessionId));
+    userId: string,
-        return sessionData ? JSON.parse(sessionData) : null;
+    sessionId: string,
-    }
+  ): Promise<SessionInfo | null> {
+    const sessionData = await redis.get(this.getSessionKey(userId, sessionId));
+    return sessionData ? JSON.parse(sessionData) : null;
+  }
 
-    async saveSession(
+  async saveSession(
-        userId: string,
+    userId: string,
-        sessionInfo: SessionInfo,
+    sessionInfo: SessionInfo,
-        ttl: number,
+    ttl: number,
-    ): Promise<void> {
+  ): Promise<void> {
-        await redis.setex(
+    await redis.setex(
-            this.getSessionKey(userId, sessionInfo.session_id),
+      this.getSessionKey(userId, sessionInfo.session_id),
-            ttl,
+      ttl,
-            JSON.stringify(sessionInfo),
+      JSON.stringify(sessionInfo),
-        );
+    );
-    }
+  }
 
-    async deleteSession(userId: string, sessionId: string): Promise<void> {
+  async deleteSession(userId: string, sessionId: string): Promise<void> {
-        await redis.del(this.getSessionKey(userId, sessionId));
+    await redis.del(this.getSessionKey(userId, sessionId));
-    }
+  }
 }

apps/server/src/auth/types.ts

@@ -1,31 +1,31 @@
 export interface TokenConfig {
-    accessToken: {
+  accessToken: {
-        expirationMs: number;
+    expirationMs: number;
-        expirationTTL: number;
+    expirationTTL: number;
-    };
+  };
-    refreshToken: {
+  refreshToken: {
-        expirationMs: number;
+    expirationMs: number;
-    };
+  };
 }
 
 export interface FileAuthResult {
-    isValid: boolean
+  isValid: boolean;
-    userId?: string
+  userId?: string;
-    resourceType?: string
+  resourceType?: string;
-    error?: string
+  error?: string;
 }
 export interface FileRequest {
-    originalUri: string;
+  originalUri: string;
-    realIp: string;
+  realIp: string;
-    method: string;
+  method: string;
-    queryParams: string;
+  queryParams: string;
-    host: string;
+  host: string;
-    authorization: string
+  authorization: string;
 }
 export enum FileValidationErrorType {
-    INVALID_URI = 'INVALID_URI',
+  INVALID_URI = 'INVALID_URI',
-    RESOURCE_NOT_FOUND = 'RESOURCE_NOT_FOUND',
+  RESOURCE_NOT_FOUND = 'RESOURCE_NOT_FOUND',
-    AUTHORIZATION_REQUIRED = 'AUTHORIZATION_REQUIRED',
+  AUTHORIZATION_REQUIRED = 'AUTHORIZATION_REQUIRED',
-    INVALID_TOKEN = 'INVALID_TOKEN',
+  INVALID_TOKEN = 'INVALID_TOKEN',
-    UNKNOWN_ERROR = 'UNKNOWN_ERROR'
+  UNKNOWN_ERROR = 'UNKNOWN_ERROR',
 }

apps/server/src/auth/utils.ts

@@ -11,7 +11,7 @@ import { env } from '@server/env';
 import { redis } from '@server/utils/redis/redis.service';
 import EventBus from '@server/utils/event-bus';
 import { RoleMapService } from '@server/models/rbac/rolemap.service';
-import { Request } from "express"
+import { Request } from 'express';
 interface ProfileResult {
   staff: UserProfile | undefined;
   error?: string;
@@ -22,9 +22,11 @@ interface TokenVerifyResult {
   error?: string;
 }
 export function extractTokenFromHeader(request: Request): string | undefined {
-  return extractTokenFromAuthorization(request.headers.authorization)
+  return extractTokenFromAuthorization(request.headers.authorization);
 }
-export function extractTokenFromAuthorization(authorization: string): string | undefined {
+export function extractTokenFromAuthorization(
+  authorization: string,
+): string | undefined {
   const [type, token] = authorization?.split(' ') ?? [];
   return type === 'Bearer' ? token : undefined;
 }
@@ -40,7 +42,7 @@ export class UserProfileService {
     this.jwtService = new JwtService();
     this.departmentService = new DepartmentService();
     this.roleMapService = new RoleMapService(this.departmentService);
-    EventBus.on("dataChanged", ({ type, data }) => {
+    EventBus.on('dataChanged', ({ type, data }) => {
       if (type === ObjectType.STAFF) {
         // 确保 data 是数组，如果不是则转换为数组
         const dataArray = Array.isArray(data) ? data : [data];
@@ -51,7 +53,6 @@ export class UserProfileService {
         }
       }
     });
-
   }
   public getProfileCacheKey(id: string) {
     return `user-profile-${id}`;
@@ -175,9 +176,7 @@ export class UserProfileService {
       staff.deptId
         ? this.departmentService.getDescendantIdsInDomain(staff.deptId)
         : [],
-      staff.deptId
+      staff.deptId ? this.departmentService.getAncestorIds([staff.deptId]) : [],
-        ? this.departmentService.getAncestorIds([staff.deptId])
-        : [],
       this.roleMapService.getPermsForObject({
         domainId: staff.domainId,
         staffId: staff.id,

apps/server/src/env.ts

@@ -1,3 +1,4 @@
 export const env: { JWT_SECRET: string } = {
-    JWT_SECRET: process.env.JWT_SECRET || '/yT9MnLm/r6NY7ee2Fby6ihCHZl+nFx4OQFKupivrhA='
+  JWT_SECRET:
-}
+    process.env.JWT_SECRET || '/yT9MnLm/r6NY7ee2Fby6ihCHZl+nFx4OQFKupivrhA=',
+};

apps/server/src/models/app-config/app-config.module.ts

@@ -7,6 +7,6 @@ import { RealTimeModule } from '@server/socket/realtime/realtime.module';
 @Module({
   imports: [RealTimeModule],
   providers: [AppConfigService, AppConfigRouter, TrpcService],
-  exports: [AppConfigService, AppConfigRouter]
+  exports: [AppConfigService, AppConfigRouter],
 })
-export class AppConfigModule { }
+export class AppConfigModule {}

apps/server/src/models/base/errorMap.prisma.ts

@@ -1,198 +1,236 @@
 import {
-    BadRequestException,
+  BadRequestException,
-    NotFoundException,
+  NotFoundException,
-    ConflictException,
+  ConflictException,
-    InternalServerErrorException,
+  InternalServerErrorException,
-  } from '@nestjs/common';
+} from '@nestjs/common';
 
-  export const PrismaErrorCode = Object.freeze({
+export const PrismaErrorCode = Object.freeze({
-    P2000: 'P2000',
+  P2000: 'P2000',
-    P2001: 'P2001',
+  P2001: 'P2001',
-    P2002: 'P2002',
+  P2002: 'P2002',
-    P2003: 'P2003',
+  P2003: 'P2003',
-    P2006: 'P2006',
+  P2006: 'P2006',
-    P2007: 'P2007',
+  P2007: 'P2007',
-    P2008: 'P2008',
+  P2008: 'P2008',
-    P2009: 'P2009',
+  P2009: 'P2009',
-    P2010: 'P2010',
+  P2010: 'P2010',
-    P2011: 'P2011',
+  P2011: 'P2011',
-    P2012: 'P2012',
+  P2012: 'P2012',
-    P2014: 'P2014',
+  P2014: 'P2014',
-    P2015: 'P2015',
+  P2015: 'P2015',
-    P2016: 'P2016',
+  P2016: 'P2016',
-    P2017: 'P2017',
+  P2017: 'P2017',
-    P2018: 'P2018',
+  P2018: 'P2018',
-    P2019: 'P2019',
+  P2019: 'P2019',
-    P2021: 'P2021',
+  P2021: 'P2021',
-    P2023: 'P2023',
+  P2023: 'P2023',
-    P2025: 'P2025',
+  P2025: 'P2025',
-    P2031: 'P2031',
+  P2031: 'P2031',
-    P2033: 'P2033',
+  P2033: 'P2033',
-    P2034: 'P2034',
+  P2034: 'P2034',
-    P2037: 'P2037',
+  P2037: 'P2037',
-    P1000: 'P1000',
+  P1000: 'P1000',
-    P1001: 'P1001',
+  P1001: 'P1001',
-    P1002: 'P1002',
+  P1002: 'P1002',
-    P1015: 'P1015',
+  P1015: 'P1015',
-    P1017: 'P1017',
+  P1017: 'P1017',
-  });
+});
 
-  export type PrismaErrorCode = keyof typeof PrismaErrorCode;
+export type PrismaErrorCode = keyof typeof PrismaErrorCode;
 
+interface PrismaErrorMeta {
+  target?: string;
+  model?: string;
+  relationName?: string;
+  details?: string;
+}
 
-  interface PrismaErrorMeta {
+export type operationT = 'create' | 'read' | 'update' | 'delete';
-    target?: string;
-    model?: string;
-    relationName?: string;
-    details?: string;
-  }
 
-  export type operationT = 'create' | 'read' | 'update' | 'delete';
+export type PrismaErrorHandler = (
+  operation: operationT,
+  meta?: PrismaErrorMeta,
+) => Error;
 
-  export type PrismaErrorHandler = (
+export const ERROR_MAP: Record<PrismaErrorCode, PrismaErrorHandler> = {
-    operation: operationT,
+  P2000: (_operation, meta) =>
-    meta?: PrismaErrorMeta,
+    new BadRequestException(
-  ) => Error;
+      `The provided value for ${
+        meta?.target || 'a field'
+      } is too long. Please use a shorter value.`,
+    ),
 
-  export const ERROR_MAP: Record<PrismaErrorCode, PrismaErrorHandler> = {
+  P2001: (operation, meta) =>
-      P2000: (_operation, meta) => new BadRequestException(
+    new NotFoundException(
-          `The provided value for ${meta?.target || 'a field'} is too long. Please use a shorter value.`
+      `The ${
-      ),
+        meta?.model || 'record'
+      } you are trying to ${operation} could not be found.`,
+    ),
 
-      P2001: (operation, meta) => new NotFoundException(
+  P2002: (operation, meta) => {
-          `The ${meta?.model || 'record'} you are trying to ${operation} could not be found.`
+    const field = meta?.target || 'unique field';
-      ),
+    switch (operation) {
+      case 'create':
+        return new ConflictException(
+          `A record with the same ${field} already exists. Please use a different value.`,
+        );
+      case 'update':
+        return new ConflictException(
+          `The new value for ${field} conflicts with an existing record.`,
+        );
+      default:
+        return new ConflictException(
+          `Unique constraint violation on ${field}.`,
+        );
+    }
+  },
 
-      P2002: (operation, meta) => {
+  P2003: (operation) =>
-          const field = meta?.target || 'unique field';
+    new BadRequestException(
-          switch (operation) {
+      `Foreign key constraint failed. Unable to ${operation} the record because related data is invalid or missing.`,
-              case 'create':
+    ),
-                  return new ConflictException(
-                      `A record with the same ${field} already exists. Please use a different value.`
-                  );
-              case 'update':
-                  return new ConflictException(
-                      `The new value for ${field} conflicts with an existing record.`
-                  );
-              default:
-                  return new ConflictException(
-                      `Unique constraint violation on ${field}.`
-                  );
-          }
-      },
 
-      P2003: (operation) => new BadRequestException(
+  P2006: (_operation, meta) =>
-          `Foreign key constraint failed. Unable to ${operation} the record because related data is invalid or missing.`
+    new BadRequestException(
-      ),
+      `The provided value for ${
+        meta?.target || 'a field'
+      } is invalid. Please correct it.`,
+    ),
 
-      P2006: (_operation, meta) => new BadRequestException(
+  P2007: (operation) =>
-          `The provided value for ${meta?.target || 'a field'} is invalid. Please correct it.`
+    new InternalServerErrorException(
-      ),
+      `Data validation error during ${operation}. Please ensure all inputs are valid and try again.`,
+    ),
 
-      P2007: (operation) => new InternalServerErrorException(
+  P2008: (operation) =>
-          `Data validation error during ${operation}. Please ensure all inputs are valid and try again.`
+    new InternalServerErrorException(
-      ),
+      `Failed to query the database during ${operation}. Please try again later.`,
+    ),
 
-      P2008: (operation) => new InternalServerErrorException(
+  P2009: (operation) =>
-          `Failed to query the database during ${operation}. Please try again later.`
+    new InternalServerErrorException(
-      ),
+      `Invalid data fetched during ${operation}. Check query structure.`,
+    ),
 
-      P2009: (operation) => new InternalServerErrorException(
+  P2010: () =>
-          `Invalid data fetched during ${operation}. Check query structure.`
+    new InternalServerErrorException(
-      ),
+      `Invalid raw query. Ensure your query is correct and try again.`,
+    ),
 
-      P2010: () => new InternalServerErrorException(
+  P2011: (_operation, meta) =>
-          `Invalid raw query. Ensure your query is correct and try again.`
+    new BadRequestException(
-      ),
+      `The required field ${
+        meta?.target || 'a field'
+      } is missing. Please provide it to continue.`,
+    ),
 
-      P2011: (_operation, meta) => new BadRequestException(
+  P2012: (operation, meta) =>
-          `The required field ${meta?.target || 'a field'} is missing. Please provide it to continue.`
+    new BadRequestException(
-      ),
+      `Missing required relation ${
+        meta?.relationName || ''
+      }. Ensure all related data exists before ${operation}.`,
+    ),
 
-      P2012: (operation, meta) => new BadRequestException(
+  P2014: (operation) => {
-          `Missing required relation ${meta?.relationName || ''}. Ensure all related data exists before ${operation}.`
+    switch (operation) {
-      ),
+      case 'create':
+        return new BadRequestException(
+          `Cannot create record because the referenced data does not exist. Ensure related data exists.`,
+        );
+      case 'delete':
+        return new BadRequestException(
+          `Unable to delete record because it is linked to other data. Update or delete dependent records first.`,
+        );
+      default:
+        return new BadRequestException(`Foreign key constraint error.`);
+    }
+  },
 
-      P2014: (operation) => {
+  P2015: () =>
-          switch (operation) {
+    new InternalServerErrorException(
-              case 'create':
+      `A record with the required ID was expected but not found. Please retry.`,
-                  return new BadRequestException(
+    ),
-                      `Cannot create record because the referenced data does not exist. Ensure related data exists.`
-                  );
-              case 'delete':
-                  return new BadRequestException(
-                      `Unable to delete record because it is linked to other data. Update or delete dependent records first.`
-                  );
-              default:
-                  return new BadRequestException(`Foreign key constraint error.`);
-          }
-      },
 
-      P2015: () => new InternalServerErrorException(
+  P2016: (operation) =>
-          `A record with the required ID was expected but not found. Please retry.`
+    new InternalServerErrorException(
-      ),
+      `Query ${operation} failed because the record could not be fetched. Ensure the query is correct.`,
+    ),
 
-      P2016: (operation) => new InternalServerErrorException(
+  P2017: (operation) =>
-          `Query ${operation} failed because the record could not be fetched. Ensure the query is correct.`
+    new InternalServerErrorException(
-      ),
+      `Connected records were not found for ${operation}. Check related data.`,
+    ),
 
-      P2017: (operation) => new InternalServerErrorException(
+  P2018: () =>
-          `Connected records were not found for ${operation}. Check related data.`
+    new InternalServerErrorException(
-      ),
+      `The required connection could not be established. Please check relationships.`,
+    ),
 
-      P2018: () => new InternalServerErrorException(
+  P2019: (_operation, meta) =>
-          `The required connection could not be established. Please check relationships.`
+    new InternalServerErrorException(
-      ),
+      `Invalid input for ${
+        meta?.details || 'a field'
+      }. Please ensure data conforms to expectations.`,
+    ),
 
-      P2019: (_operation, meta) => new InternalServerErrorException(
+  P2021: (_operation, meta) =>
-          `Invalid input for ${meta?.details || 'a field'}. Please ensure data conforms to expectations.`
+    new InternalServerErrorException(
-      ),
+      `The ${meta?.model || 'model'} was not found in the database.`,
+    ),
 
-      P2021: (_operation, meta) => new InternalServerErrorException(
+  P2025: (operation, meta) =>
-          `The ${meta?.model || 'model'} was not found in the database.`
+    new NotFoundException(
-      ),
+      `The ${
+        meta?.model || 'record'
+      } you are trying to ${operation} does not exist. It may have been deleted.`,
+    ),
 
-      P2025: (operation, meta) => new NotFoundException(
+  P2031: () =>
-          `The ${meta?.model || 'record'} you are trying to ${operation} does not exist. It may have been deleted.`
+    new InternalServerErrorException(
-      ),
+      `Invalid Prisma Client initialization error. Please check configuration.`,
+    ),
 
-      P2031: () => new InternalServerErrorException(
+  P2033: (operation) =>
-          `Invalid Prisma Client initialization error. Please check configuration.`
+    new InternalServerErrorException(
-      ),
+      `Insufficient database write permissions for ${operation}.`,
+    ),
 
-      P2033: (operation) => new InternalServerErrorException(
+  P2034: (operation) =>
-          `Insufficient database write permissions for ${operation}.`
+    new InternalServerErrorException(
-      ),
+      `Database read-only transaction failed during ${operation}.`,
+    ),
 
-      P2034: (operation) => new InternalServerErrorException(
+  P2037: (operation) =>
-          `Database read-only transaction failed during ${operation}.`
+    new InternalServerErrorException(
-      ),
+      `Unsupported combinations of input types for ${operation}. Please correct the query or input.`,
+    ),
 
-      P2037: (operation) => new InternalServerErrorException(
+  P1000: () =>
-          `Unsupported combinations of input types for ${operation}. Please correct the query or input.`
+    new InternalServerErrorException(
-      ),
+      `Database authentication failed. Verify your credentials and try again.`,
+    ),
 
-      P1000: () => new InternalServerErrorException(
+  P1001: () =>
-          `Database authentication failed. Verify your credentials and try again.`
+    new InternalServerErrorException(
-      ),
+      `The database server could not be reached. Please check its availability.`,
+    ),
 
-      P1001: () => new InternalServerErrorException(
+  P1002: () =>
-          `The database server could not be reached. Please check its availability.`
+    new InternalServerErrorException(
-      ),
+      `Connection to the database timed out. Verify network connectivity and server availability.`,
+    ),
 
-      P1002: () => new InternalServerErrorException(
+  P1015: (operation) =>
-          `Connection to the database timed out. Verify network connectivity and server availability.`
+    new InternalServerErrorException(
-      ),
+      `Migration failed. Unable to complete ${operation}. Check migration history or database state.`,
-
+    ),
-      P1015: (operation) => new InternalServerErrorException(
-          `Migration failed. Unable to complete ${operation}. Check migration history or database state.`
-      ),
-
-      P1017: () => new InternalServerErrorException(
-          `Database connection failed. Ensure the database is online and credentials are correct.`
-      ),
-      P2023: function (operation: operationT, meta?: PrismaErrorMeta): Error {
-          throw new Error('Function not implemented.');
-      }
-  };
 
+  P1017: () =>
+    new InternalServerErrorException(
+      `Database connection failed. Ensure the database is online and credentials are correct.`,
+    ),
+  P2023: function (operation: operationT, meta?: PrismaErrorMeta): Error {
+    throw new Error('Function not implemented.');
+  },
+};

apps/server/src/models/base/row-cache.service.ts

@@ -1,183 +1,176 @@
-import { UserProfile, RowModelRequest, RowRequestSchema } from "@nice/common";
+import { UserProfile, RowModelRequest, RowRequestSchema } from '@nice/common';
-import { RowModelService } from "./row-model.service";
+import { RowModelService } from './row-model.service';
-import { isFieldCondition, LogicalCondition, SQLBuilder } from "./sql-builder";
+import { isFieldCondition, LogicalCondition, SQLBuilder } from './sql-builder';
-import EventBus from "@server/utils/event-bus";
+import EventBus from '@server/utils/event-bus';
-import supejson from "superjson-cjs"
+import supejson from 'superjson-cjs';
-import { deleteByPattern } from "@server/utils/redis/utils";
+import { deleteByPattern } from '@server/utils/redis/utils';
-import { redis } from "@server/utils/redis/redis.service";
+import { redis } from '@server/utils/redis/redis.service';
-import { z } from "zod";
+import { z } from 'zod';
 export class RowCacheService extends RowModelService {
-    constructor(tableName: string, private enableCache: boolean = true) {
+  constructor(
-        super(tableName)
+    tableName: string,
-        if (this.enableCache) {
+    private enableCache: boolean = true,
-            EventBus.on("dataChanged", async ({ type, data }) => {
+  ) {
-                if (type === tableName) {
+    super(tableName);
-                    const dataArray = Array.isArray(data) ? data : [data];
+    if (this.enableCache) {
-                    for (const item of dataArray) {
+      EventBus.on('dataChanged', async ({ type, data }) => {
-                        try {
+        if (type === tableName) {
-                            if (item.id) {
+          const dataArray = Array.isArray(data) ? data : [data];
-                                this.invalidateRowCacheById(item.id)
+          for (const item of dataArray) {
-                            }
+            try {
-                            if (item.parentId) {
+              if (item.id) {
-                                this.invalidateRowCacheById(item.parentId)
+                this.invalidateRowCacheById(item.id);
-                            }
+              }
-                        } catch (err) {
+              if (item.parentId) {
-                            console.error(`Error deleting cache for type ${tableName}:`, err);
+                this.invalidateRowCacheById(item.parentId);
-                        }
+              }
-                    }
+            } catch (err) {
-                }
+              console.error(`Error deleting cache for type ${tableName}:`, err);
-            });
+            }
+          }
         }
+      });
     }
-    protected getRowCacheKey(id: string) {
+  }
-        return `row-data-${id}`;
+  protected getRowCacheKey(id: string) {
+    return `row-data-${id}`;
+  }
+  private async invalidateRowCacheById(id: string) {
+    if (!this.enableCache) return;
+    const pattern = this.getRowCacheKey(id);
+    await deleteByPattern(pattern);
+  }
+  createJoinSql(request?: RowModelRequest): string[] {
+    return [];
+  }
+  protected async getRowRelation(args: { data: any; staff?: UserProfile }) {
+    return args.data;
+  }
+  protected async setResPermissions(data: any, staff?: UserProfile) {
+    return data;
+  }
+  protected async getRowDto(data: any, staff?: UserProfile): Promise<any> {
+    // 如果没有id，直接返回原数据
+    if (!data?.id) return data;
+    // 如果未启用缓存，直接处理并返回数据
+    if (!this.enableCache) {
+      return this.processDataWithPermissions(data, staff);
     }
-    private async invalidateRowCacheById(id: string) {
+    const key = this.getRowCacheKey(data.id);
-        if (!this.enableCache) return;
+    try {
-        const pattern = this.getRowCacheKey(id);
+      // 尝试从缓存获取数据
-        await deleteByPattern(pattern);
+      const cachedData = await this.getCachedData(key, staff);
-    }
+      // 如果缓存命中，直接返回
-    createJoinSql(request?: RowModelRequest): string[] {
+      if (cachedData) return cachedData;
-        return []
+      // 处理数据并缓存
-    }
+      const processedData = await this.processDataWithPermissions(data, staff);
-    protected async getRowRelation(args: { data: any, staff?: UserProfile }) {
+      await redis.set(key, supejson.stringify(processedData));
-        return args.data;
+      return processedData;
-    }
+    } catch (err) {
-    protected async setResPermissions(
+      this.logger.error('Error in getRowDto:', err);
-        data: any,
+      throw err;
-        staff?: UserProfile,
-    ) {
-        return data
-    }
-    protected async getRowDto(
-        data: any,
-        staff?: UserProfile,
-    ): Promise<any> {
-        // 如果没有id，直接返回原数据
-        if (!data?.id) return data;
-        // 如果未启用缓存，直接处理并返回数据
-        if (!this.enableCache) {
-            return this.processDataWithPermissions(data, staff);
-        }
-        const key = this.getRowCacheKey(data.id);
-        try {
-            // 尝试从缓存获取数据
-            const cachedData = await this.getCachedData(key, staff);
-            // 如果缓存命中，直接返回
-            if (cachedData) return cachedData;
-            // 处理数据并缓存
-            const processedData = await this.processDataWithPermissions(data, staff);
-            await redis.set(key, supejson.stringify(processedData));
-            return processedData;
-        } catch (err) {
-            this.logger.error('Error in getRowDto:', err);
-            throw err;
-        }
     }
+  }
 
-    private async getCachedData(
+  private async getCachedData(
-        key: string,
+    key: string,
-        staff?: UserProfile
+    staff?: UserProfile,
-    ): Promise<any | null> {
+  ): Promise<any | null> {
-        const cachedDataStr = await redis.get(key);
+    const cachedDataStr = await redis.get(key);
-        if (!cachedDataStr) return null;
+    if (!cachedDataStr) return null;
-        const cachedData = supejson.parse(cachedDataStr) as any;
+    const cachedData = supejson.parse(cachedDataStr) as any;
-        if (!cachedData?.id) return null;
+    if (!cachedData?.id) return null;
-        return staff
+    return staff ? this.setResPermissions(cachedData, staff) : cachedData;
-            ? this.setResPermissions(cachedData, staff)
+  }
-            : cachedData;
-    }
 
-    private async processDataWithPermissions(
+  private async processDataWithPermissions(
-        data: any,
+    data: any,
-        staff?: UserProfile
+    staff?: UserProfile,
-    ): Promise<any> {
+  ): Promise<any> {
-        // 处理权限
+    // 处理权限
-        const permData = staff
+    const permData = staff ? await this.setResPermissions(data, staff) : data;
-            ? await this.setResPermissions(data, staff)
+    // 获取关联数据
-            : data;
+    return this.getRowRelation({ data: permData, staff });
-        // 获取关联数据
+  }
-        return this.getRowRelation({ data: permData, staff });
-    }
 
-    protected createGetRowsFilters(
+  protected createGetRowsFilters(
-        request: z.infer<typeof RowRequestSchema>,
+    request: z.infer<typeof RowRequestSchema>,
-        staff?: UserProfile,
+    staff?: UserProfile,
-    ) {
+  ) {
-        const condition = super.createGetRowsFilters(request);
+    const condition = super.createGetRowsFilters(request);
-        if (isFieldCondition(condition)) return {};
+    if (isFieldCondition(condition)) return {};
-        const baseCondition: LogicalCondition[] = [
+    const baseCondition: LogicalCondition[] = [
-            {
+      {
-                field: `${this.tableName}.deleted_at`,
+        field: `${this.tableName}.deleted_at`,
-                op: 'blank',
+        op: 'blank',
-                type: 'date',
+        type: 'date',
-            },
+      },
-        ];
+    ];
-        condition.AND = [...baseCondition, ...condition.AND];
+    condition.AND = [...baseCondition, ...condition.AND];
-        return condition;
+    return condition;
-    }
+  }
-    createUnGroupingRowSelect(request?: RowModelRequest): string[] {
+  createUnGroupingRowSelect(request?: RowModelRequest): string[] {
-        return [
+    return [
-            `${this.tableName}.id AS id`,
+      `${this.tableName}.id AS id`,
-            SQLBuilder.rowNumber(`${this.tableName}.id`, `${this.tableName}.id`),
+      SQLBuilder.rowNumber(`${this.tableName}.id`, `${this.tableName}.id`),
-        ];
+    ];
-    }
+  }
-    protected createGroupingRowSelect(
+  protected createGroupingRowSelect(
-        request: RowModelRequest,
+    request: RowModelRequest,
-        wrapperSql: boolean,
+    wrapperSql: boolean,
-    ): string[] {
+  ): string[] {
-        const colsToSelect = super.createGroupingRowSelect(request, wrapperSql);
+    const colsToSelect = super.createGroupingRowSelect(request, wrapperSql);
-        return colsToSelect.concat([
+    return colsToSelect.concat([
-            SQLBuilder.rowNumber(`${this.tableName}.id`, `${this.tableName}.id`),
+      SQLBuilder.rowNumber(`${this.tableName}.id`, `${this.tableName}.id`),
-        ]);
+    ]);
-    }
+  }
-    protected async getRowsSqlWrapper(
+  protected async getRowsSqlWrapper(
-        sql: string,
+    sql: string,
-        request?: RowModelRequest,
+    request?: RowModelRequest,
-        staff?: UserProfile,
+    staff?: UserProfile,
-    ): Promise<string> {
+  ): Promise<string> {
-        const groupingSql = SQLBuilder.join([
+    const groupingSql = SQLBuilder.join([
-            SQLBuilder.select([
+      SQLBuilder.select([
-                ...this.createGroupingRowSelect(request, true),
+        ...this.createGroupingRowSelect(request, true),
-                `${this.tableName}.id AS id`,
+        `${this.tableName}.id AS id`,
-            ]),
+      ]),
-            SQLBuilder.from(this.tableName),
+      SQLBuilder.from(this.tableName),
-            SQLBuilder.join(this.createJoinSql(request)),
+      SQLBuilder.join(this.createJoinSql(request)),
-            SQLBuilder.where(this.createGetRowsFilters(request, staff)),
+      SQLBuilder.where(this.createGetRowsFilters(request, staff)),
-        ]);
+    ]);
-        const { rowGroupCols, valueCols, groupKeys } = request;
+    const { rowGroupCols, valueCols, groupKeys } = request;
-        if (this.isDoingGroup(request)) {
+    if (this.isDoingGroup(request)) {
-            const rowGroupCol = rowGroupCols[groupKeys.length];
+      const rowGroupCol = rowGroupCols[groupKeys.length];
-            const groupByField = rowGroupCol?.field?.replace('.', '_');
+      const groupByField = rowGroupCol?.field?.replace('.', '_');
-            return SQLBuilder.join([
+      return SQLBuilder.join([
-                SQLBuilder.select([
+        SQLBuilder.select([
-                    groupByField,
+          groupByField,
-                    ...super.createAggSqlForWrapper(request),
+          ...super.createAggSqlForWrapper(request),
-                    'COUNT(id) AS child_count',
+          'COUNT(id) AS child_count',
-                ]),
+        ]),
-                SQLBuilder.from(`(${groupingSql})`),
+        SQLBuilder.from(`(${groupingSql})`),
-                SQLBuilder.where({
+        SQLBuilder.where({
-                    field: 'row_num',
+          field: 'row_num',
-                    value: '1',
+          value: '1',
-                    op: 'equals',
+          op: 'equals',
-                }),
+        }),
-                SQLBuilder.groupBy([groupByField]),
+        SQLBuilder.groupBy([groupByField]),
-                SQLBuilder.orderBy(
+        SQLBuilder.orderBy(
-                    this.getOrderByColumns(request).map((item) => item.replace('.', '_')),
+          this.getOrderByColumns(request).map((item) => item.replace('.', '_')),
-                ),
+        ),
-                this.getLimitSql(request),
+        this.getLimitSql(request),
-            ]);
+      ]);
-        } else
+    } else
-            return SQLBuilder.join([
+      return SQLBuilder.join([
-                SQLBuilder.select(['*']),
+        SQLBuilder.select(['*']),
-                SQLBuilder.from(`(${sql})`),
+        SQLBuilder.from(`(${sql})`),
-                SQLBuilder.where({
+        SQLBuilder.where({
-                    field: 'row_num',
+          field: 'row_num',
-                    value: '1',
+          value: '1',
-                    op: 'equals',
+          op: 'equals',
-                }),
+        }),
-                this.getLimitSql(request),
+        this.getLimitSql(request),
-            ]);
+      ]);
-        // return super.getRowsSqlWrapper(sql, request)
+    // return super.getRowsSqlWrapper(sql, request)
-    }
+  }
 }

apps/server/src/models/base/row-model.service.ts

@@ -21,7 +21,7 @@ export abstract class RowModelService {
     // 添加更多需要引号的关键词
   ]);
   protected logger = new Logger(this.tableName);
-  protected constructor(protected tableName: string) { }
+  protected constructor(protected tableName: string) {}
   protected async getRowDto(row: any, staff?: UserProfile): Promise<any> {
     return row;
   }
@@ -140,11 +140,11 @@ export abstract class RowModelService {
   private buildFilterConditions(filterModel: any): LogicalCondition[] {
     return filterModel
       ? Object.entries(filterModel)?.map(([key, item]) =>
-        SQLBuilder.createFilterSql(
+          SQLBuilder.createFilterSql(
-          key === 'ag-Grid-AutoColumn' ? 'name' : key,
+            key === 'ag-Grid-AutoColumn' ? 'name' : key,
-          item,
+            item,
-        ),
+          ),
-      )
+        )
       : [];
   }
 
@@ -160,7 +160,10 @@ export abstract class RowModelService {
     const { rowGroupCols, valueCols, groupKeys } = request;
     return valueCols.map(
       (valueCol) =>
-        `${valueCol.aggFunc}(${valueCol.field.replace('.', '_')}) AS ${valueCol.field.split('.').join('_')}`,
+        `${valueCol.aggFunc}(${valueCol.field.replace(
+          '.',
+          '_',
+        )}) AS ${valueCol.field.split('.').join('_')}`,
     );
   }
   protected createGroupingRowSelect(
@@ -179,7 +182,9 @@ export abstract class RowModelService {
     colsToSelect.push(
       ...valueCols.map(
         (valueCol) =>
-          `${wrapperSql ? '' : valueCol.aggFunc}(${valueCol.field}) AS ${valueCol.field.replace('.', '_')}`,
+          `${wrapperSql ? '' : valueCol.aggFunc}(${
+            valueCol.field
+          }) AS ${valueCol.field.replace('.', '_')}`,
       ),
     );
 
@@ -286,7 +291,10 @@ export abstract class RowModelService {
   protected buildAggSelect(valueCols: any[]): string[] {
     return valueCols.map(
       (valueCol) =>
-        `${valueCol.aggFunc}(${valueCol.field}) AS ${valueCol.field.replace('.', '_')}`,
+        `${valueCol.aggFunc}(${valueCol.field}) AS ${valueCol.field.replace(
+          '.',
+          '_',
+        )}`,
     );
   }
 

apps/server/src/models/base/sql-builder.ts

@@ -1,138 +1,172 @@
 export interface FieldCondition {
-    field: string;
+  field: string;
-    op: OperatorType
+  op: OperatorType;
-    type?: "text" | "number" | "date";
+  type?: 'text' | 'number' | 'date';
-    value?: any;
+  value?: any;
-    valueTo?: any;
+  valueTo?: any;
-};
+}
-export type OperatorType = 'equals' | 'notEqual' | 'contains' | 'startsWith' | 'endsWith' | 'blank' | 'notBlank' | 'greaterThan' | 'lessThanOrEqual' | 'inRange' | 'lessThan' | 'greaterThan' | 'in';
+export type OperatorType =
-export type LogicalCondition = FieldCondition | {
+  | 'equals'
-    AND?: LogicalCondition[];
+  | 'notEqual'
-    OR?: LogicalCondition[];
+  | 'contains'
-};
+  | 'startsWith'
+  | 'endsWith'
+  | 'blank'
+  | 'notBlank'
+  | 'greaterThan'
+  | 'lessThanOrEqual'
+  | 'inRange'
+  | 'lessThan'
+  | 'greaterThan'
+  | 'in';
+export type LogicalCondition =
+  | FieldCondition
+  | {
+      AND?: LogicalCondition[];
+      OR?: LogicalCondition[];
+    };
 
-export function isFieldCondition(condition: LogicalCondition): condition is FieldCondition {
+export function isFieldCondition(
-    return (condition as FieldCondition).field !== undefined;
+  condition: LogicalCondition,
+): condition is FieldCondition {
+  return (condition as FieldCondition).field !== undefined;
 }
 function buildCondition(condition: FieldCondition): string {
-    const { field, op, value, type = "text", valueTo } = condition;
+  const { field, op, value, type = 'text', valueTo } = condition;
-    switch (op) {
+  switch (op) {
-        case 'equals':
+    case 'equals':
-            return `${field} = '${value}'`;
+      return `${field} = '${value}'`;
-        case 'notEqual':
+    case 'notEqual':
-            return `${field} != '${value}'`;
+      return `${field} != '${value}'`;
-        case 'contains':
+    case 'contains':
-            return `${field} LIKE '%${value}%'`;
+      return `${field} LIKE '%${value}%'`;
-        case 'startsWith':
+    case 'startsWith':
-            return `${field} LIKE '${value}%'`;
+      return `${field} LIKE '${value}%'`;
-        case 'endsWith':
+    case 'endsWith':
-            return `${field} LIKE '%${value}'`;
+      return `${field} LIKE '%${value}'`;
-        case 'blank':
+    case 'blank':
-            if (type !== "date")
+      if (type !== 'date') return `(${field} IS NULL OR ${field} = '')`;
-                return `(${field} IS NULL OR ${field} = '')`;
+      else return `${field} IS NULL`;
-            else
+    case 'notBlank':
-                return `${field} IS NULL`;
+      if (type !== 'date') return `${field} IS NOT NULL AND ${field} != ''`;
-        case 'notBlank':
+      else return `${field} IS NOT NULL`;
-            if (type !== 'date')
+    case 'greaterThan':
-                return `${field} IS NOT NULL AND ${field} != ''`;
+      return `${field} > '${value}'`;
-            else
+    case 'lessThanOrEqual':
-                return `${field} IS NOT NULL`;
+      return `${field} <= '${value}'`;
-        case 'greaterThan':
+    case 'lessThan':
-            return `${field} > '${value}'`;
+      return `${field} < '${value}'`;
-        case 'lessThanOrEqual':
+    case 'greaterThan':
-            return `${field} <= '${value}'`;
+      return `${field} > '${value}'`;
-        case 'lessThan':
+    case 'inRange':
-            return `${field} < '${value}'`;
+      return `${field} >= '${value}' AND ${field} <= '${valueTo}'`;
-        case 'greaterThan':
+    case 'in':
-            return `${field} > '${value}'`;
+      if (!value || (Array.isArray(value) && value.length === 0)) {
-        case 'inRange':
+        // Return a condition that is always false if value is empty or an empty array
-            return `${field} >= '${value}' AND ${field} <= '${valueTo}'`;
+        return '1 = 0';
-        case 'in':
+      }
-            if (!value || (Array.isArray(value) && value.length === 0)) {
+      return `${field} IN (${(value as any[])
-                // Return a condition that is always false if value is empty or an empty array
+        .map((val) => `'${val}'`)
-                return '1 = 0';
+        .join(', ')})`;
-            }
+    default:
-            return `${field} IN (${(value as any[]).map(val => `'${val}'`).join(', ')})`;
+      return 'true'; // Default return for unmatched conditions
-        default:
+  }
-            return 'true'; // Default return for unmatched conditions
-    }
 }
 function buildLogicalCondition(logicalCondition: LogicalCondition): string {
-    if (isFieldCondition(logicalCondition)) {
+  if (isFieldCondition(logicalCondition)) {
-        return buildCondition(logicalCondition);
+    return buildCondition(logicalCondition);
+  }
+  const parts: string[] = [];
+  if (logicalCondition.AND && logicalCondition.AND.length > 0) {
+    const andParts = logicalCondition.AND.map((c) =>
+      buildLogicalCondition(c),
+    ).filter((part) => part !== ''); // Filter out empty conditions
+    if (andParts.length > 0) {
+      parts.push(`(${andParts.join(' AND ')})`);
     }
-    const parts: string[] = [];
+  }
-    if (logicalCondition.AND && logicalCondition.AND.length > 0) {
+  // Process OR conditions
-        const andParts = logicalCondition.AND
+  if (logicalCondition.OR && logicalCondition.OR.length > 0) {
-            .map(c => buildLogicalCondition(c))
+    const orParts = logicalCondition.OR.map((c) =>
-            .filter(part => part !== ''); // Filter out empty conditions
+      buildLogicalCondition(c),
-        if (andParts.length > 0) {
+    ).filter((part) => part !== ''); // Filter out empty conditions
-            parts.push(`(${andParts.join(' AND ')})`);
+    if (orParts.length > 0) {
-        }
+      parts.push(`(${orParts.join(' OR ')})`);
     }
-    // Process OR conditions
+  }
-    if (logicalCondition.OR && logicalCondition.OR.length > 0) {
+  // Join AND and OR parts with an 'AND' if both are present
-        const orParts = logicalCondition.OR
+  return parts.length > 1 ? parts.join(' AND ') : parts[0] || '';
-            .map(c => buildLogicalCondition(c))
-            .filter(part => part !== ''); // Filter out empty conditions
-        if (orParts.length > 0) {
-            parts.push(`(${orParts.join(' OR ')})`);
-        }
-    }
-    // Join AND and OR parts with an 'AND' if both are present
-    return parts.length > 1 ? parts.join(' AND ') : parts[0] || '';
 }
 
 export class SQLBuilder {
-    static select(fields: string[], distinctField?: string): string {
+  static select(fields: string[], distinctField?: string): string {
-        const distinctClause = distinctField ? `DISTINCT ON (${distinctField}) ` : "";
+    const distinctClause = distinctField
-        return `SELECT ${distinctClause}${fields.join(", ")}`;
+      ? `DISTINCT ON (${distinctField}) `
-    }
+      : '';
-    static rowNumber(orderBy: string, partitionBy: string | null = null, alias: string = 'row_num'): string {
+    return `SELECT ${distinctClause}${fields.join(', ')}`;
-        if (!orderBy) {
+  }
-            throw new Error("orderBy 参数不能为空");
+  static rowNumber(
-        }
+    orderBy: string,
-
+    partitionBy: string | null = null,
-        let partitionClause = '';
+    alias: string = 'row_num',
-        if (partitionBy) {
+  ): string {
-            partitionClause = `PARTITION BY ${partitionBy} `;
+    if (!orderBy) {
-        }
+      throw new Error('orderBy 参数不能为空');
-
-        return `ROW_NUMBER() OVER (${partitionClause}ORDER BY ${orderBy}) AS ${alias}`;
-    }
-    static from(tableName: string): string {
-        return `FROM ${tableName}`;
     }
 
-    static where(conditions: LogicalCondition): string {
+    let partitionClause = '';
-        const whereClause = buildLogicalCondition(conditions);
+    if (partitionBy) {
-        return whereClause ? `WHERE ${whereClause}` : "";
+      partitionClause = `PARTITION BY ${partitionBy} `;
     }
 
-    static groupBy(columns: string[]): string {
+    return `ROW_NUMBER() OVER (${partitionClause}ORDER BY ${orderBy}) AS ${alias}`;
-        return columns.length ? `GROUP BY ${columns.join(", ")}` : "";
+  }
-    }
+  static from(tableName: string): string {
+    return `FROM ${tableName}`;
+  }
 
-    static orderBy(columns: string[]): string {
+  static where(conditions: LogicalCondition): string {
-        return columns.length ? `ORDER BY ${columns.join(", ")}` : "";
+    const whereClause = buildLogicalCondition(conditions);
-    }
+    return whereClause ? `WHERE ${whereClause}` : '';
+  }
 
-    static limit(pageSize: number, offset: number = 0): string {
+  static groupBy(columns: string[]): string {
-        return `LIMIT ${pageSize + 1} OFFSET ${offset}`;
+    return columns.length ? `GROUP BY ${columns.join(', ')}` : '';
-    }
+  }
 
-    static join(clauses: string[]): string {
+  static orderBy(columns: string[]): string {
-        return clauses.filter(Boolean).join(' ');
+    return columns.length ? `ORDER BY ${columns.join(', ')}` : '';
-    }
+  }
-    static createFilterSql(key: string, item: any): LogicalCondition {
-        const conditionFuncs: Record<string, (item: { values?: any[], dateFrom?: string, dateTo?: string, filter: any, type: OperatorType, filterType: OperatorType }) => LogicalCondition> = {
-            text: (item) => ({ value: item.filter, op: item.type, field: key }),
-            number: (item) => ({ value: item.filter, op: item.type, field: key }),
-            date: (item) => ({ value: item.dateFrom, valueTo: item.dateTo, op: item.type, field: key }),
-            set: (item) => ({ value: item.values, op: "in", field: key })
-        }
-        return conditionFuncs[item.filterType](item)
 
-    }
+  static limit(pageSize: number, offset: number = 0): string {
+    return `LIMIT ${pageSize + 1} OFFSET ${offset}`;
+  }
+
+  static join(clauses: string[]): string {
+    return clauses.filter(Boolean).join(' ');
+  }
+  static createFilterSql(key: string, item: any): LogicalCondition {
+    const conditionFuncs: Record<
+      string,
+      (item: {
+        values?: any[];
+        dateFrom?: string;
+        dateTo?: string;
+        filter: any;
+        type: OperatorType;
+        filterType: OperatorType;
+      }) => LogicalCondition
+    > = {
+      text: (item) => ({ value: item.filter, op: item.type, field: key }),
+      number: (item) => ({ value: item.filter, op: item.type, field: key }),
+      date: (item) => ({
+        value: item.dateFrom,
+        valueTo: item.dateTo,
+        op: item.type,
+        field: key,
+      }),
+      set: (item) => ({ value: item.values, op: 'in', field: key }),
+    };
+    return conditionFuncs[item.filterType](item);
+  }
 }
-

apps/server/src/models/daily-train/dailyTrain.controller.ts

@@ -1,9 +1,9 @@
-import { Controller, UseGuards } from "@nestjs/common";
+import { Controller, UseGuards } from '@nestjs/common';
 import { AuthGuard } from '@server/auth/auth.guard';
-import { DailyTrainService } from "./dailyTrain.service";
+import { DailyTrainService } from './dailyTrain.service';
 
 @Controller('train-content')
 export class DailyTrainController {
-    constructor(private readonly dailyTrainService: DailyTrainService) {}
+  constructor(private readonly dailyTrainService: DailyTrainService) {}
-    //@UseGuards(AuthGuard)
+  //@UseGuards(AuthGuard)
 }

apps/server/src/models/daily-train/dailyTrain.module.ts

@@ -5,11 +5,10 @@ import { DailyTrainController } from './dailyTrain.controller';
 import { DailyTrainService } from './dailyTrain.service';
 import { DailyTrainRouter } from './dailyTrain.router';
 
-
 @Module({
   imports: [StaffModule],
   controllers: [DailyTrainController],
-  providers: [DailyTrainService,DailyTrainRouter,TrpcService],
+  providers: [DailyTrainService, DailyTrainRouter, TrpcService],
-  exports: [DailyTrainService,DailyTrainRouter],
+  exports: [DailyTrainService, DailyTrainRouter],
 })
 export class DailyTrainModule {}

apps/server/src/models/daily-train/dailyTrain.router.ts

@@ -1,16 +1,13 @@
-import { Injectable } from "@nestjs/common";
+import { Injectable } from '@nestjs/common';
-import { TrpcService } from "@server/trpc/trpc.service";
+import { TrpcService } from '@server/trpc/trpc.service';
-import { DailyTrainService } from "./dailyTrain.service";
+import { DailyTrainService } from './dailyTrain.service';
 
 @Injectable()
 export class DailyTrainRouter {
-    constructor(
+  constructor(
-        private readonly trpc: TrpcService,
+    private readonly trpc: TrpcService,
-        private readonly dailyTrainService: DailyTrainService,
+    private readonly dailyTrainService: DailyTrainService,
-    ) { }
+  ) {}
-
-    router = this.trpc.router({
-
-    })
 
+  router = this.trpc.router({});
 }

apps/server/src/models/daily-train/dailyTrain.service.ts

@@ -1,40 +1,37 @@
-import { Injectable } from "@nestjs/common";
+import { Injectable } from '@nestjs/common';
-import { BaseService } from "../base/base.service";
+import { BaseService } from '../base/base.service';
-import { db, ObjectType, Prisma, UserProfile } from "@nice/common";
+import { db, ObjectType, Prisma, UserProfile } from '@nice/common';
-import { DefaultArgs } from "@prisma/client/runtime/library";
+import { DefaultArgs } from '@prisma/client/runtime/library';
-import EventBus, { CrudOperation } from "@server/utils/event-bus";
+import EventBus, { CrudOperation } from '@server/utils/event-bus';
-
 
 @Injectable()
 export class DailyTrainService extends BaseService<Prisma.DailyTrainTimeDelegate> {
-    constructor() {
+  constructor() {
-        super(db,ObjectType.DAILY_TRAIN,true);
+    super(db, ObjectType.DAILY_TRAIN, true);
-    }
+  }
-    async create(args: Prisma.DailyTrainTimeCreateArgs) {
+  async create(args: Prisma.DailyTrainTimeCreateArgs) {
-        console.log(args)
+    console.log(args);
-        const result = await super.create(args)
+    const result = await super.create(args);
-        this.emitDataChanged(CrudOperation.CREATED,result)
+    this.emitDataChanged(CrudOperation.CREATED, result);
-        return result    
+    return result;
-    }
+  }
 
-    async update(args:Prisma.DailyTrainTimeUpdateArgs){
+  async update(args: Prisma.DailyTrainTimeUpdateArgs) {
-        const result = await super.update(args)
+    const result = await super.update(args);
-        this.emitDataChanged(CrudOperation.UPDATED,result)
+    this.emitDataChanged(CrudOperation.UPDATED, result);
-        return result
+    return result;
-    }
+  }
 
+  async findMany(args: Prisma.DailyTrainTimeFindManyArgs) {
+    const result = await super.findMany(args);
+    return result;
+  }
 
-    async findMany(args: Prisma.DailyTrainTimeFindManyArgs) {
+  private emitDataChanged(operation: CrudOperation, data: any) {
-        const result = await super.findMany(args);
+    EventBus.emit('dataChanged', {
-        return result;
+      type: ObjectType.DAILY_TRAIN,
-    }
+      operation,
-
+      data,
-
+    });
-    private emitDataChanged(operation: CrudOperation, data: any) {
+  }
-        EventBus.emit('dataChanged', {
-          type:ObjectType.DAILY_TRAIN,
-          operation,
-          data,
-        });
-    }
 }

apps/server/src/models/department/department.controller.ts

@@ -6,7 +6,7 @@ import { db } from '@nice/common';
 
 @Controller('dept')
 export class DepartmentController {
-  constructor(private readonly deptService: DepartmentService) { }
+  constructor(private readonly deptService: DepartmentService) {}
   @UseGuards(AuthGuard)
   @Get('get-detail')
   async getDepartmentDetails(@Query('dept-id') deptId: string) {

apps/server/src/models/department/department.module.ts

@@ -6,8 +6,13 @@ import { DepartmentController } from './department.controller';
 import { DepartmentRowService } from './department.row.service';
 
 @Module({
-    providers: [DepartmentService, DepartmentRouter, DepartmentRowService, TrpcService],
+  providers: [
-    exports: [DepartmentService, DepartmentRouter],
+    DepartmentService,
-    controllers: [DepartmentController],
+    DepartmentRouter,
+    DepartmentRowService,
+    TrpcService,
+  ],
+  exports: [DepartmentService, DepartmentRouter],
+  controllers: [DepartmentController],
 })
-export class DepartmentModule { }
+export class DepartmentModule {}

apps/server/src/models/message/message.controller.ts

@@ -6,7 +6,7 @@ import { db, VisitType } from '@nice/common';
 
 @Controller('message')
 export class MessageController {
-  constructor(private readonly messageService: MessageService) { }
+  constructor(private readonly messageService: MessageService) {}
   @UseGuards(AuthGuard)
   @Get('find-last-one')
   async findLastOne(@Query('staff-id') staffId: string) {
@@ -27,7 +27,7 @@ export class MessageController {
         select: {
           title: true,
           content: true,
-          url: true
+          url: true,
         },
       });
 
@@ -53,7 +53,7 @@ export class MessageController {
           visits: {
             none: {
               id: staffId,
-              type: VisitType.READED
+              type: VisitType.READED,
             },
           },
           receivers: {
@@ -92,7 +92,7 @@ export class MessageController {
           visits: {
             none: {
               id: staffId,
-              type: VisitType.READED
+              type: VisitType.READED,
             },
           },
           receivers: {

apps/server/src/models/message/message.module.ts

@@ -11,4 +11,4 @@ import { MessageController } from './message.controller';
   exports: [MessageService, MessageRouter],
   controllers: [MessageController],
 })
-export class MessageModule { }
+export class MessageModule {}

apps/server/src/models/message/message.router.ts

@@ -3,15 +3,16 @@ import { TrpcService } from '@server/trpc/trpc.service';
 import { MessageService } from './message.service';
 import { Prisma } from '@nice/common';
 import { z, ZodType } from 'zod';
-const MessageUncheckedCreateInputSchema: ZodType<Prisma.MessageUncheckedCreateInput> = z.any()
+const MessageUncheckedCreateInputSchema: ZodType<Prisma.MessageUncheckedCreateInput> =
-const MessageWhereInputSchema: ZodType<Prisma.MessageWhereInput> = z.any()
+  z.any();
-const MessageSelectSchema: ZodType<Prisma.MessageSelect> = z.any()
+const MessageWhereInputSchema: ZodType<Prisma.MessageWhereInput> = z.any();
+const MessageSelectSchema: ZodType<Prisma.MessageSelect> = z.any();
 @Injectable()
 export class MessageRouter {
   constructor(
     private readonly trpc: TrpcService,
     private readonly messageService: MessageService,
-  ) { }
+  ) {}
   router = this.trpc.router({
     create: this.trpc.procedure
       .input(MessageUncheckedCreateInputSchema)
@@ -20,20 +21,21 @@ export class MessageRouter {
         return await this.messageService.create({ data: input }, { staff });
       }),
     findManyWithCursor: this.trpc.protectProcedure
-      .input(z.object({
+      .input(
-        cursor: z.any().nullish(),
+        z.object({
-        take: z.number().nullish(),
+          cursor: z.any().nullish(),
-        where: MessageWhereInputSchema.nullish(),
+          take: z.number().nullish(),
-        select: MessageSelectSchema.nullish()
+          where: MessageWhereInputSchema.nullish(),
-      }))
+          select: MessageSelectSchema.nullish(),
+        }),
+      )
       .query(async ({ ctx, input }) => {
         const { staff } = ctx;
         return await this.messageService.findManyWithCursor(input, staff);
       }),
-    getUnreadCount: this.trpc.protectProcedure
+    getUnreadCount: this.trpc.protectProcedure.query(async ({ ctx }) => {
-      .query(async ({ ctx }) => {
+      const { staff } = ctx;
-        const { staff } = ctx;
+      return await this.messageService.getUnreadCount(staff);
-        return await this.messageService.getUnreadCount(staff);
+    }),
-      })
+  });
-  })
 }

apps/server/src/models/message/message.service.ts

@@ -8,26 +8,28 @@ export class MessageService extends BaseService<Prisma.MessageDelegate> {
   constructor() {
     super(db, ObjectType.MESSAGE);
   }
-  async create(args: Prisma.MessageCreateArgs, params?: { tx?: Prisma.MessageDelegate, staff?: UserProfile }) {
+  async create(
+    args: Prisma.MessageCreateArgs,
+    params?: { tx?: Prisma.MessageDelegate; staff?: UserProfile },
+  ) {
     args.data!.senderId = params?.staff?.id;
     args.include = {
       receivers: {
-        select: { id: true, registerToken: true, username: true }
+        select: { id: true, registerToken: true, username: true },
-      }
+      },
-    }
+    };
     const result = await super.create(args);
-    EventBus.emit("dataChanged", {
+    EventBus.emit('dataChanged', {
       type: ObjectType.MESSAGE,
       operation: CrudOperation.CREATED,
-      data: result
+      data: result,
-    })
+    });
-    return result
+    return result;
   }
   async findManyWithCursor(
     args: Prisma.MessageFindManyArgs,
     staff?: UserProfile,
   ) {
-
     return this.wrapResult(super.findManyWithCursor(args), async (result) => {
       let { items } = result;
       await Promise.all(
@@ -46,12 +48,12 @@ export class MessageService extends BaseService<Prisma.MessageDelegate> {
         visits: {
           none: {
             visitorId: staff?.id,
-            type: VisitType.READED
+            type: VisitType.READED,
-          }
+          },
-        }
+        },
-      }
+      },
-    })
+    });
 
-    return count
+    return count;
   }
 }

apps/server/src/models/message/utils.ts

@@ -1,20 +1,18 @@
-import { Message, UserProfile, VisitType, db } from "@nice/common"
+import { Message, UserProfile, VisitType, db } from '@nice/common';
 export async function setMessageRelation(
-    data: Message,
+  data: Message,
-    staff?: UserProfile,
+  staff?: UserProfile,
 ): Promise<any> {
+  const readed =
+    (await db.visit.count({
+      where: {
+        messageId: data.id,
+        type: VisitType.READED,
+        visitorId: staff?.id,
+      },
+    })) > 0;
 
-    const readed =
+  Object.assign(data, {
-        (await db.visit.count({
+    readed,
-            where: {
+  });
-                messageId: data.id,
-                type: VisitType.READED,
-                visitorId: staff?.id,
-            },
-        })) > 0;
-
-
-    Object.assign(data, {
-        readed
-    })
 }

apps/server/src/models/position/dailyTrain.controller.ts

@@ -1,9 +1,9 @@
-import { Controller, UseGuards } from "@nestjs/common";
+import { Controller, UseGuards } from '@nestjs/common';
 import { AuthGuard } from '@server/auth/auth.guard';
-import { DailyTrainService } from "./dailyTrain.service";
+import { DailyTrainService } from './dailyTrain.service';
 
 @Controller('train-content')
 export class DailyTrainController {
-    constructor(private readonly dailyTrainService: DailyTrainService) {}
+  constructor(private readonly dailyTrainService: DailyTrainService) {}
-    //@UseGuards(AuthGuard)
+  //@UseGuards(AuthGuard)
 }

apps/server/src/models/position/dailyTrain.module.ts

@@ -5,11 +5,10 @@ import { DailyTrainController } from './dailyTrain.controller';
 import { DailyTrainService } from './dailyTrain.service';
 import { DailyTrainRouter } from './dailyTrain.router';
 
-
 @Module({
   imports: [StaffModule],
   controllers: [DailyTrainController],
-  providers: [DailyTrainService,DailyTrainRouter,TrpcService],
+  providers: [DailyTrainService, DailyTrainRouter, TrpcService],
-  exports: [DailyTrainService,DailyTrainRouter],
+  exports: [DailyTrainService, DailyTrainRouter],
 })
 export class DailyTrainModule {}

apps/server/src/models/position/dailyTrain.router.ts

@@ -1,16 +1,13 @@
-import { Injectable } from "@nestjs/common";
+import { Injectable } from '@nestjs/common';
-import { TrpcService } from "@server/trpc/trpc.service";
+import { TrpcService } from '@server/trpc/trpc.service';
-import { DailyTrainService } from "./dailyTrain.service";
+import { DailyTrainService } from './dailyTrain.service';
 
 @Injectable()
 export class DailyTrainRouter {
-    constructor(
+  constructor(
-        private readonly trpc: TrpcService,
+    private readonly trpc: TrpcService,
-        private readonly dailyTrainService: DailyTrainService,
+    private readonly dailyTrainService: DailyTrainService,
-    ) { }
+  ) {}
-
-    router = this.trpc.router({
-
-    })
 
+  router = this.trpc.router({});
 }

apps/server/src/models/position/dailyTrain.service.ts

@@ -1,40 +1,37 @@
-import { Injectable } from "@nestjs/common";
+import { Injectable } from '@nestjs/common';
-import { BaseService } from "../base/base.service";
+import { BaseService } from '../base/base.service';
-import { db, ObjectType, Prisma, UserProfile } from "@nice/common";
+import { db, ObjectType, Prisma, UserProfile } from '@nice/common';
-import { DefaultArgs } from "@prisma/client/runtime/library";
+import { DefaultArgs } from '@prisma/client/runtime/library';
-import EventBus, { CrudOperation } from "@server/utils/event-bus";
+import EventBus, { CrudOperation } from '@server/utils/event-bus';
-
 
 @Injectable()
 export class DailyTrainService extends BaseService<Prisma.DailyTrainTimeDelegate> {
-    constructor() {
+  constructor() {
-        super(db,ObjectType.DAILY_TRAIN,true);
+    super(db, ObjectType.DAILY_TRAIN, true);
-    }
+  }
-    async create(args: Prisma.DailyTrainTimeCreateArgs) {
+  async create(args: Prisma.DailyTrainTimeCreateArgs) {
-        console.log(args)
+    console.log(args);
-        const result = await super.create(args)
+    const result = await super.create(args);
-        this.emitDataChanged(CrudOperation.CREATED,result)
+    this.emitDataChanged(CrudOperation.CREATED, result);
-        return result    
+    return result;
-    }
+  }
 
-    async update(args:Prisma.DailyTrainTimeUpdateArgs){
+  async update(args: Prisma.DailyTrainTimeUpdateArgs) {
-        const result = await super.update(args)
+    const result = await super.update(args);
-        this.emitDataChanged(CrudOperation.UPDATED,result)
+    this.emitDataChanged(CrudOperation.UPDATED, result);
-        return result
+    return result;
-    }
+  }
 
+  async findMany(args: Prisma.DailyTrainTimeFindManyArgs) {
+    const result = await super.findMany(args);
+    return result;
+  }
 
-    async findMany(args: Prisma.DailyTrainTimeFindManyArgs) {
+  private emitDataChanged(operation: CrudOperation, data: any) {
-        const result = await super.findMany(args);
+    EventBus.emit('dataChanged', {
-        return result;
+      type: ObjectType.DAILY_TRAIN,
-    }
+      operation,
-
+      data,
-
+    });
-    private emitDataChanged(operation: CrudOperation, data: any) {
+  }
-        EventBus.emit('dataChanged', {
-          type:ObjectType.DAILY_TRAIN,
-          operation,
-          data,
-        });
-    }
 }

apps/server/src/models/rbac/rbac.module.ts

@@ -8,7 +8,13 @@ import { DepartmentModule } from '../department/department.module';
 
 @Module({
   imports: [DepartmentModule],
-  providers: [RoleMapService, RoleRouter, TrpcService, RoleService, RoleMapRouter],
+  providers: [
-  exports: [RoleRouter, RoleService, RoleMapService, RoleMapRouter]
+    RoleMapService,
+    RoleRouter,
+    TrpcService,
+    RoleService,
+    RoleMapRouter,
+  ],
+  exports: [RoleRouter, RoleService, RoleMapService, RoleMapRouter],
 })
-export class RoleMapModule { }
+export class RoleMapModule {}

apps/server/src/models/rbac/role.router.ts

@@ -3,86 +3,91 @@ import { TrpcService } from '@server/trpc/trpc.service';
 import { Prisma, UpdateOrderSchema } from '@nice/common';
 import { RoleService } from './role.service';
 import { z, ZodType } from 'zod';
-const RoleCreateArgsSchema: ZodType<Prisma.RoleCreateArgs> = z.any()
+const RoleCreateArgsSchema: ZodType<Prisma.RoleCreateArgs> = z.any();
-const RoleUpdateArgsSchema: ZodType<Prisma.RoleUpdateArgs> = z.any()
+const RoleUpdateArgsSchema: ZodType<Prisma.RoleUpdateArgs> = z.any();
-const RoleCreateManyInputSchema: ZodType<Prisma.RoleCreateManyInput> = z.any()
+const RoleCreateManyInputSchema: ZodType<Prisma.RoleCreateManyInput> = z.any();
-const RoleDeleteManyArgsSchema: ZodType<Prisma.RoleDeleteManyArgs> = z.any()
+const RoleDeleteManyArgsSchema: ZodType<Prisma.RoleDeleteManyArgs> = z.any();
-const RoleFindManyArgsSchema: ZodType<Prisma.RoleFindManyArgs> = z.any()
+const RoleFindManyArgsSchema: ZodType<Prisma.RoleFindManyArgs> = z.any();
-const RoleFindFirstArgsSchema: ZodType<Prisma.RoleFindFirstArgs> = z.any()
+const RoleFindFirstArgsSchema: ZodType<Prisma.RoleFindFirstArgs> = z.any();
-const RoleWhereInputSchema: ZodType<Prisma.RoleWhereInput> = z.any()
+const RoleWhereInputSchema: ZodType<Prisma.RoleWhereInput> = z.any();
-const RoleSelectSchema: ZodType<Prisma.RoleSelect> = z.any()
+const RoleSelectSchema: ZodType<Prisma.RoleSelect> = z.any();
 const RoleUpdateInputSchema: ZodType<Prisma.RoleUpdateInput> = z.any();
 @Injectable()
 export class RoleRouter {
-    constructor(
+  constructor(
-        private readonly trpc: TrpcService,
+    private readonly trpc: TrpcService,
-        private readonly roleService: RoleService,
+    private readonly roleService: RoleService,
-    ) { }
+  ) {}
-    router = this.trpc.router({
+  router = this.trpc.router({
-        create: this.trpc.protectProcedure
+    create: this.trpc.protectProcedure
-            .input(RoleCreateArgsSchema)
+      .input(RoleCreateArgsSchema)
-            .mutation(async ({ ctx, input }) => {
+      .mutation(async ({ ctx, input }) => {
-                const { staff } = ctx;
+        const { staff } = ctx;
-                return await this.roleService.create(input, staff);
+        return await this.roleService.create(input, staff);
-            }),
+      }),
-        update: this.trpc.protectProcedure
+    update: this.trpc.protectProcedure
-            .input(RoleUpdateArgsSchema)
+      .input(RoleUpdateArgsSchema)
-            .mutation(async ({ ctx, input }) => {
+      .mutation(async ({ ctx, input }) => {
-                const { staff } = ctx;
+        const { staff } = ctx;
-                return await this.roleService.update(input, staff);
+        return await this.roleService.update(input, staff);
-            }),
+      }),
-        createMany: this.trpc.protectProcedure.input(z.array(RoleCreateManyInputSchema))
+    createMany: this.trpc.protectProcedure
-            .mutation(async ({ ctx, input }) => {
+      .input(z.array(RoleCreateManyInputSchema))
-                const { staff } = ctx;
+      .mutation(async ({ ctx, input }) => {
+        const { staff } = ctx;
 
-                return await this.roleService.createMany({ data: input }, staff);
+        return await this.roleService.createMany({ data: input }, staff);
-            }),
+      }),
-        softDeleteByIds: this.trpc.protectProcedure
+    softDeleteByIds: this.trpc.protectProcedure
-            .input(
+      .input(
-                z.object({
+        z.object({
-                    ids: z.array(z.string()),
+          ids: z.array(z.string()),
-                    data: RoleUpdateInputSchema.optional()
+          data: RoleUpdateInputSchema.optional(),
-                }),
+        }),
-            )
+      )
-            .mutation(async ({ input }) => {
+      .mutation(async ({ input }) => {
-                return await this.roleService.softDeleteByIds(input.ids, input.data);
+        return await this.roleService.softDeleteByIds(input.ids, input.data);
-            }),
+      }),
-        findFirst: this.trpc.procedure
+    findFirst: this.trpc.procedure
-            .input(RoleFindFirstArgsSchema) // Assuming StaffMethodSchema.findMany is the Zod schema for finding staffs by keyword
+      .input(RoleFindFirstArgsSchema) // Assuming StaffMethodSchema.findMany is the Zod schema for finding staffs by keyword
-            .query(async ({ input }) => {
+      .query(async ({ input }) => {
-                return await this.roleService.findFirst(input);
+        return await this.roleService.findFirst(input);
-            }),
+      }),
 
-        updateOrder: this.trpc.protectProcedure
+    updateOrder: this.trpc.protectProcedure
-            .input(UpdateOrderSchema)
+      .input(UpdateOrderSchema)
-            .mutation(async ({ input }) => {
+      .mutation(async ({ input }) => {
-                return this.roleService.updateOrder(input);
+        return this.roleService.updateOrder(input);
-            }),
+      }),
-        findMany: this.trpc.procedure
+    findMany: this.trpc.procedure
-            .input(RoleFindManyArgsSchema) // Assuming StaffMethodSchema.findMany is the Zod schema for finding staffs by keyword
+      .input(RoleFindManyArgsSchema) // Assuming StaffMethodSchema.findMany is the Zod schema for finding staffs by keyword
-            .query(async ({ input }) => {
+      .query(async ({ input }) => {
-                return await this.roleService.findMany(input);
+        return await this.roleService.findMany(input);
-            }),
+      }),
-        findManyWithCursor: this.trpc.protectProcedure
+    findManyWithCursor: this.trpc.protectProcedure
-            .input(z.object({
+      .input(
-                cursor: z.any().nullish(),
+        z.object({
-                take: z.number().optional(),
+          cursor: z.any().nullish(),
-                where: RoleWhereInputSchema.optional(),
+          take: z.number().optional(),
-                select: RoleSelectSchema.optional()
+          where: RoleWhereInputSchema.optional(),
-            }))
+          select: RoleSelectSchema.optional(),
-            .query(async ({ ctx, input }) => {
+        }),
-                const { staff } = ctx;
+      )
-                return await this.roleService.findManyWithCursor(input);
+      .query(async ({ ctx, input }) => {
-            }),
+        const { staff } = ctx;
-        findManyWithPagination: this.trpc.procedure
+        return await this.roleService.findManyWithCursor(input);
-            .input(z.object({
+      }),
-                page: z.number(),
+    findManyWithPagination: this.trpc.procedure
-                pageSize: z.number().optional(),
+      .input(
-                where: RoleWhereInputSchema.optional(),
+        z.object({
-                select: RoleSelectSchema.optional()
+          page: z.number(),
-            })) // Assuming StaffMethodSchema.findMany is the Zod schema for finding staffs by keyword
+          pageSize: z.number().optional(),
-            .query(async ({ input }) => {
+          where: RoleWhereInputSchema.optional(),
-                return await this.roleService.findManyWithPagination(input);
+          select: RoleSelectSchema.optional(),
-            }),
+        }),
-    });
+      ) // Assuming StaffMethodSchema.findMany is the Zod schema for finding staffs by keyword
+      .query(async ({ input }) => {
+        return await this.roleService.findManyWithPagination(input);
+      }),
+  });
 }

apps/server/src/models/rbac/role.row.service.ts

@@ -1,47 +1,59 @@
-import { db, ObjectType, RowModelRequest, RowRequestSchema, UserProfile } from "@nice/common";
+import {
-import { RowCacheService } from "../base/row-cache.service";
+  db,
-import { isFieldCondition, LogicalCondition } from "../base/sql-builder";
+  ObjectType,
-import { z } from "zod";
+  RowModelRequest,
+  RowRequestSchema,
+  UserProfile,
+} from '@nice/common';
+import { RowCacheService } from '../base/row-cache.service';
+import { isFieldCondition, LogicalCondition } from '../base/sql-builder';
+import { z } from 'zod';
 export class RoleRowService extends RowCacheService {
-    protected createGetRowsFilters(
+  protected createGetRowsFilters(
-        request: z.infer<typeof RowRequestSchema>,
+    request: z.infer<typeof RowRequestSchema>,
-        staff?: UserProfile
+    staff?: UserProfile,
-    ) {
+  ) {
-        const condition = super.createGetRowsFilters(request)
+    const condition = super.createGetRowsFilters(request);
-        if (isFieldCondition(condition))
+    if (isFieldCondition(condition)) return {};
-            return {}
+    const baseModelCondition: LogicalCondition[] = [
-        const baseModelCondition: LogicalCondition[] = [{
+      {
-            field: `${this.tableName}.deleted_at`,
+        field: `${this.tableName}.deleted_at`,
-            op: "blank",
+        op: 'blank',
-            type: "date"
+        type: 'date',
-        }]
+      },
-        condition.AND = [...baseModelCondition, ...condition.AND!]
+    ];
-        return condition
+    condition.AND = [...baseModelCondition, ...condition.AND!];
-    }
+    return condition;
-    createUnGroupingRowSelect(): string[] {
+  }
-        return [
+  createUnGroupingRowSelect(): string[] {
-            `${this.tableName}.id AS id`,
+    return [
-            `${this.tableName}.name AS name`,
+      `${this.tableName}.id AS id`,
-            `${this.tableName}.system AS system`,
+      `${this.tableName}.name AS name`,
-            `${this.tableName}.permissions AS permissions`
+      `${this.tableName}.system AS system`,
-        ];
+      `${this.tableName}.permissions AS permissions`,
-    }
+    ];
-    protected async getRowDto(data: any, staff?: UserProfile): Promise<any> {
+  }
-        if (!data.id)
+  protected async getRowDto(data: any, staff?: UserProfile): Promise<any> {
-            return data
+    if (!data.id) return data;
-        const roleMaps = await db.roleMap.findMany({
+    const roleMaps = await db.roleMap.findMany({
-            where: {
+      where: {
-                roleId: data.id
+        roleId: data.id,
-            }
+      },
-        })
+    });
-        const deptIds = roleMaps.filter(item => item.objectType === ObjectType.DEPARTMENT).map(roleMap => roleMap.objectId)
+    const deptIds = roleMaps
-        const staffIds = roleMaps.filter(item => item.objectType === ObjectType.STAFF).map(roleMap => roleMap.objectId)
+      .filter((item) => item.objectType === ObjectType.DEPARTMENT)
-        const depts = await db.department.findMany({ where: { id: { in: deptIds } } })
+      .map((roleMap) => roleMap.objectId);
-        const staffs = await db.staff.findMany({ where: { id: { in: staffIds } } })
+    const staffIds = roleMaps
-        const result = { ...data, depts, staffs }
+      .filter((item) => item.objectType === ObjectType.STAFF)
-        return result
+      .map((roleMap) => roleMap.objectId);
-    }
+    const depts = await db.department.findMany({
-    createJoinSql(request?: RowModelRequest): string[] {
+      where: { id: { in: deptIds } },
-        return [];
+    });
-    }
+    const staffs = await db.staff.findMany({ where: { id: { in: staffIds } } });
+    const result = { ...data, depts, staffs };
+    return result;
+  }
+  createJoinSql(request?: RowModelRequest): string[] {
+    return [];
+  }
 }

apps/server/src/models/rbac/rolemap.router.ts

@@ -1,9 +1,6 @@
 import { Injectable } from '@nestjs/common';
 import { TrpcService } from '@server/trpc/trpc.service';
-import {
+import { ObjectType, RoleMapMethodSchema } from '@nice/common';
-  ObjectType,
-  RoleMapMethodSchema,
-} from '@nice/common';
 import { RoleMapService } from './rolemap.service';
 
 @Injectable()
@@ -11,7 +8,7 @@ export class RoleMapRouter {
   constructor(
     private readonly trpc: TrpcService,
     private readonly roleMapService: RoleMapService,
-  ) { }
+  ) {}
   router = this.trpc.router({
     deleteAllRolesForObject: this.trpc.protectProcedure
       .input(RoleMapMethodSchema.deleteWithObject)

apps/server/src/models/rbac/rolemap.service.ts

@@ -64,10 +64,7 @@ export class RoleMapService extends RowModelService {
     return condition;
   }
 
-  protected async getRowDto(
+  protected async getRowDto(row: any, staff?: UserProfile): Promise<any> {
-    row: any,
-    staff?: UserProfile,
-  ): Promise<any> {
     if (!row.id) return row;
     return row;
   }
@@ -126,15 +123,17 @@ export class RoleMapService extends RowModelService {
         data: roleMaps,
       });
     });
-    const wrapResult = Promise.all(result.map(async item => {
+    const wrapResult = Promise.all(
-      const staff = await db.staff.findMany({
+      result.map(async (item) => {
-        include: { department: true },
+        const staff = await db.staff.findMany({
-        where: {
+          include: { department: true },
-          id: item.objectId
+          where: {
-        }
+            id: item.objectId,
-      })
+          },
-      return { ...item, staff }
+        });
-    }))
+        return { ...item, staff };
+      }),
+    );
     return wrapResult;
   }
   async addRoleForObjects(
@@ -187,11 +186,11 @@ export class RoleMapService extends RowModelService {
       { objectId: staffId, objectType: ObjectType.STAFF },
       ...(deptId || ancestorDeptIds.length > 0
         ? [
-          {
+            {
-            objectId: { in: [deptId, ...ancestorDeptIds].filter(Boolean) },
+              objectId: { in: [deptId, ...ancestorDeptIds].filter(Boolean) },
-            objectType: ObjectType.DEPARTMENT,
+              objectType: ObjectType.DEPARTMENT,
-          },
+            },
-        ]
+          ]
         : []),
     ];
     // Helper function to fetch roles based on domain ID.
@@ -260,7 +259,9 @@ export class RoleMapService extends RowModelService {
     // const processedItems = await Promise.all(items.map(item => this.genRoleMapDto(item)));
     return { items, totalCount };
   }
-  async getStaffsNotMap(data: z.infer<typeof RoleMapMethodSchema.getStaffsNotMap>) {
+  async getStaffsNotMap(
+    data: z.infer<typeof RoleMapMethodSchema.getStaffsNotMap>,
+  ) {
     const { domainId, roleId } = data;
     let staffs = await db.staff.findMany({
       where: {
@@ -300,7 +301,9 @@ export class RoleMapService extends RowModelService {
    * @param data 包含角色ID和域ID的数据
    * @returns 角色映射详情，包含部门ID和员工ID列表
    */
-  async getRoleMapDetail(data: z.infer<typeof RoleMapMethodSchema.getRoleMapDetail>) {
+  async getRoleMapDetail(
+    data: z.infer<typeof RoleMapMethodSchema.getRoleMapDetail>,
+  ) {
     const { roleId, domainId } = data;
     const res = await db.roleMap.findMany({ where: { roleId, domainId } });
 

apps/server/src/models/resource/processor/BaseProcessor.ts

@@ -1,23 +1,24 @@
-import path, { dirname } from "path";
+import path, { dirname } from 'path';
-import { FileMetadata, VideoMetadata, ResourceProcessor } from "../types";
+import { FileMetadata, VideoMetadata, ResourceProcessor } from '../types';
-import { Resource, ResourceStatus, db } from "@nice/common";
+import { Resource, ResourceStatus, db } from '@nice/common';
-import { Logger } from "@nestjs/common";
+import { Logger } from '@nestjs/common';
 import fs from 'fs/promises';
 
 export abstract class BaseProcessor implements ResourceProcessor {
-    constructor() { }
+  constructor() {}
-    protected logger = new Logger(BaseProcessor.name)
+  protected logger = new Logger(BaseProcessor.name);
 
-    abstract process(resource: Resource): Promise<Resource>
+  abstract process(resource: Resource): Promise<Resource>;
-    protected createOutputDir(filepath: string, subdirectory: string = 'assets'): string {
+  protected createOutputDir(
-        const outputDir = path.join(
+    filepath: string,
-            path.dirname(filepath),
+    subdirectory: string = 'assets',
-            subdirectory,
+  ): string {
-        );
+    const outputDir = path.join(path.dirname(filepath), subdirectory);
-        fs.mkdir(outputDir, { recursive: true }).catch(err => this.logger.error(`Failed to create directory: ${err.message}`));
+    fs.mkdir(outputDir, { recursive: true }).catch((err) =>
+      this.logger.error(`Failed to create directory: ${err.message}`),
+    );
 
-        return outputDir;
+    return outputDir;
-    
+  }
-    }
 }
 //

apps/server/src/models/resource/resource.module.ts

@@ -4,7 +4,7 @@ import { ResourceService } from './resource.service';
 import { TrpcService } from '@server/trpc/trpc.service';
 
 @Module({
-    exports: [ResourceRouter, ResourceService],
+  exports: [ResourceRouter, ResourceService],
-    providers: [ResourceRouter, ResourceService, TrpcService],
+  providers: [ResourceRouter, ResourceService, TrpcService],
 })
-export class ResourceModule { }
+export class ResourceModule {}

apps/server/src/models/resource/types.ts

@@ -1,55 +1,57 @@
-import { Resource } from "@nice/common";
+import { Resource } from '@nice/common';
 
 export interface ResourceProcessor {
-    process(resource: Resource): Promise<any>
+  process(resource: Resource): Promise<any>;
 }
 export interface ProcessResult {
-    success: boolean
+  success: boolean;
-    resource: Resource
+  resource: Resource;
-    error?: Error
+  error?: Error;
 }
 
 export interface BaseMetadata {
-    size: number
+  size: number;
-    filetype: string
+  filetype: string;
-    filename: string
+  filename: string;
-    extension: string
+  extension: string;
-    modifiedAt: Date
+  modifiedAt: Date;
 }
 /**
  * 图片特有元数据接口
  */
 export interface ImageMetadata {
-    width: number;          // 图片宽度(px)
+  width: number; // 图片宽度(px)
-    height: number;         // 图片高度(px)
+  height: number; // 图片高度(px)
-    compressedUrl?: string;
+  compressedUrl?: string;
-    orientation?: number;   // EXIF方向信息
+  orientation?: number; // EXIF方向信息
-    space?: string;    // 色彩空间 (如: RGB, CMYK)
+  space?: string; // 色彩空间 (如: RGB, CMYK)
-    hasAlpha?: boolean;     // 是否包含透明通道
+  hasAlpha?: boolean; // 是否包含透明通道
 }
 
 /**
  * 视频特有元数据接口
  */
 export interface VideoMetadata {
-    width?: number;
+  width?: number;
-    height?: number;
+  height?: number;
-    duration?: number;
+  duration?: number;
-    videoCodec?: string;
+  videoCodec?: string;
-    audioCodec?: string;
+  audioCodec?: string;
-    coverUrl?: string
+  coverUrl?: string;
 }
 
 /**
  * 音频特有元数据接口
  */
 export interface AudioMetadata {
-    duration: number;       // 音频时长(秒)
+  duration: number; // 音频时长(秒)
-    bitrate?: number;       // 比特率(bps)
+  bitrate?: number; // 比特率(bps)
-    sampleRate?: number;    // 采样率(Hz)
+  sampleRate?: number; // 采样率(Hz)
-    channels?: number;      // 声道数
+  channels?: number; // 声道数
-    codec?: string;         // 音频编码格式
+  codec?: string; // 音频编码格式
 }
 
-
+export type FileMetadata = ImageMetadata &
-export type FileMetadata = ImageMetadata & VideoMetadata & AudioMetadata & BaseMetadata
+  VideoMetadata &
+  AudioMetadata &
+  BaseMetadata;

apps/server/src/models/sport-project/sportProject.controller.ts

@@ -1,9 +1,9 @@
-import { Controller, UseGuards } from "@nestjs/common";
+import { Controller, UseGuards } from '@nestjs/common';
 import { AuthGuard } from '@server/auth/auth.guard';
-import { sportProjectService } from "./sportProject.service";
+import { sportProjectService } from './sportProject.service';
 
 @Controller('sportProject')
 export class sportProjectController {
-        constructor(private readonly sportProjectService: sportProjectService) {}
+  constructor(private readonly sportProjectService: sportProjectService) {}
-        //@UseGuards(AuthGuard)
+  //@UseGuards(AuthGuard)
 }

apps/server/src/models/sport-project/sportProject.module.ts

@@ -7,7 +7,7 @@ import { SportProjectRouter } from './sportProject.router';
 @Module({
   imports: [StaffModule],
   controllers: [sportProjectController],
-  providers: [sportProjectService,SportProjectRouter,TrpcService],
+  providers: [sportProjectService, SportProjectRouter, TrpcService],
-  exports: [sportProjectService,SportProjectRouter],
+  exports: [sportProjectService, SportProjectRouter],
 })
 export class SportProjectModule {}

apps/server/src/models/sport-project/sportProject.router.ts

@@ -1,42 +1,49 @@
-import { Injectable } from "@nestjs/common";
+import { Injectable } from '@nestjs/common';
-import { TrpcService } from "@server/trpc/trpc.service";
+import { TrpcService } from '@server/trpc/trpc.service';
-import { sportProjectService } from "./sportProject.service";
+import { sportProjectService } from './sportProject.service';
-import { z, ZodType } from "zod";
+import { z, ZodType } from 'zod';
-import { Prisma } from "@nice/common";
+import { Prisma } from '@nice/common';
 
-const SportProjectArgsSchema:ZodType<Prisma.SportProjectCreateArgs> = z.any()
+const SportProjectArgsSchema: ZodType<Prisma.SportProjectCreateArgs> = z.any();
-const SportProjectUpdateArgsSchema:ZodType<Prisma.SportProjectUpdateArgs> = z.any()
+const SportProjectUpdateArgsSchema: ZodType<Prisma.SportProjectUpdateArgs> =
-const SportProjectFindManyArgsSchema:ZodType<Prisma.SportProjectFindManyArgs> = z.any()
+  z.any();
-const SportProjectFindFirstArgsSchema:ZodType<Prisma.SportProjectFindFirstArgs> = z.any()
+const SportProjectFindManyArgsSchema: ZodType<Prisma.SportProjectFindManyArgs> =
+  z.any();
+const SportProjectFindFirstArgsSchema: ZodType<Prisma.SportProjectFindFirstArgs> =
+  z.any();
 @Injectable()
 export class SportProjectRouter {
-    constructor(
+  constructor(
-        private readonly trpc: TrpcService,
+    private readonly trpc: TrpcService,
-        private readonly sportProjectService: sportProjectService,
+    private readonly sportProjectService: sportProjectService,
-    ) { }
+  ) {}
-
-    router = this.trpc.router({
-        create:this.trpc.procedure.input(SportProjectArgsSchema)
-            .mutation(async ({input})=>{
-                console.log(input)
-                return this.sportProjectService.create(input)
-            }),
-        update:this.trpc.procedure.input(SportProjectUpdateArgsSchema)
-            .mutation(async ({input})=>{
-                return this.sportProjectService.update(input)
-            }),
-        findMany:this.trpc.procedure.input(SportProjectFindManyArgsSchema)
-            .query(async ({input})=>{
-                return this.sportProjectService.findMany(input)
-            }),
-        softDeleteByIds:this.trpc.procedure.input(z.object({ ids: z.array(z.string()) }))
-            .mutation(async ({input})=>{
-                return this.sportProjectService.softDeleteByIds(input.ids)
-            }),
-        findFirst:this.trpc.procedure.input(SportProjectFindFirstArgsSchema)
-            .query(async ({input})=>{
-                return this.sportProjectService.findFirst(input)
-            }),
-    })
 
+  router = this.trpc.router({
+    create: this.trpc.procedure
+      .input(SportProjectArgsSchema)
+      .mutation(async ({ input }) => {
+        console.log(input);
+        return this.sportProjectService.create(input);
+      }),
+    update: this.trpc.procedure
+      .input(SportProjectUpdateArgsSchema)
+      .mutation(async ({ input }) => {
+        return this.sportProjectService.update(input);
+      }),
+    findMany: this.trpc.procedure
+      .input(SportProjectFindManyArgsSchema)
+      .query(async ({ input }) => {
+        return this.sportProjectService.findMany(input);
+      }),
+    softDeleteByIds: this.trpc.procedure
+      .input(z.object({ ids: z.array(z.string()) }))
+      .mutation(async ({ input }) => {
+        return this.sportProjectService.softDeleteByIds(input.ids);
+      }),
+    findFirst: this.trpc.procedure
+      .input(SportProjectFindFirstArgsSchema)
+      .query(async ({ input }) => {
+        return this.sportProjectService.findFirst(input);
+      }),
+  });
 }

apps/server/src/models/sport-project/sportProject.service.ts

@@ -1,59 +1,58 @@
-import { Injectable } from "@nestjs/common";
+import { Injectable } from '@nestjs/common';
-import { BaseService } from "../base/base.service";
+import { BaseService } from '../base/base.service';
-import { db, ObjectType, Prisma, UserProfile } from "@nice/common";
+import { db, ObjectType, Prisma, UserProfile } from '@nice/common';
-import EventBus, { CrudOperation } from "@server/utils/event-bus";
+import EventBus, { CrudOperation } from '@server/utils/event-bus';
-import { DefaultArgs } from "@prisma/client/runtime/library";
+import { DefaultArgs } from '@prisma/client/runtime/library';
 
 interface AgeRange {
-    start: number | null;
+  start: number | null;
-    end: number | null;
+  end: number | null;
-    label: string;
+  label: string;
-  }
+}
 
 interface ScoreStandard {
-    ageRanges: AgeRange[];
+  ageRanges: AgeRange[];
-    scoreTable: {
+  scoreTable: {
-      [score: string]: number[];
+    [score: string]: number[];
-    }
+  };
-  }
+}
 
 @Injectable()
 export class sportProjectService extends BaseService<Prisma.SportProjectDelegate> {
-    constructor() {
+  constructor() {
-        super(db,ObjectType.SPORT_PROJECT,false);
+    super(db, ObjectType.SPORT_PROJECT, false);
-    }
+  }
-    async create(args: Prisma.SportProjectCreateArgs) {
+  async create(args: Prisma.SportProjectCreateArgs) {
-        const result = await super.create(args)
+    const result = await super.create(args);
-        this.emitDataChanged(CrudOperation.CREATED,result)
+    this.emitDataChanged(CrudOperation.CREATED, result);
-        return result    
+    return result;
-    }
+  }
 
-    async update(args:Prisma.SportProjectUpdateArgs){
+  async update(args: Prisma.SportProjectUpdateArgs) {
-        const result = await super.update(args)
+    const result = await super.update(args);
-        this.emitDataChanged(CrudOperation.UPDATED,result)
+    this.emitDataChanged(CrudOperation.UPDATED, result);
-        return result
+    return result;
-    }
+  }
 
+  async findMany(args: Prisma.SportProjectFindManyArgs) {
+    const result = await super.findMany(args);
+    return result;
+  }
+  async findFirst(args: Prisma.SportProjectFindFirstArgs) {
+    const result = await super.findFirst(args);
+    return result;
+  }
+  async softDeleteByIds(ids: string[]) {
+    const result = await super.softDeleteByIds(ids);
+    this.emitDataChanged(CrudOperation.DELETED, result);
+    return result;
+  }
 
-    async findMany(args: Prisma.SportProjectFindManyArgs) {
+  private emitDataChanged(operation: CrudOperation, data: any) {
-        const result = await super.findMany(args);
+    EventBus.emit('dataChanged', {
-        return result;
+      type: ObjectType.SPORT_STANDARD,
-    }
+      operation,
-    async findFirst(args: Prisma.SportProjectFindFirstArgs) {
+      data,
-      const result = await super.findFirst(args)
+    });
-      return result
+  }
-    }
-    async softDeleteByIds(ids: string[]) {
-      const result = await super.softDeleteByIds(ids);
-      this.emitDataChanged(CrudOperation.DELETED,result)
-      return result
-    }
-
-    private emitDataChanged(operation: CrudOperation, data: any) {
-        EventBus.emit('dataChanged', {
-          type:ObjectType.SPORT_STANDARD,
-          operation,
-          data,
-        });
-    }
 }

apps/server/src/models/sport-standard/sportStandard.controller.ts

@@ -1,9 +1,9 @@
-import { Controller, UseGuards } from "@nestjs/common";
+import { Controller, UseGuards } from '@nestjs/common';
 import { AuthGuard } from '@server/auth/auth.guard';
-import { SportStandardService } from "./sportStandard.service";
+import { SportStandardService } from './sportStandard.service';
 
 @Controller('sportStandard')
 export class SportStandardController {
-        constructor(private readonly sportStandardService: SportStandardService) {}
+  constructor(private readonly sportStandardService: SportStandardService) {}
-        //@UseGuards(AuthGuard)
+  //@UseGuards(AuthGuard)
 }

apps/server/src/models/sport-standard/sportStandard.module.ts

@@ -7,7 +7,7 @@ import { SportStandardRouter } from './sportStandard.router';
 @Module({
   imports: [StaffModule],
   controllers: [SportStandardController],
-  providers: [SportStandardService,SportStandardRouter,TrpcService],
+  providers: [SportStandardService, SportStandardRouter, TrpcService],
-  exports: [SportStandardService,SportStandardRouter],
+  exports: [SportStandardService, SportStandardRouter],
 })
 export class SportStandardModule {}

apps/server/src/models/sport-standard/sportStandard.router.ts

@@ -1,78 +1,92 @@
-import { Injectable } from "@nestjs/common";
+import { Injectable } from '@nestjs/common';
-import { TrpcService } from "@server/trpc/trpc.service";
+import { TrpcService } from '@server/trpc/trpc.service';
-import { SportStandardService } from "./sportStandard.service";
+import { SportStandardService } from './sportStandard.service';
-import { z, ZodType } from "zod";
+import { z, ZodType } from 'zod';
-import { Prisma } from "@nice/common";
+import { Prisma } from '@nice/common';
 
-const SportStandardArgsSchema: ZodType<Prisma.SportStandardCreateArgs> = z.any()
+const SportStandardArgsSchema: ZodType<Prisma.SportStandardCreateArgs> =
-const SportStandardUpdateArgsSchema: ZodType<Prisma.SportStandardUpdateArgs> = z.any()
+  z.any();
-const SportStandardFindManyArgsSchema: ZodType<Prisma.SportStandardFindManyArgs> = z.any()
+const SportStandardUpdateArgsSchema: ZodType<Prisma.SportStandardUpdateArgs> =
-const SportStandardCreateStandardArgsSchema: ZodType<Prisma.SportStandardCreateArgs> = z.any()
+  z.any();
-const SportStandardUpdateStandardArgsSchema: ZodType<Prisma.SportStandardUpdateArgs> = z.any()
+const SportStandardFindManyArgsSchema: ZodType<Prisma.SportStandardFindManyArgs> =
+  z.any();
+const SportStandardCreateStandardArgsSchema: ZodType<Prisma.SportStandardCreateArgs> =
+  z.any();
+const SportStandardUpdateStandardArgsSchema: ZodType<Prisma.SportStandardUpdateArgs> =
+  z.any();
 const GetScoreArgsSchema = z.object({
-    projectId: z.string().nonempty(),
+  projectId: z.string().nonempty(),
-    gender: z.boolean(),
+  gender: z.boolean(),
-    age: z.number().min(0),
+  age: z.number().min(0),
-    performance: z.number().min(0).or(z.string()),
+  performance: z.number().min(0).or(z.string()),
-    personType: z.string().nonempty(),
+  personType: z.string().nonempty(),
-    projectUnit: z.string().nonempty()
+  projectUnit: z.string().nonempty(),
 });
 
 interface AgeRange {
-    start: number | null;
+  start: number | null;
-    end: number | null;
+  end: number | null;
-    label: string;
+  label: string;
 }
 interface Record {
-    [key: number]: number[];
+  [key: number]: number[];
 }
 
 @Injectable()
 export class SportStandardRouter {
-    constructor(
+  constructor(
-        private readonly trpc: TrpcService,
+    private readonly trpc: TrpcService,
-        private readonly sportStandardService: SportStandardService,
+    private readonly sportStandardService: SportStandardService,
-    ) { }
+  ) {}
 
-    router = this.trpc.router({
+  router = this.trpc.router({
-        // create:this.trpc.procedure.input(SportStandardArgsSchema)
+    // create:this.trpc.procedure.input(SportStandardArgsSchema)
-        //     .mutation(async ({input})=>{
+    //     .mutation(async ({input})=>{
-        //         return this.sportStandardService.create(input)
+    //         return this.sportStandardService.create(input)
-        //     }),
+    //     }),
-        update: this.trpc.procedure.input(SportStandardUpdateArgsSchema)
+    update: this.trpc.procedure
-            .mutation(async ({ input }) => {
+      .input(SportStandardUpdateArgsSchema)
-                return this.sportStandardService.update(input)
+      .mutation(async ({ input }) => {
-            }),
+        return this.sportStandardService.update(input);
-        findMany: this.trpc.procedure.input(SportStandardFindManyArgsSchema)
+      }),
-            .query(async ({ input }) => {
+    findMany: this.trpc.procedure
-                return this.sportStandardService.findMany(input)
+      .input(SportStandardFindManyArgsSchema)
-            }),
+      .query(async ({ input }) => {
-        createStandard: this.trpc.procedure.input(SportStandardCreateStandardArgsSchema)
+        return this.sportStandardService.findMany(input);
-            .mutation(async ({ input }) => {
+      }),
-                const data = {
+    createStandard: this.trpc.procedure
-                    projectId: input.data.projectId,
+      .input(SportStandardCreateStandardArgsSchema)
-                    gender: input.data.gender,
+      .mutation(async ({ input }) => {
-                    personType: input.data.personType,
+        const data = {
-                    ageRanges: input.data.ageRanges as any as AgeRange[],
+          projectId: input.data.projectId,
-                    scoreTable: input.data.scoreTable as Record
+          gender: input.data.gender,
-                }
+          personType: input.data.personType,
-                return this.sportStandardService.createStandard(data, input.select, input.include)
+          ageRanges: input.data.ageRanges as any as AgeRange[],
-            }),
+          scoreTable: input.data.scoreTable as Record,
-        updateStandard: this.trpc.procedure.input(SportStandardUpdateStandardArgsSchema)
+        };
-            .mutation(async ({ input }) => {
+        return this.sportStandardService.createStandard(
-                const data = {
+          data,
-                    id: input.data.id as string,
+          input.select,
-                    ageRanges: input.data.ageRanges as any as AgeRange[],
+          input.include,
-                    scoreTable: input.data.scoreTable as Record
+        );
-                }
+      }),
-                return this.sportStandardService.updateStandard(data)
+    updateStandard: this.trpc.procedure
-            }),
+      .input(SportStandardUpdateStandardArgsSchema)
-
+      .mutation(async ({ input }) => {
-        getScore: this.trpc.procedure.input(GetScoreArgsSchema).query(async ({ input }) => {
+        const data = {
-            console.log('计算')
+          id: input.data.id as string,
-            console.log(input)
+          ageRanges: input.data.ageRanges as any as AgeRange[],
-            return this.sportStandardService.getScore(input);
+          scoreTable: input.data.scoreTable as Record,
-        }),
+        };
-    })
+        return this.sportStandardService.updateStandard(data);
+      }),
 
+    getScore: this.trpc.procedure
+      .input(GetScoreArgsSchema)
+      .query(async ({ input }) => {
+        console.log('计算');
+        console.log(input);
+        return this.sportStandardService.getScore(input);
+      }),
+  });
 }

apps/server/src/models/sport-standard/sportStandard.service.ts

@@ -1,217 +1,223 @@
-import { Injectable } from "@nestjs/common";
+import { Injectable } from '@nestjs/common';
-import { BaseService } from "../base/base.service";
+import { BaseService } from '../base/base.service';
-import { db, ObjectType, Prisma, UserProfile } from "@nice/common";
+import { db, ObjectType, Prisma, UserProfile } from '@nice/common';
-import EventBus, { CrudOperation } from "@server/utils/event-bus";
+import EventBus, { CrudOperation } from '@server/utils/event-bus';
-import { DefaultArgs } from "@prisma/client/runtime/library";
+import { DefaultArgs } from '@prisma/client/runtime/library';
-import { z } from "zod";
+import { z } from 'zod';
 
 interface AgeRange {
-    start: number | null;
+  start: number | null;
-    end: number | null;
+  end: number | null;
-    label: string;
+  label: string;
 }
 interface Record {
-    [key: number]: (number | string)[];
+  [key: number]: (number | string)[];
 }
 interface ScoreStandard {
-    ageRanges: AgeRange[];
+  ageRanges: AgeRange[];
-    scoreTable: Record;
+  scoreTable: Record;
 }
 
 const GetScoreArgsSchema = z.object({
-    projectId: z.string().nonempty(),
+  projectId: z.string().nonempty(),
-    gender: z.boolean(),
+  gender: z.boolean(),
-    age: z.number().min(0),
+  age: z.number().min(0),
-    performance: z.number().min(0).or(z.string()),
+  performance: z.number().min(0).or(z.string()),
-    personType: z.string().nonempty(),
+  personType: z.string().nonempty(),
-    projectUnit: z.string().nonempty()
+  projectUnit: z.string().nonempty(),
 });
 
 @Injectable()
 export class SportStandardService extends BaseService<Prisma.SportStandardDelegate> {
-    constructor() {
+  constructor() {
-        super(db, ObjectType.SPORT_STANDARD, false);
+    super(db, ObjectType.SPORT_STANDARD, false);
+  }
+  async create(args: Prisma.SportStandardCreateArgs) {
+    console.log(args);
+    const result = await super.create(args);
+    this.emitDataChanged(CrudOperation.CREATED, result);
+    return result;
+  }
+
+  async update(args: Prisma.SportStandardUpdateArgs) {
+    const result = await super.update(args);
+    this.emitDataChanged(CrudOperation.UPDATED, result);
+    return result;
+  }
+
+  async findMany(args: Prisma.SportStandardFindManyArgs) {
+    const result = await super.findMany(args);
+    return result;
+  }
+  async findUnique(args: Prisma.SportStandardFindUniqueArgs) {
+    const result = await super.findUnique(args);
+    return result;
+  }
+
+  private emitDataChanged(operation: CrudOperation, data: any) {
+    EventBus.emit('dataChanged', {
+      type: ObjectType.SPORT_STANDARD,
+      operation,
+      data,
+    });
+  }
+
+  async createStandard(
+    data: {
+      projectId: string;
+      gender: boolean;
+      personType: string;
+      ageRanges: AgeRange[];
+      scoreTable: Record;
+    },
+    select?: Prisma.SportStandardSelect<DefaultArgs>,
+    include?: Prisma.SportStandardInclude<DefaultArgs>,
+  ) {
+    console.log(data);
+    this.validateAgeRanges(data.ageRanges);
+    this.validateScoreTable(data.scoreTable, data.ageRanges.length);
+    const result = await super.create({
+      data: {
+        projectId: data.projectId,
+        gender: data.gender,
+        personType: data.personType,
+        ageRanges: JSON.stringify(data.ageRanges),
+        scoreTable: JSON.stringify(data.scoreTable),
+      },
+      select,
+      include,
+    });
+    this.emitDataChanged(CrudOperation.CREATED, result);
+    return result;
+  }
+  private validateAgeRanges(ranges: AgeRange[]) {
+    // 检查年龄段是否按顺序排列且无重叠
+    for (let i = 0; i < ranges.length - 1; i++) {
+      const current = ranges[i];
+      const next = ranges[i + 1];
+
+      if (current.end !== next.start) {
+        throw new Error('年龄段必须连续且不重叠');
+      }
     }
-    async create(args: Prisma.SportStandardCreateArgs) {
+  }
-        console.log(args)
+
-        const result = await super.create(args)
+  private validateScoreTable(scoreTable: Record, expectedLength: number) {
-        this.emitDataChanged(CrudOperation.CREATED, result)
+    Object.values(scoreTable).forEach((standards) => {
-        return result
+      if (standards.length !== expectedLength) {
+        throw new Error('分数表的每行数据长度必须与年龄段数量匹配');
+      }
+    });
+  }
+
+  async updateStandard(data: {
+    id: string;
+    ageRanges: AgeRange[];
+    scoreTable: Record;
+  }) {
+    this.validateAgeRanges(data.ageRanges);
+    this.validateScoreTable(data.scoreTable, data.ageRanges.length);
+    const result = await super.update({
+      where: {
+        id: data.id,
+      },
+      data: {
+        ageRanges: JSON.stringify(data.ageRanges),
+        scoreTable: JSON.stringify(data.scoreTable),
+      },
+    });
+    this.emitDataChanged(CrudOperation.UPDATED, result);
+    return result;
+  }
+
+  public SportScoreCalculator(
+    performance: number | string,
+    age: number,
+    scoreStandard: ScoreStandard,
+    projectUnit: string,
+  ): number {
+    // 1. 找到对应的年龄段索引
+    const ageRangeIndex = scoreStandard.ageRanges.findIndex((range) => {
+      const isAboveStart = range.start === null || age > range.start;
+      const isBelowEnd = range.end === null || age <= range.end;
+      return isAboveStart && isBelowEnd;
+    });
+
+    if (ageRangeIndex === -1) {
+      throw new Error('未找到匹配的年龄段');
     }
 
-    async update(args: Prisma.SportStandardUpdateArgs) {
+    // 2. 查找对应分数
-        const result = await super.update(args)
+    const scores = Object.keys(scoreStandard.scoreTable)
-        this.emitDataChanged(CrudOperation.UPDATED, result)
+      .map(Number)
-        return result
+      .sort((a, b) => b - a);
+
+    const isTimeUnit = projectUnit.includes('time'); // 假设时间单位包含 '时间单位' 字符串
+
+    for (const score of scores) {
+      const standard =
+        scoreStandard.scoreTable[score.toString()][ageRangeIndex];
+      if (isTimeUnit) {
+        // 此时的performance和standard是时间字符串
+        // 需要将时间字符串转换为秒
+        if (
+          this.timeStringToSeconds(performance) <=
+          this.timeStringToSeconds(standard)
+        ) {
+          return score;
+        }
+      } else {
+        if (performance >= standard) {
+          return score;
+        }
+      }
     }
 
+    return 0;
+  }
 
-    async findMany(args: Prisma.SportStandardFindManyArgs) {
+  async getScore(data: z.infer<typeof GetScoreArgsSchema>) {
-        const result = await super.findMany(args);
+    console.log('传入的参数', data);
-        return result;
+    const standard = await this.findUnique({
-    }
+      where: {
-    async findUnique(args: Prisma.SportStandardFindUniqueArgs) {
+        projectId_gender_personType: {
-        const result = await super.findUnique(args)
+          // 使用复合唯一索引
-        return result
+          projectId: data.projectId,
-    }
+          gender: data.gender,
-
+          personType: data.personType,
-    private emitDataChanged(operation: CrudOperation, data: any) {
-        EventBus.emit('dataChanged', {
-            type: ObjectType.SPORT_STANDARD,
-            operation,
-            data,
-        });
-    }
-
-    async createStandard(
-        data: {
-            projectId: string;
-            gender: boolean;
-            personType: string;
-            ageRanges: AgeRange[];
-            scoreTable: Record;
         },
-        select?: Prisma.SportStandardSelect<DefaultArgs>,
+      },
-        include?: Prisma.SportStandardInclude<DefaultArgs>
+    });
-    ) {
+    console.log('找到的评分标准', standard);
-        console.log(data)
+    if (!standard) {
-        this.validateAgeRanges(data.ageRanges);
+      throw new Error('未找到对应的评分标准');
-        this.validateScoreTable(data.scoreTable, data.ageRanges.length);
-        const result = await super.create({
-            data: {
-                projectId: data.projectId,
-                gender: data.gender,
-                personType: data.personType,
-                ageRanges: JSON.stringify(data.ageRanges),
-                scoreTable: JSON.stringify(data.scoreTable)
-            },
-            select,
-            include
-        })
-        this.emitDataChanged(CrudOperation.CREATED, result)
-        return result
     }
-    private validateAgeRanges(ranges: AgeRange[]) {
+    const scoreTable: Record = JSON.parse(String(standard.scoreTable));
-        // 检查年龄段是否按顺序排列且无重叠
+    const ageRanges: AgeRange[] = JSON.parse(String(standard.ageRanges));
-        for (let i = 0; i < ranges.length - 1; i++) {
+    const scoreStandard: ScoreStandard = {
-            const current = ranges[i];
+      ageRanges,
-            const next = ranges[i + 1];
+      scoreTable,
+    };
+    console.log('评分标准', scoreStandard);
+    return this.SportScoreCalculator(
+      data.performance,
+      data.age,
+      scoreStandard,
+      data.projectUnit,
+    );
+  }
+  // 将 13:45 格式的字符串转换为秒数
+  private timeStringToSeconds(timeStr) {
+    const [minutes, seconds] = timeStr.split(':').map(Number);
+    return minutes * 60 + seconds;
+  }
 
-            if (current.end !== next.start) {
+  // 将秒数转换为 13:45 格式的字符串
-                throw new Error('年龄段必须连续且不重叠');
+  private secondsToTimeString(seconds: number) {
-            }
+    const minutesPart = Math.floor(seconds / 60);
-        }
+    const secondsPart = seconds % 60;
-    }
+    return `${String(minutesPart).padStart(2, '0')}:${String(
-
+      secondsPart,
-    private validateScoreTable(
+    ).padStart(2, '0')}`;
-        scoreTable: Record,
+  }
-        expectedLength: number
-    ) {
-        Object.values(scoreTable).forEach(standards => {
-            if (standards.length !== expectedLength) {
-                throw new Error('分数表的每行数据长度必须与年龄段数量匹配');
-            }
-        });
-    }
-
-    async updateStandard(
-        data: {
-            id: string;
-            ageRanges: AgeRange[];
-            scoreTable: Record;
-        }
-    ) {
-        this.validateAgeRanges(data.ageRanges);
-        this.validateScoreTable(data.scoreTable, data.ageRanges.length);
-        const result = await super.update({
-            where: {
-                id: data.id
-            },
-            data: {
-                ageRanges: JSON.stringify(data.ageRanges),
-                scoreTable: JSON.stringify(data.scoreTable)
-            }
-        })
-        this.emitDataChanged(CrudOperation.UPDATED, result)
-        return result
-    }
-
-    public SportScoreCalculator(performance: number | string, age: number, scoreStandard: ScoreStandard, projectUnit: string, ): number {
-        // 1. 找到对应的年龄段索引
-        const ageRangeIndex = scoreStandard.ageRanges.findIndex(range => {
-            const isAboveStart = range.start === null || age > range.start;
-            const isBelowEnd = range.end === null || age <= range.end;
-            return isAboveStart && isBelowEnd;
-        });
-
-        if (ageRangeIndex === -1) {
-            throw new Error('未找到匹配的年龄段');
-        }
-
-        // 2. 查找对应分数
-        const scores = Object.keys(scoreStandard.scoreTable)
-            .map(Number)
-            .sort((a, b) => b - a);
-
-        const isTimeUnit = projectUnit.includes('time'); // 假设时间单位包含 '时间单位' 字符串
-
-        for (const score of scores) {
-            const standard = scoreStandard.scoreTable[score.toString()][ageRangeIndex];
-            if (isTimeUnit) {
-                // 此时的performance和standard是时间字符串
-                // 需要将时间字符串转换为秒
-                if (this.timeStringToSeconds(performance) <= this.timeStringToSeconds(standard)) {
-                    return score;
-                }
-            } else {
-                if (performance >= standard) {
-                    return score;
-                }
-            }
-        }
-
-        return 0;
-    }
-
-    async getScore(data: z.infer<typeof GetScoreArgsSchema>) {
-        console.log("传入的参数",data)
-        const standard = await this.findUnique({
-            where: {
-                projectId_gender_personType: { // 使用复合唯一索引
-                    projectId: data.projectId,
-                    gender: data.gender,
-                    personType: data.personType
-                }
-            }
-        })
-        console.log("找到的评分标准",standard)
-        if (!standard) {
-            throw new Error('未找到对应的评分标准');
-        }
-        const scoreTable:Record = JSON.parse(String(standard.scoreTable))
-        const ageRanges:AgeRange[] = JSON.parse(String(standard.ageRanges))
-        const scoreStandard:ScoreStandard = {
-            ageRanges,
-            scoreTable
-        }
-        console.log("评分标准",scoreStandard)
-        return this.SportScoreCalculator(
-            data.performance,
-            data.age,
-            scoreStandard,
-            data.projectUnit,
-        )
-    }
-    // 将 13:45 格式的字符串转换为秒数
-    private timeStringToSeconds(timeStr) {
-        const [minutes, seconds] = timeStr.split(':').map(Number);
-        return minutes * 60 + seconds;
-    }
-
-    // 将秒数转换为 13:45 格式的字符串
-    private secondsToTimeString(seconds: number) {
-        const minutesPart = Math.floor(seconds / 60);
-        const secondsPart = seconds % 60;
-        return `${String(minutesPart).padStart(2, '0')}:${String(secondsPart).padStart(2, '0')}`;
-    }
 }

apps/server/src/models/staff/staff.module.ts

@@ -12,4 +12,4 @@ import { StaffRowService } from './staff.row.service';
   exports: [StaffService, StaffRouter, StaffRowService],
   controllers: [StaffController],
 })
-export class StaffModule { }
+export class StaffModule {}

apps/server/src/models/staff/staff.router.ts

@@ -95,7 +95,7 @@ export class StaffRouter {
       .query(async ({ input }) => {
         return await this.staffService.findUnique(input);
       }),
-    findSportStaffByDept:this.trpc.procedure
+    findSportStaffByDept: this.trpc.procedure
       .input(StaffMethodSchema.findSportStaffByDept)
       .query(async ({ input }) => {
         return await this.staffService.findSportStaffByDept(input);

apps/server/src/models/staff/staff.service.ts

@@ -37,8 +37,8 @@ const StaffSelect = {
       type: true,
       categorize: true,
       createdAt: true,
-      updatedAt: true
+      updatedAt: true,
-    }
+    },
   },
   // 获取关联的 TrainSituation 模型的基础信息
   trainSituations: {
@@ -47,7 +47,7 @@ const StaffSelect = {
       score: true,
       value: true,
       alreadyTrainTime: true,
-      groupId:true,
+      groupId: true,
       // 获取关联的 TrainContent 模型的基础信息
       trainContent: {
         select: {
@@ -57,18 +57,18 @@ const StaffSelect = {
           parentId: true,
           deletedAt: true,
           createdAt: true,
-          updatedAt: true
+          updatedAt: true,
-        }
+        },
-      }
+      },
-    }
+    },
   },
-  department:{
+  department: {
-    select:{
+    select: {
-      id:true,
+      id: true,
       name: true,
-    }
+    },
-  }
+  },
-}
+};
 
 @Injectable()
 export class StaffService extends BaseService<Prisma.StaffDelegate> {
@@ -176,30 +176,35 @@ export class StaffService extends BaseService<Prisma.StaffDelegate> {
       return staff;
     }
   }
-  async findSportStaffByDept(data: z.infer<typeof StaffMethodSchema.findSportStaffByDept>) {
+  async findSportStaffByDept(
+    data: z.infer<typeof StaffMethodSchema.findSportStaffByDept>,
+  ) {
     const { deptId, domainId } = data;
     let queryResult;
 
     if (!deptId) {
       // deptId 为空时执行 res 的请求
       queryResult = await db.staff.findMany({
-        select: StaffSelect
+        select: StaffSelect,
       });
     } else {
       // deptId 不为空时执行 result 的请求
-      const childDepts = await this.departmentService.getDescendantIds(deptId, true);
+      const childDepts = await this.departmentService.getDescendantIds(
+        deptId,
+        true,
+      );
       queryResult = await db.staff.findMany({
         where: {
           deptId: { in: childDepts },
           domainId,
         },
-        select: StaffSelect
+        select: StaffSelect,
       });
     }
 
     // 筛选出 trainSituations 中 trainContent 的 type 为 'SPORT' 的记录
-    const filteredResult = queryResult.filter(staff => {
+    const filteredResult = queryResult.filter((staff) => {
-      return staff.trainSituations.some(trainSituation => {
+      return staff.trainSituations.some((trainSituation) => {
         return trainSituation.trainContent.type === 'SPORT';
       });
     });

apps/server/src/models/taxonomy/taxonomy.router.ts

@@ -8,7 +8,7 @@ export class TaxonomyRouter {
   constructor(
     private readonly trpc: TrpcService,
     private readonly taxonomyService: TaxonomyService,
-  ) { }
+  ) {}
 
   router = this.trpc.router({
     create: this.trpc.procedure

apps/server/src/models/term/term.module.ts

@@ -13,4 +13,4 @@ import { TermRowService } from './term.row.service';
   exports: [TermService, TermRouter],
   controllers: [TermController],
 })
-export class TermModule { }
+export class TermModule {}

apps/server/src/models/train-content/trainContent.controller.ts

@@ -1,9 +1,9 @@
-import { Controller, UseGuards } from "@nestjs/common";
+import { Controller, UseGuards } from '@nestjs/common';
-import { TrainContentService } from "./trainContent.service";
+import { TrainContentService } from './trainContent.service';
 import { AuthGuard } from '@server/auth/auth.guard';
 
 @Controller('train-content')
 export class TrainContentController {
-    constructor(private readonly trainContentService: TrainContentService) {}
+  constructor(private readonly trainContentService: TrainContentService) {}
-    //@UseGuards(AuthGuard)
+  //@UseGuards(AuthGuard)
 }

apps/server/src/models/train-content/trainContent.module.ts

@@ -5,11 +5,10 @@ import { TrainContentController } from './trainContent.controller';
 import { TrainContentRouter } from './trainContent.router';
 import { TrpcService } from '@server/trpc/trpc.service';
 
-
 @Module({
   imports: [StaffModule],
   controllers: [TrainContentController],
-  providers: [TrainContentService,TrainContentRouter,TrpcService],
+  providers: [TrainContentService, TrainContentRouter, TrpcService],
-  exports: [TrainContentService,TrainContentRouter],
+  exports: [TrainContentService, TrainContentRouter],
 })
 export class TrainContentModule {}

apps/server/src/models/train-content/trainContent.router.ts

@@ -1,37 +1,43 @@
-import { Injectable } from "@nestjs/common";
+import { Injectable } from '@nestjs/common';
-import { TrpcService } from "@server/trpc/trpc.service";
+import { TrpcService } from '@server/trpc/trpc.service';
-import { TrainContentService } from "./trainContent.service";
+import { TrainContentService } from './trainContent.service';
-import { z, ZodType } from "zod";
+import { z, ZodType } from 'zod';
-import { Prisma } from "@nice/common";
+import { Prisma } from '@nice/common';
 
-const TrainContentArgsSchema:ZodType<Prisma.TrainContentCreateArgs> = z.any()
+const TrainContentArgsSchema: ZodType<Prisma.TrainContentCreateArgs> = z.any();
-const TrainContentUpdateArgsSchema:ZodType<Prisma.TrainContentUpdateArgs> = z.any()
+const TrainContentUpdateArgsSchema: ZodType<Prisma.TrainContentUpdateArgs> =
-const TrainContentFindManyArgsSchema:ZodType<Prisma.TrainContentFindManyArgs> = z.any()
+  z.any();
-const TrainContentFindFirstArgsSchema:ZodType<Prisma.TrainContentFindFirstArgs> = z.any()
+const TrainContentFindManyArgsSchema: ZodType<Prisma.TrainContentFindManyArgs> =
+  z.any();
+const TrainContentFindFirstArgsSchema: ZodType<Prisma.TrainContentFindFirstArgs> =
+  z.any();
 @Injectable()
 export class TrainContentRouter {
-    constructor(
+  constructor(
-        private readonly trpc: TrpcService,
+    private readonly trpc: TrpcService,
-        private readonly trainContentService: TrainContentService,
+    private readonly trainContentService: TrainContentService,
-    ) { }
+  ) {}
-
-    router = this.trpc.router({
-        create:this.trpc.procedure.input(TrainContentArgsSchema)
-            .mutation(async ({input})=>{
-                return this.trainContentService.create(input)
-            }),
-        update:this.trpc.procedure.input(TrainContentUpdateArgsSchema)
-            .mutation(async ({input})=>{
-                return this.trainContentService.update(input)
-            }),
-        findMany:this.trpc.procedure.input(TrainContentFindManyArgsSchema)
-            .query(async ({input})=>{
-                return this.trainContentService.findMany(input)
-            }),
-        findFirst:this.trpc.procedure.input(TrainContentFindFirstArgsSchema)
-            .query(async ({input})=>{
-                return this.trainContentService.findFirst(input)
-            }),
-    })
 
+  router = this.trpc.router({
+    create: this.trpc.procedure
+      .input(TrainContentArgsSchema)
+      .mutation(async ({ input }) => {
+        return this.trainContentService.create(input);
+      }),
+    update: this.trpc.procedure
+      .input(TrainContentUpdateArgsSchema)
+      .mutation(async ({ input }) => {
+        return this.trainContentService.update(input);
+      }),
+    findMany: this.trpc.procedure
+      .input(TrainContentFindManyArgsSchema)
+      .query(async ({ input }) => {
+        return this.trainContentService.findMany(input);
+      }),
+    findFirst: this.trpc.procedure
+      .input(TrainContentFindFirstArgsSchema)
+      .query(async ({ input }) => {
+        return this.trainContentService.findFirst(input);
+      }),
+  });
 }

apps/server/src/models/train-content/trainContent.service.ts

@@ -1,43 +1,41 @@
-import { Injectable } from "@nestjs/common";
+import { Injectable } from '@nestjs/common';
-import { BaseService } from "../base/base.service";
+import { BaseService } from '../base/base.service';
-import { db, ObjectType, Prisma, UserProfile } from "@nice/common";
+import { db, ObjectType, Prisma, UserProfile } from '@nice/common';
-import { DefaultArgs } from "@prisma/client/runtime/library";
+import { DefaultArgs } from '@prisma/client/runtime/library';
-import EventBus, { CrudOperation } from "@server/utils/event-bus";
+import EventBus, { CrudOperation } from '@server/utils/event-bus';
-
 
 @Injectable()
 export class TrainContentService extends BaseService<Prisma.TrainContentDelegate> {
-    constructor() {
+  constructor() {
-        super(db,ObjectType.TRAIN_CONTENT,true);
+    super(db, ObjectType.TRAIN_CONTENT, true);
-    }
+  }
-    async create(args: Prisma.TrainContentCreateArgs) {
+  async create(args: Prisma.TrainContentCreateArgs) {
-        console.log(args)
+    console.log(args);
-        const result = await super.create(args)
+    const result = await super.create(args);
-        this.emitDataChanged(CrudOperation.CREATED,result)
+    this.emitDataChanged(CrudOperation.CREATED, result);
-        return result    
+    return result;
-    }
+  }
 
-    async update(args:Prisma.TrainContentUpdateArgs){
+  async update(args: Prisma.TrainContentUpdateArgs) {
-        const result = await super.update(args)
+    const result = await super.update(args);
-        this.emitDataChanged(CrudOperation.UPDATED,result)
+    this.emitDataChanged(CrudOperation.UPDATED, result);
-        return result
+    return result;
-    }
+  }
 
+  async findMany(args: Prisma.TrainContentFindManyArgs) {
+    const result = await super.findMany(args);
+    return result;
+  }
+  async findFirst(args: Prisma.TrainContentFindFirstArgs) {
+    const result = await super.findFirst(args);
+    return result;
+  }
 
-    async findMany(args: Prisma.TrainContentFindManyArgs) {
+  private emitDataChanged(operation: CrudOperation, data: any) {
-        const result = await super.findMany(args);
+    EventBus.emit('dataChanged', {
-        return result;
+      type: ObjectType.TRAIN_SITUATION,
-    }
+      operation,
-    async findFirst(args: Prisma.TrainContentFindFirstArgs) {
+      data,
-        const result = await super.findFirst(args)
+    });
-        return result
+  }
-    }
-
-    private emitDataChanged(operation: CrudOperation, data: any) {
-        EventBus.emit('dataChanged', {
-          type:ObjectType.TRAIN_SITUATION,
-          operation,
-          data,
-        });
-    }
 }

apps/server/src/models/train-situation/trainSituation.controller.ts

@@ -1,9 +1,9 @@
-import { Controller, UseGuards } from "@nestjs/common";
+import { Controller, UseGuards } from '@nestjs/common';
-import { TrainSituationService } from "./trainSituation.service";
+import { TrainSituationService } from './trainSituation.service';
 import { AuthGuard } from '@server/auth/auth.guard';
 
 @Controller('train-situation')
 export class TrainSituationController {
-    constructor(private readonly trainContentService: TrainSituationService) {}
+  constructor(private readonly trainContentService: TrainSituationService) {}
-    //@UseGuards(AuthGuard)
+  //@UseGuards(AuthGuard)
 }

apps/server/src/models/train-situation/trainSituation.module.ts

@@ -6,9 +6,9 @@ import { TrainSituationRouter } from './trainSituation.router';
 import { TrpcService } from '@server/trpc/trpc.service';
 import { SportStandardModule } from '../sport-standard/sportStandard.module';
 @Module({
-  imports: [StaffModule,SportStandardModule],
+  imports: [StaffModule, SportStandardModule],
   controllers: [TrainSituationController],
-  providers: [TrainSituationService,TrainSituationRouter,TrpcService],
+  providers: [TrainSituationService, TrainSituationRouter, TrpcService],
-  exports: [TrainSituationService,TrainSituationRouter],
+  exports: [TrainSituationService, TrainSituationRouter],
 })
 export class TrainSituationModule {}

apps/server/src/models/train-situation/trainSituation.router.ts

@@ -1,71 +1,79 @@
-import { Injectable } from "@nestjs/common";
+import { Injectable } from '@nestjs/common';
-import { TrpcService } from "@server/trpc/trpc.service";
+import { TrpcService } from '@server/trpc/trpc.service';
-import { TrainSituationService } from "./trainSituation.service";
+import { TrainSituationService } from './trainSituation.service';
-import { z, ZodType } from "zod";
+import { z, ZodType } from 'zod';
-import { Prisma } from "@nice/common";
+import { Prisma } from '@nice/common';
 
-const TrainSituationArgsSchema: ZodType<Prisma.TrainSituationCreateArgs> = z.any()
+const TrainSituationArgsSchema: ZodType<Prisma.TrainSituationCreateArgs> =
-const TrainSituationUpdateArgsSchema: ZodType<Prisma.TrainSituationUpdateArgs> = z.any()
+  z.any();
-const TrainSituationFindManyArgsSchema: ZodType<Prisma.TrainSituationFindManyArgs> = z.any()
+const TrainSituationUpdateArgsSchema: ZodType<Prisma.TrainSituationUpdateArgs> =
+  z.any();
+const TrainSituationFindManyArgsSchema: ZodType<Prisma.TrainSituationFindManyArgs> =
+  z.any();
 
 @Injectable()
 export class TrainSituationRouter {
-    constructor(
+  constructor(
-        private readonly trpc: TrpcService,
+    private readonly trpc: TrpcService,
-        private readonly trainSituationService: TrainSituationService,
+    private readonly trainSituationService: TrainSituationService,
-    ) { }
+  ) {}
-    router = this.trpc.router({
+  router = this.trpc.router({
-        create: this.trpc.protectProcedure
+    create: this.trpc.protectProcedure
-            .input(TrainSituationArgsSchema)
+      .input(TrainSituationArgsSchema)
-            .mutation(async ({ input }) => {
+      .mutation(async ({ input }) => {
-                return this.trainSituationService.create(input)
+        return this.trainSituationService.create(input);
-            }),
+      }),
-        update: this.trpc.protectProcedure
+    update: this.trpc.protectProcedure
-            .input(TrainSituationUpdateArgsSchema)
+      .input(TrainSituationUpdateArgsSchema)
-            .mutation(async ({ input }) => {
+      .mutation(async ({ input }) => {
-                return this.trainSituationService.update(input)
+        return this.trainSituationService.update(input);
-            }),
+      }),
-        findMany: this.trpc.protectProcedure
+    findMany: this.trpc.protectProcedure
-            .input(TrainSituationFindManyArgsSchema)
+      .input(TrainSituationFindManyArgsSchema)
-            .query(async ({ input }) => {
+      .query(async ({ input }) => {
-                return this.trainSituationService.findMany(input)
+        return this.trainSituationService.findMany(input);
-            }),
+      }),
-        findManyByDepId: this.trpc.protectProcedure
+    findManyByDepId: this.trpc.protectProcedure
-            .input(z.object({
+      .input(
-                deptId: z.string().optional(),
+        z.object({
-                domainId: z.string().optional(),
+          deptId: z.string().optional(),
-                trainContentId: z.string().optional()
+          domainId: z.string().optional(),
-            }))
+          trainContentId: z.string().optional(),
-            .query(async ({ input }) => {
+        }),
-                return this.trainSituationService.findManyByDeptId(input)
+      )
-            }),
+      .query(async ({ input }) => {
-        createManyTrainSituation: this.trpc.protectProcedure
+        return this.trainSituationService.findManyByDeptId(input);
-            .input(z.array(
+      }),
-                z.object({
+    createManyTrainSituation: this.trpc.protectProcedure
-                    staffId: z.string(),
+      .input(
-                    trainContentId: z.string(),
+        z.array(
-                    mustTrainTime: z.number(),
+          z.object({
-                    alreadyTrainTime: z.number(),
+            staffId: z.string(),
-                    value: z.string(),
+            trainContentId: z.string(),
-                    projectUnit: z.string(),
+            mustTrainTime: z.number(),
-                    personType: z.string(),
+            alreadyTrainTime: z.number(),
-                    projectId: z.string(),
+            value: z.string(),
-                    gender: z.boolean(),
+            projectUnit: z.string(),
-                    age: z.number(),
+            personType: z.string(),
-                    performance: z.number().or(z.string())
+            projectId: z.string(),
-                })
+            gender: z.boolean(),
-            ))
+            age: z.number(),
-            .mutation(async ({ input }) => {
+            performance: z.number().or(z.string()),
-                console.log(input)
+          }),
-                return this.trainSituationService.createManyTrainSituation(input)
+        ),
-            }),
+      )
-        deleteSameGroupTrainSituation:this.trpc.protectProcedure
+      .mutation(async ({ input }) => {
-            .input(z.object({
+        console.log(input);
-                groupId:z.string()
+        return this.trainSituationService.createManyTrainSituation(input);
-            }))
+      }),
-            .mutation(async ({input})=>{
+    deleteSameGroupTrainSituation: this.trpc.protectProcedure
-                return this.trainSituationService.deleteSameGroupTrainSituation(input)
+      .input(
-            })
+        z.object({
-    })
+          groupId: z.string(),
-
+        }),
+      )
+      .mutation(async ({ input }) => {
+        return this.trainSituationService.deleteSameGroupTrainSituation(input);
+      }),
+  });
 }

apps/server/src/models/train-situation/trainSituation.service.ts

@@ -1,145 +1,151 @@
-import { Injectable } from "@nestjs/common";
+import { Injectable } from '@nestjs/common';
-import { BaseService } from "../base/base.service";
+import { BaseService } from '../base/base.service';
-import { db, ObjectType, Prisma, UserProfile } from "@nice/common";
+import { db, ObjectType, Prisma, UserProfile } from '@nice/common';
-import EventBus, { CrudOperation } from "@server/utils/event-bus";
+import EventBus, { CrudOperation } from '@server/utils/event-bus';
-import { DefaultArgs } from "@prisma/client/runtime/library";
+import { DefaultArgs } from '@prisma/client/runtime/library';
-import { StaffService } from "../staff/staff.service";
+import { StaffService } from '../staff/staff.service';
-import { SportStandardService } from "../sport-standard/sportStandard.service";
+import { SportStandardService } from '../sport-standard/sportStandard.service';
-import { uuidv4 } from "lib0/random";
+import { uuidv4 } from 'lib0/random';
-
 
 @Injectable()
 export class TrainSituationService extends BaseService<Prisma.TrainSituationDelegate> {
-    constructor(private readonly staffService:StaffService,private readonly sportStandardService:SportStandardService) {
+  constructor(
-        super(db,ObjectType.TRAIN_SITUATION,false);
+    private readonly staffService: StaffService,
-    }
+    private readonly sportStandardService: SportStandardService,
-    // 创建培训情况
+  ) {
-    async create(
+    super(db, ObjectType.TRAIN_SITUATION, false);
-        args: Prisma.TrainSituationCreateArgs,
+  }
-    ){
+  // 创建培训情况
-        console.log(args)
+  async create(args: Prisma.TrainSituationCreateArgs) {
-        const result = await super.create(args);
+    console.log(args);
-        this.emitDataChanged(CrudOperation.CREATED, result);
+    const result = await super.create(args);
-        return result;
+    this.emitDataChanged(CrudOperation.CREATED, result);
-    }
+    return result;
-    // 更新培训情况
+  }
-    async update(
+  // 更新培训情况
-        args: Prisma.TrainSituationUpdateArgs,
+  async update(args: Prisma.TrainSituationUpdateArgs) {
-    ){
+    const result = await super.update(args);
-        const result = await super.update(args);
+    this.emitDataChanged(CrudOperation.UPDATED, result);
-        this.emitDataChanged(CrudOperation.UPDATED, result);
+    return result;
-        return result;
+  }
-    }
 
-    // 查找培训情况
+  // 查找培训情况
-    async findMany(args: Prisma.TrainSituationFindManyArgs)
+  async findMany(args: Prisma.TrainSituationFindManyArgs) {
+    const result = await super.findMany(args);
+    return result;
+  }
+  // 查找某一单位所有人员的培训情况
+  async findManyByDeptId(args: {
+    deptId?: string;
+    domainId?: string;
+    trainContentId?: string;
+  }): Promise<
     {
-        const result = await super.findMany(args);
+      id: string;
-        return result;
+      staffId: string;
-    }
+      trainContentId: string;
-    // 查找某一单位所有人员的培训情况
+      mustTrainTime: number;
-    async findManyByDeptId(args:{
+      alreadyTrainTime: number;
-        deptId?:string,
+      score: number;
-        domainId?:string,
+    }[]
-        trainContentId?:string
+  > {
-    }):Promise<{
+    const staffs = await this.staffService.findByDept({
-        id: string; 
+      deptId: args.deptId,
-        staffId: string; 
+      domainId: args.domainId,
-        trainContentId: string; 
+    });
-        mustTrainTime: number; 
+    const result = await super.findMany({
-        alreadyTrainTime: number;
+      where: {
-        score: number;
+        staffId: {
-    }[]>
+          in: staffs.map((staff) => staff.id),
-    {
+        },
-       const staffs = await this.staffService.findByDept({deptId:args.deptId,domainId:args.domainId})
+        ...(args.trainContentId ? { trainContentId: args.trainContentId } : {}),
-       const result = await super.findMany({
+      },
-        where:{
+    });
-            staffId:{
+    return result;
-                in:staffs.map(staff=>staff.id)
+  }
-            },
+  //async createDailyTrainTime()
-            ...(args.trainContentId ? {trainContentId:args.trainContentId} : {})
+  async createTrainSituation(
-        }
+    args: {
-       })
+      staffId?: string;
-       return result
+      trainContentId?: string;
-    }
+      mustTrainTime?: number;
-    //async createDailyTrainTime()
+      alreadyTrainTime?: number;
-    async createTrainSituation(args:{
+      value?: string;
-        staffId?:string,
-        trainContentId?:string,
-        mustTrainTime?:number,
-        alreadyTrainTime?:number,
-        value?:string,
 
-        projectUnit?:string,
+      projectUnit?: string;
-        personType?:string,
+      personType?: string;
-        projectId?:string,
+      projectId?: string;
-        gender?:boolean,
+      gender?: boolean;
-        age?:number,
+      age?: number;
-        performance?:number|string,
+      performance?: number | string;
-    },groupId?:string){
+    },
-        console.log("传入的参数",args)
+    groupId?: string,
-        const score = await this.sportStandardService.getScore({
+  ) {
-            projectId:args.projectId,
+    console.log('传入的参数', args);
-            gender:args.gender,
+    const score = await this.sportStandardService.getScore({
-            age:args.age,
+      projectId: args.projectId,
-            performance:args.performance,
+      gender: args.gender,
-            personType:args.personType,
+      age: args.age,
-            projectUnit:args.projectUnit
+      performance: args.performance,
-        })
+      personType: args.personType,
-        console.log("计算出的分数",score)
+      projectUnit: args.projectUnit,
-        const data : Prisma.TrainSituationCreateArgs = {
+    });
-            data:{
+    console.log('计算出的分数', score);
-                staffId:args.staffId,
+    const data: Prisma.TrainSituationCreateArgs = {
-                trainContentId:args.trainContentId,
+      data: {
-                mustTrainTime:args.mustTrainTime,
+        staffId: args.staffId,
-                alreadyTrainTime:args.alreadyTrainTime,
+        trainContentId: args.trainContentId,
-                value:args.value,
+        mustTrainTime: args.mustTrainTime,
-                score:score,
+        alreadyTrainTime: args.alreadyTrainTime,
-                groupId:groupId
+        value: args.value,
-            }
+        score: score,
-        }
+        groupId: groupId,
-        console.log("创建的数据",data)
+      },
-        const result = await super.create(data);
+    };
-        this.emitDataChanged(CrudOperation.CREATED, result);
+    console.log('创建的数据', data);
-        return result;
+    const result = await super.create(data);
-    }
+    this.emitDataChanged(CrudOperation.CREATED, result);
-    async createManyTrainSituation(args:{
+    return result;
-        staffId?:string,
+  }
-        trainContentId?:string,
+  async createManyTrainSituation(
-        mustTrainTime?:number,
+    args: {
-        alreadyTrainTime?:number,
+      staffId?: string;
-        value?:string,
+      trainContentId?: string;
+      mustTrainTime?: number;
+      alreadyTrainTime?: number;
+      value?: string;
 
-        projectUnit?:string,
+      projectUnit?: string;
-        personType?:string,
+      personType?: string;
-        projectId?:string,
+      projectId?: string;
-        gender?:boolean,
+      gender?: boolean;
-        age?:number,
+      age?: number;
-        performance?:number|string,
+      performance?: number | string;
-    }[]){
+    }[],
-        console.log("传入的参数",args)
+  ) {
-        const groupId = uuidv4();
+    console.log('传入的参数', args);
-        args.forEach(async (item)=>{
+    const groupId = uuidv4();
-            await this.createTrainSituation(item,groupId)
+    args.forEach(async (item) => {
-        })
+      await this.createTrainSituation(item, groupId);
-    }
+    });
-    async deleteSameGroupTrainSituation(args:{groupId?:string}){
+  }
-        const {groupId} = args
+  async deleteSameGroupTrainSituation(args: { groupId?: string }) {
-        const result = await super.deleteMany({
+    const { groupId } = args;
-            where:{
+    const result = await super.deleteMany({
-                groupId
+      where: {
-            }
+        groupId,
-        })
+      },
-        this.emitDataChanged(CrudOperation.DELETED,result)
+    });
-        return result
+    this.emitDataChanged(CrudOperation.DELETED, result);
-    }
+    return result;
+  }
 
-    // 发送数据变化事件
+  // 发送数据变化事件
-    private emitDataChanged(operation: CrudOperation, data: any) {
+  private emitDataChanged(operation: CrudOperation, data: any) {
-        EventBus.emit('dataChanged', {
+    EventBus.emit('dataChanged', {
-          type:ObjectType.TRAIN_SITUATION,
+      type: ObjectType.TRAIN_SITUATION,
-          operation,
+      operation,
-          data,
+      data,
-        });
+    });
-    }
+  }
 }

apps/server/src/models/transform/transform.module.ts

@@ -8,12 +8,7 @@ import { DepartmentModule } from '../department/department.module';
 import { StaffModule } from '../staff/staff.module';
 // import { TransformController } from './transform.controller';
 @Module({
-  imports: [
+  imports: [DepartmentModule, StaffModule, TermModule, TaxonomyModule],
-    DepartmentModule,
-    StaffModule,
-    TermModule,
-    TaxonomyModule,
-  ],
   providers: [TransformService, TransformRouter, TrpcService],
   exports: [TransformRouter, TransformService],
   // controllers:[TransformController]

apps/server/src/models/visit/visit.module.ts

@@ -5,6 +5,6 @@ import { TrpcService } from '@server/trpc/trpc.service';
 
 @Module({
   providers: [VisitService, VisitRouter, TrpcService],
-  exports: [VisitRouter]
+  exports: [VisitRouter],
 })
-export class VisitModule { }
+export class VisitModule {}

apps/server/src/socket/base/base-websocket-server.ts

@@ -1,205 +1,210 @@
-
+import { WebSocketServer, WebSocket } from 'ws';
-import { WebSocketServer, WebSocket } from "ws";
+import { Logger } from '@nestjs/common';
-import { Logger } from "@nestjs/common";
+import { WebSocketServerConfig, WSClient, WebSocketType } from '../types';
-import { WebSocketServerConfig, WSClient, WebSocketType } from "../types";
 import { SocketMessage } from '@nice/common';
 
 const DEFAULT_CONFIG: WebSocketServerConfig = {
-    pingInterval: 30000,
+  pingInterval: 30000,
-    pingTimeout: 5000,
+  pingTimeout: 5000,
-    debug: false, // 新增默认调试配置
+  debug: false, // 新增默认调试配置
 };
 interface IWebSocketServer {
-    start(): Promise<void>;
+  start(): Promise<void>;
-    stop(): Promise<void>;
+  stop(): Promise<void>;
-    broadcast(data: any): void;
+  broadcast(data: any): void;
-    handleConnection(ws: WSClient): void;
+  handleConnection(ws: WSClient): void;
-    handleDisconnection(ws: WSClient): void;
+  handleDisconnection(ws: WSClient): void;
 }
 
 export abstract class BaseWebSocketServer implements IWebSocketServer {
-    private _wss: WebSocketServer | null = null;
+  private _wss: WebSocketServer | null = null;
-    protected clients: Set<WSClient> = new Set();
+  protected clients: Set<WSClient> = new Set();
-    protected timeouts: Map<WSClient, NodeJS.Timeout> = new Map();
+  protected timeouts: Map<WSClient, NodeJS.Timeout> = new Map();
-    protected pingIntervalId?: NodeJS.Timeout;
+  protected pingIntervalId?: NodeJS.Timeout;
-    protected readonly logger = new Logger(this.constructor.name);
+  protected readonly logger = new Logger(this.constructor.name);
-    protected readonly finalConfig: WebSocketServerConfig;
+  protected readonly finalConfig: WebSocketServerConfig;
-    private userClientMap: Map<string, WSClient> = new Map();
+  private userClientMap: Map<string, WSClient> = new Map();
-    constructor(
+  constructor(protected readonly config: Partial<WebSocketServerConfig> = {}) {
-        protected readonly config: Partial<WebSocketServerConfig> = {}
+    this.finalConfig = {
-    ) {
+      ...DEFAULT_CONFIG,
-        this.finalConfig = {
+      ...config,
-            ...DEFAULT_CONFIG,
+    };
-            ...config,
+  }
-        };
+  protected debugLog(message: string, ...optionalParams: any[]): void {
+    if (this.finalConfig.debug) {
+      this.logger.debug(message, ...optionalParams);
     }
-    protected debugLog(message: string, ...optionalParams: any[]): void {
+  }
-        if (this.finalConfig.debug) {
+  public getClientCount() {
-            this.logger.debug(message, ...optionalParams);
+    return this.clients.size;
-        }
+  }
-    }
+  // 暴露 WebSocketServer 实例的只读访问
-    public getClientCount() {
+  public get wss(): WebSocketServer | null {
-        return this.clients.size
+    return this._wss;
-    }
+  }
-    // 暴露 WebSocketServer 实例的只读访问
+
-    public get wss(): WebSocketServer | null {
+  // 内部使用的 setter
-        return this._wss;
+  protected set wss(value: WebSocketServer | null) {
+    this._wss = value;
+  }
+
+  public abstract get serverType(): WebSocketType;
+
+  public get serverPath(): string {
+    return this.finalConfig.path || `/${this.serverType}`;
+  }
+
+  public async start(): Promise<void> {
+    if (this._wss) await this.stop();
+
+    this._wss = new WebSocketServer({
+      noServer: true,
+      path: this.serverPath,
+    });
+
+    this.debugLog(`WebSocket server starting on path: ${this.serverPath}`);
+    this.setupServerEvents();
+    this.startPingInterval();
+  }
+
+  public async stop(): Promise<void> {
+    if (this.pingIntervalId) {
+      clearInterval(this.pingIntervalId);
+      this.pingIntervalId = undefined;
     }
 
-    // 内部使用的 setter
+    this.clients.forEach((client) => client.close());
-    protected set wss(value: WebSocketServer | null) {
+    this.clients.clear();
-        this._wss = value;
+    this.timeouts.clear();
+
+    if (this._wss) {
+      await new Promise((resolve) => this._wss!.close(resolve));
+      this._wss = null;
     }
 
-    public abstract get serverType(): WebSocketType;
+    this.debugLog(`WebSocket server stopped on path: ${this.serverPath}`);
+  }
 
-    public get serverPath(): string {
+  public broadcast(data: SocketMessage): void {
-        return this.finalConfig.path || `/${this.serverType}`;
+    this.clients.forEach(
+      (client) =>
+        client.readyState === WebSocket.OPEN &&
+        client.send(JSON.stringify(data)),
+    );
+  }
+  public sendToUser(id: string, data: SocketMessage) {
+    const message = JSON.stringify(data);
+    const client = this.userClientMap.get(id);
+    client?.send(message);
+  }
+  public sendToUsers(ids: string[], data: SocketMessage) {
+    const message = JSON.stringify(data);
+    ids.forEach((id) => {
+      const client = this.userClientMap.get(id);
+      client?.send(message);
+    });
+  }
+  public sendToRoom(roomId: string, data: SocketMessage) {
+    const message = JSON.stringify(data);
+    this.clients.forEach((client) => {
+      if (client.readyState === WebSocket.OPEN && client.roomId === roomId) {
+        client.send(message);
+      }
+    });
+  }
+  protected getRoomClientsCount(roomId?: string): number {
+    if (!roomId) return 0;
+    return Array.from(this.clients).filter((client) => client.roomId === roomId)
+      .length;
+  }
+
+  public handleConnection(ws: WSClient): void {
+    if (ws.userId) {
+      this.userClientMap.set(ws.userId, ws);
     }
+    ws.isAlive = true;
+    ws.type = this.serverType;
+    this.clients.add(ws);
+    this.setupClientEvents(ws);
 
-    public async start(): Promise<void> {
+    const roomClientsCount = this.getRoomClientsCount(ws.roomId);
-        if (this._wss) await this.stop();
+    this.debugLog(`
-
-        this._wss = new WebSocketServer({
-            noServer: true,
-            path: this.serverPath
-        });
-
-        this.debugLog(`WebSocket server starting on path: ${this.serverPath}`);
-        this.setupServerEvents();
-        this.startPingInterval();
-    }
-
-    public async stop(): Promise<void> {
-        if (this.pingIntervalId) {
-            clearInterval(this.pingIntervalId);
-            this.pingIntervalId = undefined;
-        }
-
-        this.clients.forEach(client => client.close());
-        this.clients.clear();
-        this.timeouts.clear();
-
-        if (this._wss) {
-            await new Promise(resolve => this._wss!.close(resolve));
-            this._wss = null;
-        }
-
-        this.debugLog(`WebSocket server stopped on path: ${this.serverPath}`);
-    }
-
-    public broadcast(data: SocketMessage): void {
-        this.clients.forEach(client =>
-            client.readyState === WebSocket.OPEN && client.send(JSON.stringify(data))
-        );
-    }
-    public sendToUser(id: string, data: SocketMessage) {
-        const message = JSON.stringify(data);
-        const client = this.userClientMap.get(id);
-        client?.send(message)
-    }
-    public sendToUsers(ids: string[], data: SocketMessage) {
-        const message = JSON.stringify(data);
-        ids.forEach(id => {
-            const client = this.userClientMap.get(id);
-            client?.send(message);
-        });
-    }
-    public sendToRoom(roomId: string, data: SocketMessage) {
-        const message = JSON.stringify(data);
-        this.clients.forEach(client => {
-            if (client.readyState === WebSocket.OPEN && client.roomId === roomId) {
-                client.send(message)
-            }
-        })
-    }
-    protected getRoomClientsCount(roomId?: string): number {
-        if (!roomId) return 0;
-        return Array.from(this.clients).filter(client => client.roomId === roomId).length;
-    }
-
-    public handleConnection(ws: WSClient): void {
-        if (ws.userId) {
-            this.userClientMap.set(ws.userId, ws);
-        }
-        ws.isAlive = true;
-        ws.type = this.serverType;
-        this.clients.add(ws);
-        this.setupClientEvents(ws);
-
-        const roomClientsCount = this.getRoomClientsCount(ws.roomId);
-        this.debugLog(`
             [${this.serverType}] connected
             userId ${ws.userId} 
             roomId ${ws.roomId}
             room clients ${roomClientsCount}
             total clients ${this.clients.size}`);
+  }
+
+  public handleDisconnection(ws: WSClient): void {
+    if (ws.userId) {
+      this.userClientMap.delete(ws.userId);
     }
+    this.clients.delete(ws);
+    const timeout = this.timeouts.get(ws);
+    if (timeout) {
+      clearTimeout(timeout);
+      this.timeouts.delete(ws);
+    }
+    ws.terminate();
 
-    public handleDisconnection(ws: WSClient): void {
+    const roomClientsCount = this.getRoomClientsCount(ws.roomId);
-        if (ws.userId) {
-            this.userClientMap.delete(ws.userId);
-        }
-        this.clients.delete(ws);
-        const timeout = this.timeouts.get(ws);
-        if (timeout) {
-            clearTimeout(timeout);
-            this.timeouts.delete(ws);
-        }
-        ws.terminate();
 
-        const roomClientsCount = this.getRoomClientsCount(ws.roomId);
+    this.debugLog(`
-
-        this.debugLog(`
             [${this.serverType}] disconnected 
             userId ${ws.userId} 
             roomId ${ws.roomId}
             room clients ${roomClientsCount}
             total clients ${this.clients.size}`);
-    }
+  }
-    protected setupClientEvents(ws: WSClient): void {
+  protected setupClientEvents(ws: WSClient): void {
-        ws.on('pong', () => this.handlePong(ws))
+    ws.on('pong', () => this.handlePong(ws))
-            .on('close', () => this.handleDisconnection(ws))
+      .on('close', () => this.handleDisconnection(ws))
-            .on('error', (error) => {
+      .on('error', (error) => {
-                this.logger.error(`[${this.serverType}] client error on path ${this.serverPath}:`, error);
+        this.logger.error(
-                this.handleDisconnection(ws);
+          `[${this.serverType}] client error on path ${this.serverPath}:`,
-            });
+          error,
-    }
-
-    private handlePong(ws: WSClient): void {
-        ws.isAlive = true;
-        const timeout = this.timeouts.get(ws);
-        if (timeout) {
-            clearTimeout(timeout);
-            this.timeouts.delete(ws);
-        }
-    }
-
-    private startPingInterval(): void {
-        this.pingIntervalId = setInterval(
-            () => this.pingClients(),
-            this.finalConfig.pingInterval
         );
-    }
+        this.handleDisconnection(ws);
+      });
+  }
 
-    private pingClients(): void {
+  private handlePong(ws: WSClient): void {
-        this.clients.forEach(ws => {
+    ws.isAlive = true;
-            if (!ws.isAlive) return this.handleDisconnection(ws);
+    const timeout = this.timeouts.get(ws);
-
+    if (timeout) {
-            ws.isAlive = false;
+      clearTimeout(timeout);
-            ws.ping();
+      this.timeouts.delete(ws);
-            const timeout = setTimeout(
-                () => !ws.isAlive && this.handleDisconnection(ws),
-                this.finalConfig.pingTimeout
-            );
-            this.timeouts.set(ws, timeout);
-        });
     }
+  }
 
-    protected setupServerEvents(): void {
+  private startPingInterval(): void {
-        if (!this._wss) return;
+    this.pingIntervalId = setInterval(
-        this._wss
+      () => this.pingClients(),
-            .on('connection', (ws: WSClient) => this.handleConnection(ws))
+      this.finalConfig.pingInterval,
-            .on('error', (error) => this.logger.error(`Server error on path ${this.serverPath}:`, error));
+    );
-    }
+  }
+
+  private pingClients(): void {
+    this.clients.forEach((ws) => {
+      if (!ws.isAlive) return this.handleDisconnection(ws);
+
+      ws.isAlive = false;
+      ws.ping();
+      const timeout = setTimeout(
+        () => !ws.isAlive && this.handleDisconnection(ws),
+        this.finalConfig.pingTimeout,
+      );
+      this.timeouts.set(ws, timeout);
+    });
+  }
+
+  protected setupServerEvents(): void {
+    if (!this._wss) return;
+    this._wss
+      .on('connection', (ws: WSClient) => this.handleConnection(ws))
+      .on('error', (error) =>
+        this.logger.error(`Server error on path ${this.serverPath}:`, error),
+      );
+  }
 }

apps/server/src/socket/collaboration/callback.ts

@@ -8,12 +8,13 @@ import http from 'http';
 import { parseInt as libParseInt } from 'lib0/number';
 import { WSSharedDoc } from './ws-shared-doc';
 
-
 /**
  * 回调URL配置,从环境变量中获取
  * 如果环境变量未设置则为null
  */
-const CALLBACK_URL = process.env.CALLBACK_URL ? new URL(process.env.CALLBACK_URL) : null;
+const CALLBACK_URL = process.env.CALLBACK_URL
+  ? new URL(process.env.CALLBACK_URL)
+  : null;
 
 /**
  * 回调超时时间配置,从环境变量中获取
@@ -25,7 +26,9 @@ const CALLBACK_TIMEOUT = libParseInt(process.env.CALLBACK_TIMEOUT || '5000');
  * 需要监听变更的共享对象配置
  * 从环境变量CALLBACK_OBJECTS中解析JSON格式的配置
  */
-const CALLBACK_OBJECTS: Record<string, string> = process.env.CALLBACK_OBJECTS ? JSON.parse(process.env.CALLBACK_OBJECTS) : {};
+const CALLBACK_OBJECTS: Record<string, string> = process.env.CALLBACK_OBJECTS
+  ? JSON.parse(process.env.CALLBACK_OBJECTS)
+  : {};
 
 /**
  * 导出回调URL是否已配置的标志
@@ -37,10 +40,13 @@ export const isCallbackSet = !!CALLBACK_URL;
  */
 interface DataToSend {
   room: string; // 房间/文档标识
-  data: Record<string, {
+  data: Record<
-    type: string; // 数据类型
+    string,
-    content: any; // 数据内容
+    {
-  }>;
+      type: string; // 数据类型
+      content: any; // 数据内容
+    }
+  >;
 }
 
 /**
@@ -59,25 +65,29 @@ type OriginType = any;
  * @param origin - 更新的来源
  * @param doc - 共享文档实例
  */
-export const callbackHandler = (update: UpdateType, origin: OriginType, doc: WSSharedDoc): void => {
+export const callbackHandler = (
+  update: UpdateType,
+  origin: OriginType,
+  doc: WSSharedDoc,
+): void => {
   // 获取文档名称作为房间标识
   const room = doc.name;
 
   // 初始化要发送的数据对象
   const dataToSend: DataToSend = {
     room,
-    data: {}
+    data: {},
   };
 
   // 获取所有需要监听的共享对象名称
   const sharedObjectList = Object.keys(CALLBACK_OBJECTS);
 
   // 遍历所有共享对象,获取它们的最新内容
-  sharedObjectList.forEach(sharedObjectName => {
+  sharedObjectList.forEach((sharedObjectName) => {
     const sharedObjectType = CALLBACK_OBJECTS[sharedObjectName];
     dataToSend.data[sharedObjectName] = {
       type: sharedObjectType,
-      content: getContent(sharedObjectName, sharedObjectType, doc).toJSON()
+      content: getContent(sharedObjectName, sharedObjectType, doc).toJSON(),
     };
   });
 
@@ -106,8 +116,8 @@ const callbackRequest = (url: URL, timeout: number, data: DataToSend): void => {
     method: 'POST',
     headers: {
       'Content-Type': 'application/json',
-      'Content-Length': Buffer.byteLength(dataString)
+      'Content-Length': Buffer.byteLength(dataString),
-    }
+    },
   };
 
   // 创建HTTP请求
@@ -137,14 +147,24 @@ const callbackRequest = (url: URL, timeout: number, data: DataToSend): void => {
  * @param doc - 共享文档实例
  * @returns 共享对象的内容
  */
-const getContent = (objName: string, objType: string, doc: WSSharedDoc): any => {
+const getContent = (
+  objName: string,
+  objType: string,
+  doc: WSSharedDoc,
+): any => {
   // 根据对象类型返回相应的共享对象
   switch (objType) {
-    case 'Array': return doc.getArray(objName);
+    case 'Array':
-    case 'Map': return doc.getMap(objName);
+      return doc.getArray(objName);
-    case 'Text': return doc.getText(objName);
+    case 'Map':
-    case 'XmlFragment': return doc.getXmlFragment(objName);
+      return doc.getMap(objName);
-    case 'XmlElement': return doc.getXmlElement(objName);
+    case 'Text':
-    default: return {};
+      return doc.getText(objName);
+    case 'XmlFragment':
+      return doc.getXmlFragment(objName);
+    case 'XmlElement':
+      return doc.getXmlElement(objName);
+    default:
+      return {};
   }
 };

apps/server/src/socket/collaboration/collaboration.module.ts

@@ -3,6 +3,6 @@ import { YjsServer } from './yjs.server';
 
 @Module({
   providers: [YjsServer],
-  exports: [YjsServer]
+  exports: [YjsServer],
 })
-export class CollaborationModule { }
+export class CollaborationModule {}

apps/server/src/socket/collaboration/persistence.ts

@@ -23,7 +23,7 @@ if (typeof persistenceDir === 'string') {
         ldb.storeUpdate(docName, update);
       });
     },
-    writeState: async (_docName, _ydoc) => { },
+    writeState: async (_docName, _ydoc) => {},
   };
 }
 

apps/server/src/socket/collaboration/types.ts

@@ -1,5 +1,4 @@
 export interface ConnectionOptions {
-    docName: string;
+  docName: string;
-    gc: boolean;
+  gc: boolean;
-  }
+}
-  

apps/server/src/socket/collaboration/ws-shared-doc.ts

@@ -1,158 +1,187 @@
 import { readSyncMessage } from '@nice/common';
-import { applyAwarenessUpdate, Awareness, encodeAwarenessUpdate, removeAwarenessStates, writeSyncStep1, writeUpdate } from '@nice/common';
+import {
+  applyAwarenessUpdate,
+  Awareness,
+  encodeAwarenessUpdate,
+  removeAwarenessStates,
+  writeSyncStep1,
+  writeUpdate,
+} from '@nice/common';
 import * as encoding from 'lib0/encoding';
 import * as decoding from 'lib0/decoding';
-import * as Y from "yjs"
+import * as Y from 'yjs';
 import { debounce } from 'lodash';
 import { getPersistence, setPersistence } from './persistence';
 import { callbackHandler, isCallbackSet } from './callback';
-import { WebSocket } from "ws";
+import { WebSocket } from 'ws';
 import { YMessageType } from '@nice/common';
 import { WSClient } from '../types';
 export const docs = new Map<string, WSSharedDoc>();
-export const CALLBACK_DEBOUNCE_WAIT = parseInt(process.env.CALLBACK_DEBOUNCE_WAIT || '2000');
+export const CALLBACK_DEBOUNCE_WAIT = parseInt(
-export const CALLBACK_DEBOUNCE_MAXWAIT = parseInt(process.env.CALLBACK_DEBOUNCE_MAXWAIT || '10000');
+  process.env.CALLBACK_DEBOUNCE_WAIT || '2000',
+);
+export const CALLBACK_DEBOUNCE_MAXWAIT = parseInt(
+  process.env.CALLBACK_DEBOUNCE_MAXWAIT || '10000',
+);
 export const getYDoc = (docname: string, gc = true): WSSharedDoc => {
-    return docs.get(docname) || createYDoc(docname, gc);
+  return docs.get(docname) || createYDoc(docname, gc);
 };
 const createYDoc = (docname: string, gc: boolean): WSSharedDoc => {
-    const doc = new WSSharedDoc(docname, gc);
+  const doc = new WSSharedDoc(docname, gc);
-    docs.set(docname, doc);
+  docs.set(docname, doc);
-    return doc;
+  return doc;
 };
 
 export const send = (doc: WSSharedDoc, conn: WebSocket, m: Uint8Array) => {
-    if (conn.readyState !== WebSocket.OPEN) {
+  if (conn.readyState !== WebSocket.OPEN) {
-        closeConn(doc, conn);
+    closeConn(doc, conn);
-        return;
+    return;
-    }
+  }
-    try {
+  try {
-        conn.send(m, {}, err => { err != null && closeConn(doc, conn) });
+    conn.send(m, {}, (err) => {
-    } catch (e) {
+      err != null && closeConn(doc, conn);
-        closeConn(doc, conn);
+    });
-    }
+  } catch (e) {
+    closeConn(doc, conn);
+  }
 };
 export const closeConn = (doc: WSSharedDoc, conn: WebSocket) => {
-    if (doc.conns.has(conn)) {
+  if (doc.conns.has(conn)) {
-        const controlledIds = doc.conns.get(conn) as Set<number>;
+    const controlledIds = doc.conns.get(conn) as Set<number>;
-        doc.conns.delete(conn);
+    doc.conns.delete(conn);
-        removeAwarenessStates(
+    removeAwarenessStates(doc.awareness, Array.from(controlledIds), null);
-            doc.awareness,
-            Array.from(controlledIds),
-            null
-        );
 
-        if (doc.conns.size === 0 && getPersistence() !== null) {
+    if (doc.conns.size === 0 && getPersistence() !== null) {
-            getPersistence()?.writeState(doc.name, doc).then(() => {
+      getPersistence()
-                doc.destroy();
+        ?.writeState(doc.name, doc)
-            });
+        .then(() => {
-            docs.delete(doc.name);
+          doc.destroy();
-        }
+        });
+      docs.delete(doc.name);
     }
-    conn.close();
+  }
+  conn.close();
 };
 
-export const messageListener = (conn: WSClient, doc: WSSharedDoc, message: Uint8Array) => {
+export const messageListener = (
-    try {
+  conn: WSClient,
-        const encoder = encoding.createEncoder();
+  doc: WSSharedDoc,
-        const decoder = decoding.createDecoder(message);
+  message: Uint8Array,
-        const messageType = decoding.readVarUint(decoder);
+) => {
-        switch (messageType) {
+  try {
-            case YMessageType.Sync:
-                // console.log(`received sync message ${message.length}`)
-                encoding.writeVarUint(encoder, YMessageType.Sync);
-                readSyncMessage(decoder, encoder, doc, conn);
-                if (encoding.length(encoder) > 1) {
-                    send(doc, conn, encoding.toUint8Array(encoder));
-                }
-                break;
-
-            case YMessageType.Awareness: {
-                applyAwarenessUpdate(
-                    doc.awareness,
-                    decoding.readVarUint8Array(decoder),
-                    conn
-                );
-                // console.log(`received awareness message from ${conn.origin} total ${doc.awareness.states.size}`)
-                break;
-            }
-        }
-    } catch (err) {
-        console.error(err);
-        doc.emit('error' as any, [err]);
-    }
-};
-
-const updateHandler = (update: Uint8Array, _origin: any, doc: WSSharedDoc, _tr: any) => {
     const encoder = encoding.createEncoder();
-    encoding.writeVarUint(encoder, YMessageType.Sync);
+    const decoder = decoding.createDecoder(message);
-    writeUpdate(encoder, update);
+    const messageType = decoding.readVarUint(decoder);
-    const message = encoding.toUint8Array(encoder);
+    switch (messageType) {
-    doc.conns.forEach((_, conn) => send(doc, conn, message));
+      case YMessageType.Sync:
+        // console.log(`received sync message ${message.length}`)
+        encoding.writeVarUint(encoder, YMessageType.Sync);
+        readSyncMessage(decoder, encoder, doc, conn);
+        if (encoding.length(encoder) > 1) {
+          send(doc, conn, encoding.toUint8Array(encoder));
+        }
+        break;
+
+      case YMessageType.Awareness: {
+        applyAwarenessUpdate(
+          doc.awareness,
+          decoding.readVarUint8Array(decoder),
+          conn,
+        );
+        // console.log(`received awareness message from ${conn.origin} total ${doc.awareness.states.size}`)
+        break;
+      }
+    }
+  } catch (err) {
+    console.error(err);
+    doc.emit('error' as any, [err]);
+  }
 };
 
-let contentInitializor: (ydoc: Y.Doc) => Promise<void> = (_ydoc) => Promise.resolve();
+const updateHandler = (
+  update: Uint8Array,
+  _origin: any,
+  doc: WSSharedDoc,
+  _tr: any,
+) => {
+  const encoder = encoding.createEncoder();
+  encoding.writeVarUint(encoder, YMessageType.Sync);
+  writeUpdate(encoder, update);
+  const message = encoding.toUint8Array(encoder);
+  doc.conns.forEach((_, conn) => send(doc, conn, message));
+};
+
+let contentInitializor: (ydoc: Y.Doc) => Promise<void> = (_ydoc) =>
+  Promise.resolve();
 export const setContentInitializor = (f: (ydoc: Y.Doc) => Promise<void>) => {
-    contentInitializor = f;
+  contentInitializor = f;
 };
 
 export class WSSharedDoc extends Y.Doc {
-    name: string;
+  name: string;
-    conns: Map<WebSocket, Set<number>>;
+  conns: Map<WebSocket, Set<number>>;
-    awareness: Awareness;
+  awareness: Awareness;
-    whenInitialized: Promise<void>;
+  whenInitialized: Promise<void>;
 
-    constructor(name: string, gc: boolean) {
+  constructor(name: string, gc: boolean) {
-        super({ gc });
+    super({ gc });
 
-        this.name = name;
+    this.name = name;
-        this.conns = new Map();
+    this.conns = new Map();
-        this.awareness = new Awareness(this);
+    this.awareness = new Awareness(this);
-        this.awareness.setLocalState(null);
+    this.awareness.setLocalState(null);
 
-        const awarenessUpdateHandler = ({
+    const awarenessUpdateHandler = (
-            added,
+      {
-            updated,
+        added,
-            removed
+        updated,
-        }: {
+        removed,
-            added: number[],
+      }: {
-            updated: number[],
+        added: number[];
-            removed: number[]
+        updated: number[];
-        }, conn: WebSocket) => {
+        removed: number[];
-            const changedClients = added.concat(updated, removed);
+      },
-            if (changedClients.length === 0) return
+      conn: WebSocket,
-            if (conn !== null) {
+    ) => {
-                const connControlledIDs = this.conns.get(conn) as Set<number>;
+      const changedClients = added.concat(updated, removed);
-                if (connControlledIDs !== undefined) {
+      if (changedClients.length === 0) return;
-                    added.forEach(clientID => { connControlledIDs.add(clientID); });
+      if (conn !== null) {
-                    removed.forEach(clientID => { connControlledIDs.delete(clientID); });
+        const connControlledIDs = this.conns.get(conn) as Set<number>;
-                }
+        if (connControlledIDs !== undefined) {
-            }
+          added.forEach((clientID) => {
-
+            connControlledIDs.add(clientID);
-            const encoder = encoding.createEncoder();
+          });
-            encoding.writeVarUint(encoder, YMessageType.Awareness);
+          removed.forEach((clientID) => {
-            encoding.writeVarUint8Array(
+            connControlledIDs.delete(clientID);
-                encoder,
+          });
-                encodeAwarenessUpdate(this.awareness, changedClients)
-            );
-            const buff = encoding.toUint8Array(encoder);
-
-            this.conns.forEach((_, c) => {
-                send(this, c, buff);
-            });
-        };
-
-        this.awareness.on('update', awarenessUpdateHandler);
-        this.on('update', updateHandler as any);
-
-        if (isCallbackSet) {
-            this.on('update', debounce(
-                callbackHandler as any,
-                CALLBACK_DEBOUNCE_WAIT,
-                { maxWait: CALLBACK_DEBOUNCE_MAXWAIT }
-            ) as any);
         }
+      }
 
-        this.whenInitialized = contentInitializor(this);
+      const encoder = encoding.createEncoder();
+      encoding.writeVarUint(encoder, YMessageType.Awareness);
+      encoding.writeVarUint8Array(
+        encoder,
+        encodeAwarenessUpdate(this.awareness, changedClients),
+      );
+      const buff = encoding.toUint8Array(encoder);
+
+      this.conns.forEach((_, c) => {
+        send(this, c, buff);
+      });
+    };
+
+    this.awareness.on('update', awarenessUpdateHandler);
+    this.on('update', updateHandler as any);
+
+    if (isCallbackSet) {
+      this.on(
+        'update',
+        debounce(callbackHandler as any, CALLBACK_DEBOUNCE_WAIT, {
+          maxWait: CALLBACK_DEBOUNCE_MAXWAIT,
+        }) as any,
+      );
     }
+
+    this.whenInitialized = contentInitializor(this);
+  }
 }

apps/server/src/socket/collaboration/yjs.server.ts

@@ -1,85 +1,117 @@
-import { Injectable } from "@nestjs/common";
+import { Injectable } from '@nestjs/common';
-import { WebSocketType, WSClient } from "../types";
+import { WebSocketType, WSClient } from '../types';
-import { BaseWebSocketServer } from "../base/base-websocket-server";
+import { BaseWebSocketServer } from '../base/base-websocket-server';
-import { encoding } from "lib0";
+import { encoding } from 'lib0';
-import { YMessageType, writeSyncStep1, encodeAwarenessUpdate } from "@nice/common";
+import {
-import { getYDoc, closeConn, WSSharedDoc, messageListener, send } from "./ws-shared-doc";
+  YMessageType,
+  writeSyncStep1,
+  encodeAwarenessUpdate,
+} from '@nice/common';
+import {
+  getYDoc,
+  closeConn,
+  WSSharedDoc,
+  messageListener,
+  send,
+} from './ws-shared-doc';
 @Injectable()
 export class YjsServer extends BaseWebSocketServer {
-    public get serverType(): WebSocketType {
+  public get serverType(): WebSocketType {
-        return WebSocketType.YJS;
+    return WebSocketType.YJS;
-    }
+  }
-    public override handleConnection(
+  public override handleConnection(connection: WSClient): void {
-        connection: WSClient
+    super.handleConnection(connection);
-    ): void {
+    try {
-        super.handleConnection(connection)
+      connection.binaryType = 'arraybuffer';
-        try {
+      const doc = this.initializeDocument(connection, connection.roomId, true);
-            connection.binaryType = 'arraybuffer';
+      this.setupConnectionHandlers(connection, doc);
-            const doc = this.initializeDocument(connection, connection.roomId, true);
+      this.sendInitialSync(connection, doc);
-            this.setupConnectionHandlers(connection, doc);
+    } catch (error: any) {
-            this.sendInitialSync(connection, doc);
+      this.logger.error(
-        } catch (error: any) {
+        `Error in handleNewConnection: ${error.message}`,
-            this.logger.error(`Error in handleNewConnection: ${error.message}`, error.stack);
+        error.stack,
-            connection.close();
+      );
-        }
+      connection.close();
     }
+  }
 
-    private initializeDocument(conn: WSClient, docName: string, gc: boolean) {
+  private initializeDocument(conn: WSClient, docName: string, gc: boolean) {
-        const doc = getYDoc(docName, gc);
+    const doc = getYDoc(docName, gc);
 
-        doc.conns.set(conn, new Set());
+    doc.conns.set(conn, new Set());
-        return doc;
+    return doc;
-    }
+  }
 
-    private setupConnectionHandlers(connection: WSClient, doc: WSSharedDoc): void {
+  private setupConnectionHandlers(
-        connection.on('message', (message: ArrayBuffer) => {
+    connection: WSClient,
-            this.handleMessage(connection, doc, message);
+    doc: WSSharedDoc,
-        });
+  ): void {
-        connection.on('close', () => {
+    connection.on('message', (message: ArrayBuffer) => {
-            this.handleClose(doc, connection);
+      this.handleMessage(connection, doc, message);
-        });
+    });
-        connection.on('error', (error) => {
+    connection.on('close', () => {
-            this.logger.error(`WebSocket error for doc ${doc.name}: ${error.message}`, error.stack);
+      this.handleClose(doc, connection);
-            closeConn(doc, connection);
+    });
-            this.logger.warn(`Connection closed due to error for doc: ${doc.name}. Remaining connections: ${doc.conns.size}`);
+    connection.on('error', (error) => {
-        });
+      this.logger.error(
-    }
+        `WebSocket error for doc ${doc.name}: ${error.message}`,
+        error.stack,
+      );
+      closeConn(doc, connection);
+      this.logger.warn(
+        `Connection closed due to error for doc: ${doc.name}. Remaining connections: ${doc.conns.size}`,
+      );
+    });
+  }
 
-    private handleClose(doc: WSSharedDoc, connection: WSClient): void {
+  private handleClose(doc: WSSharedDoc, connection: WSClient): void {
-        try {
+    try {
-            closeConn(doc, connection);
+      closeConn(doc, connection);
-        } catch (error: any) {
+    } catch (error: any) {
-            this.logger.error(`Error closing connection: ${error.message}`, error.stack);
+      this.logger.error(
-        }
+        `Error closing connection: ${error.message}`,
+        error.stack,
+      );
     }
-    private handleMessage(connection: WSClient, doc: WSSharedDoc, message: ArrayBuffer): void {
+  }
-        try {
+  private handleMessage(
-            messageListener(connection, doc, new Uint8Array(message));
+    connection: WSClient,
-        } catch (error: any) {
+    doc: WSSharedDoc,
-            this.logger.error(`Error handling message: ${error.message}`, error.stack);
+    message: ArrayBuffer,
-        }
+  ): void {
+    try {
+      messageListener(connection, doc, new Uint8Array(message));
+    } catch (error: any) {
+      this.logger.error(
+        `Error handling message: ${error.message}`,
+        error.stack,
+      );
     }
-    private sendInitialSync(connection: WSClient, doc: any): void {
+  }
-        this.sendSyncStep1(connection, doc);
+  private sendInitialSync(connection: WSClient, doc: any): void {
-        this.sendAwarenessStates(connection, doc);
+    this.sendSyncStep1(connection, doc);
-    }
+    this.sendAwarenessStates(connection, doc);
-    private sendSyncStep1(connection: WSClient, doc: any): void {
+  }
-        const encoder = encoding.createEncoder();
+  private sendSyncStep1(connection: WSClient, doc: any): void {
-        encoding.writeVarUint(encoder, YMessageType.Sync);
+    const encoder = encoding.createEncoder();
-        writeSyncStep1(encoder, doc);
+    encoding.writeVarUint(encoder, YMessageType.Sync);
-        send(doc, connection, encoding.toUint8Array(encoder));
+    writeSyncStep1(encoder, doc);
-    }
+    send(doc, connection, encoding.toUint8Array(encoder));
-    private sendAwarenessStates(connection: WSClient, doc: WSSharedDoc): void {
+  }
-        const awarenessStates = doc.awareness.getStates();
+  private sendAwarenessStates(connection: WSClient, doc: WSSharedDoc): void {
+    const awarenessStates = doc.awareness.getStates();
 
-        if (awarenessStates.size > 0) {
+    if (awarenessStates.size > 0) {
-            const encoder = encoding.createEncoder();
+      const encoder = encoding.createEncoder();
-            encoding.writeVarUint(encoder, YMessageType.Awareness);
+      encoding.writeVarUint(encoder, YMessageType.Awareness);
-            encoding.writeVarUint8Array(
+      encoding.writeVarUint8Array(
-                encoder,
+        encoder,
-                encodeAwarenessUpdate(doc.awareness, Array.from(awarenessStates.keys()))
+        encodeAwarenessUpdate(
-            );
+          doc.awareness,
-            send(doc, connection, encoding.toUint8Array(encoder));
+          Array.from(awarenessStates.keys()),
-        }
+        ),
+      );
+      send(doc, connection, encoding.toUint8Array(encoder));
     }
+  }
 }

apps/server/src/socket/realtime/realtime.module.ts

@@ -1,9 +1,8 @@
 import { Module } from '@nestjs/common';
 import { RealtimeServer } from './realtime.server';
 
-
 @Module({
-    providers: [ RealtimeServer],
+  providers: [RealtimeServer],
-    exports: [ RealtimeServer]
+  exports: [RealtimeServer],
 })
-export class RealTimeModule { }
+export class RealTimeModule {}

apps/server/src/socket/realtime/realtime.server.ts

@@ -1,25 +1,37 @@
-import { Injectable, OnModuleInit } from "@nestjs/common";
+import { Injectable, OnModuleInit } from '@nestjs/common';
-import { WebSocketType } from "../types";
+import { WebSocketType } from '../types';
-import { BaseWebSocketServer } from "../base/base-websocket-server";
+import { BaseWebSocketServer } from '../base/base-websocket-server';
-import EventBus, { CrudOperation } from "@server/utils/event-bus";
+import EventBus, { CrudOperation } from '@server/utils/event-bus';
-import { ObjectType, SocketMsgType, MessageDto, PostDto, PostType } from "@nice/common";
+import {
+  ObjectType,
+  SocketMsgType,
+  MessageDto,
+  PostDto,
+  PostType,
+} from '@nice/common';
 @Injectable()
-export class RealtimeServer extends BaseWebSocketServer implements OnModuleInit {
+export class RealtimeServer
-    onModuleInit() {
+  extends BaseWebSocketServer
-        EventBus.on("dataChanged", ({ data, type, operation }) => {
+  implements OnModuleInit
-            if (type === ObjectType.MESSAGE && operation === CrudOperation.CREATED) {
+{
-                const receiverIds = (data as Partial<MessageDto>).receivers.map(receiver => receiver.id)
+  onModuleInit() {
-                this.sendToUsers(receiverIds, { type: SocketMsgType.NOTIFY, payload: { objectType: ObjectType.MESSAGE } })
+    EventBus.on('dataChanged', ({ data, type, operation }) => {
-            }
+      if (type === ObjectType.MESSAGE && operation === CrudOperation.CREATED) {
+        const receiverIds = (data as Partial<MessageDto>).receivers.map(
+          (receiver) => receiver.id,
+        );
+        this.sendToUsers(receiverIds, {
+          type: SocketMsgType.NOTIFY,
+          payload: { objectType: ObjectType.MESSAGE },
+        });
+      }
 
-            if (type === ObjectType.POST) {
+      if (type === ObjectType.POST) {
-                const post = data as Partial<PostDto>
+        const post = data as Partial<PostDto>;
-
+      }
-            }
+    });
-        })
+  }
-
+  public get serverType(): WebSocketType {
-    }
+    return WebSocketType.REALTIME;
-    public get serverType(): WebSocketType {
+  }
-        return WebSocketType.REALTIME;
-    }
 }

apps/server/src/socket/types.ts

@@ -1,29 +1,29 @@
-import { WebSocketServer, WebSocket } from "ws";
+import { WebSocketServer, WebSocket } from 'ws';
 
 // 类型定义
 export enum WebSocketType {
-    YJS = "yjs",
+  YJS = 'yjs',
-    REALTIME = "realtime"
+  REALTIME = 'realtime',
 }
 
 export interface WebSocketServerConfig {
-    path?: string;
+  path?: string;
-    pingInterval?: number;
+  pingInterval?: number;
-    pingTimeout?: number;
+  pingTimeout?: number;
-    debug?: boolean
+  debug?: boolean;
 }
 
 export interface ServerInstance {
-    wss: WebSocketServer | null;
+  wss: WebSocketServer | null;
-    clients: Set<WSClient>;
+  clients: Set<WSClient>;
-    pingIntervalId?: NodeJS.Timeout;
+  pingIntervalId?: NodeJS.Timeout;
-    timeouts: Map<WebSocket, NodeJS.Timeout>;
+  timeouts: Map<WebSocket, NodeJS.Timeout>;
 }
 
 export interface WSClient extends WebSocket {
-    isAlive?: boolean;
+  isAlive?: boolean;
-    type?: WebSocketType;
+  type?: WebSocketType;
-    userId?: string
+  userId?: string;
-    origin?: string
+  origin?: string;
-    roomId?: string
+  roomId?: string;
 }

apps/server/src/socket/websocket.module.ts

@@ -8,4 +8,4 @@ import { CollaborationModule } from './collaboration/collaboration.module';
   providers: [WebSocketService],
   exports: [WebSocketService],
 })
-export class WebSocketModule { }
+export class WebSocketModule {}

apps/server/src/socket/websocket.service.ts

@@ -1,61 +1,61 @@
-import { Injectable, Logger } from "@nestjs/common";
+import { Injectable, Logger } from '@nestjs/common';
-import { Server } from "http";
+import { Server } from 'http';
-import { WSClient } from "./types";
+import { WSClient } from './types';
-import { RealtimeServer } from "./realtime/realtime.server";
+import { RealtimeServer } from './realtime/realtime.server';
-import { YjsServer } from "./collaboration/yjs.server";
+import { YjsServer } from './collaboration/yjs.server';
-import { BaseWebSocketServer } from "./base/base-websocket-server";
+import { BaseWebSocketServer } from './base/base-websocket-server';
 
 @Injectable()
 export class WebSocketService {
-    private readonly logger = new Logger(WebSocketService.name);
+  private readonly logger = new Logger(WebSocketService.name);
-    private readonly servers: BaseWebSocketServer[] = [];
+  private readonly servers: BaseWebSocketServer[] = [];
-    constructor(
+  constructor(
-        private realTimeServer: RealtimeServer,
+    private realTimeServer: RealtimeServer,
-        private yjsServer: YjsServer
+    private yjsServer: YjsServer,
-    ) {
+  ) {
-        this.servers.push(this.realTimeServer)
+    this.servers.push(this.realTimeServer);
-        this.servers.push(this.yjsServer)
+    this.servers.push(this.yjsServer);
+  }
+  public async initialize(httpServer: Server): Promise<void> {
+    try {
+      await Promise.all(this.servers.map((server) => server.start()));
+      this.setupUpgradeHandler(httpServer);
+    } catch (error) {
+      this.logger.error('Failed to initialize:', error);
+      throw error;
     }
-    public async initialize(httpServer: Server): Promise<void> {
+  }
-        try {
+  private setupUpgradeHandler(httpServer: Server): void {
-            await Promise.all(this.servers.map(server => server.start()));
+    if (httpServer.listeners('upgrade').length) return;
-            this.setupUpgradeHandler(httpServer);
+    httpServer.on('upgrade', async (request, socket, head) => {
-        } catch (error) {
+      try {
-            this.logger.error('Failed to initialize:', error);
+        const url = new URL(request.url!, `http://${request.headers.host}`);
-            throw error;
+        const pathname = url.pathname;
-        }
-    }
-    private setupUpgradeHandler(httpServer: Server): void {
-        if (httpServer.listeners('upgrade').length) return;
-        httpServer.on('upgrade', async (request, socket, head) => {
-            try {
-                const url = new URL(request.url!, `http://${request.headers.host}`);
-                const pathname = url.pathname;
 
-                // 从URL查询参数中获取roomId和token
+        // 从URL查询参数中获取roomId和token
-                const urlParams = new URLSearchParams(url.search);
+        const urlParams = new URLSearchParams(url.search);
-                const roomId = urlParams.get('roomId');
+        const roomId = urlParams.get('roomId');
-                const userId = urlParams.get('userId');
+        const userId = urlParams.get('userId');
-                const server = this.servers.find(server => {
+        const server = this.servers.find((server) => {
-                    const serverPathClean = server.serverPath.replace(/\/$/, '');
+          const serverPathClean = server.serverPath.replace(/\/$/, '');
-                    const pathnameClean = pathname.replace(/\/$/, '');
+          const pathnameClean = pathname.replace(/\/$/, '');
-                    return serverPathClean === pathnameClean;
+          return serverPathClean === pathnameClean;
-                });
-
-                if (!server || !server.wss) {
-                    return socket.destroy();
-                }
-
-                server.wss!.handleUpgrade(request, socket, head, (ws: WSClient) => {
-                    ws.userId = userId;
-                    ws.origin = request.url
-                    ws.roomId = roomId
-                    server.wss!.emit('connection', ws, request);
-                });
-            } catch (error) {
-                this.logger.error('Upgrade error:', error);
-                socket.destroy();
-            }
         });
-    }
+
+        if (!server || !server.wss) {
+          return socket.destroy();
+        }
+
+        server.wss!.handleUpgrade(request, socket, head, (ws: WSClient) => {
+          ws.userId = userId;
+          ws.origin = request.url;
+          ws.roomId = roomId;
+          server.wss!.emit('connection', ws, request);
+        });
+      } catch (error) {
+        this.logger.error('Upgrade error:', error);
+        socket.destroy();
+      }
+    });
+  }
 }

apps/server/src/tasks/init/gendev.service.ts

@@ -52,8 +52,8 @@ export class GenDevService {
       await this.generateStaffs(4);
       //await this.generateTerms(2, 6);
       //await this.generateCourses(8);
-      await this.generateTrainContent(2,6)
+      await this.generateTrainContent(2, 6);
-      await this.generateTrainSituations()
+      await this.generateTrainSituations();
     } catch (err) {
       this.logger.error(err);
     }
@@ -88,7 +88,9 @@ export class GenDevService {
     this.domains.forEach((domain) => {
       this.domainDepts[domain.id] = this.getAllChildDepartments(domain.id);
       this.logger.log(
-        `Domain: ${domain.name} has ${this.domainDepts[domain.id].length} child departments`,
+        `Domain: ${domain.name} has ${
+          this.domainDepts[domain.id].length
+        } child departments`,
       );
     });
     this.logger.log(`Completed: Generated ${this.depts.length} departments.`);
@@ -104,7 +106,9 @@ export class GenDevService {
     if (currentDepth > maxDepth) return;
 
     for (let i = 0; i < count; i++) {
-      const deptName = `${parentId?.slice(0, 6) || '根'}公司${currentDepth}-${i}`;
+      const deptName = `${
+        parentId?.slice(0, 6) || '根'
+      }公司${currentDepth}-${i}`;
       const newDept = await this.createDepartment(
         deptName,
         parentId,
@@ -190,7 +194,9 @@ export class GenDevService {
       });
       for (const cate of cates) {
         for (let i = 0; i < countPerCate; i++) {
-          const randomTitle = `${titleList[Math.floor(Math.random() * titleList.length)]} ${Math.random().toString(36).substring(7)}`;
+          const randomTitle = `${
+            titleList[Math.floor(Math.random() * titleList.length)]
+          } ${Math.random().toString(36).substring(7)}`;
           const randomLevelId =
             levels[Math.floor(Math.random() * levels.length)].id;
           const randomDeptId =
@@ -224,7 +230,9 @@ export class GenDevService {
             this.deptStaffRecord[dept.id] = [];
           }
           for (let i = 0; i < countPerDept; i++) {
-            const username = `${dept.name}-S${staffsGenerated.toString().padStart(4, '0')}`;
+            const username = `${dept.name}-S${staffsGenerated
+              .toString()
+              .padStart(4, '0')}`;
             const staff = await this.staffService.create({
               data: {
                 showname: username,
@@ -328,7 +336,9 @@ export class GenDevService {
     ) => {
       if (currentDepth > depth) return;
       for (let i = 0; i < nodesPerLevel; i++) {
-        const name = `${taxonomySlug}-${domain?.name || 'public'}-${currentDepth}-${counter++} `;
+        const name = `${taxonomySlug}-${
+          domain?.name || 'public'
+        }-${currentDepth}-${counter++} `;
         const newTerm = await this.termService.create({
           data: {
             name,
@@ -347,106 +357,113 @@ export class GenDevService {
   }
   // 生成培训内容
   private async createTrainContent(
-    type:string,
+    type: string,
-    title:string,
+    title: string,
-    parentId:string|null
+    parentId: string | null,
-  ){
+  ) {
     const trainContent = await db.trainContent.create({
       data: {
         type,
         title,
-        parentId
+        parentId,
       },
     });
     return trainContent;
   }
   // 生成培训内容
-  private async generateTrainContent(depth:number=3,count:number=6){
+  private async generateTrainContent(depth: number = 3, count: number = 6) {
-    if(this.counts.trainContentCount !== 0) return;
+    if (this.counts.trainContentCount !== 0) return;
-    const totalTrainContent = this.calculateTotalTrainContent(depth,count)
+    const totalTrainContent = this.calculateTotalTrainContent(depth, count);
-    this.logger.log("Start generating train content...")
+    this.logger.log('Start generating train content...');
-    await this.generateSubTrainContent(null,1,depth,count,totalTrainContent)
+    await this.generateSubTrainContent(
-    this.trainContents = await db.trainContent.findMany()
+      null,
-    this.logger.log(`Completed: Generated ${this.trainContents.length} departments.`);
+      1,
+      depth,
+      count,
+      totalTrainContent,
+    );
+    this.trainContents = await db.trainContent.findMany();
+    this.logger.log(
+      `Completed: Generated ${this.trainContents.length} departments.`,
+    );
   }
   // 生成培训内容子内容
   private async generateSubTrainContent(
     parentId: string | null,
-    currentDepth:number,
+    currentDepth: number,
-    maxDepth:number,
+    maxDepth: number,
-    count:number,
+    count: number,
-    total:number,
+    total: number,
-  ){
+  ) {
-    if(currentDepth > maxDepth) return;
+    if (currentDepth > maxDepth) return;
-    const contentType = [TrainContentType.SUBJECTS,TrainContentType.COURSE]
+    const contentType = [TrainContentType.SUBJECTS, TrainContentType.COURSE];
-    for(let i = 0 ; i < count ; i++){
+    for (let i = 0; i < count; i++) {
-      const trainContentTitle = `${parentId?.slice(0,6) || '根'}公司${currentDepth}-${i}`
+      const trainContentTitle = `${
+        parentId?.slice(0, 6) || '根'
+      }公司${currentDepth}-${i}`;
       const newTrainContent = await this.createTrainContent(
-        contentType[currentDepth-1],
+        contentType[currentDepth - 1],
         trainContentTitle,
-        parentId
+        parentId,
-      )
+      );
       this.trainContentGeneratedCount++;
       this.logger.log(
-        `Generated ${this.trainContentGeneratedCount}/${total} train contents`
+        `Generated ${this.trainContentGeneratedCount}/${total} train contents`,
-      )
+      );
       await this.generateSubTrainContent(
         newTrainContent.id,
-        currentDepth+1,
+        currentDepth + 1,
         maxDepth,
         count,
-        total
+        total,
-      )
+      );
     }
   }
-  private calculateTotalTrainContent(depth:number,count:number):number{
+  private calculateTotalTrainContent(depth: number, count: number): number {
     let total = 0;
-    for(let i = 1 ; i<=depth;i++){
+    for (let i = 1; i <= depth; i++) {
-      total += Math.pow(count,i);
+      total += Math.pow(count, i);
     }
     return total;
   }
 
-
+  private async createTrainSituation(staffId: string, trainContentId: string) {
-  private async createTrainSituation(staffId:string,trainContentId:string){
     const trainSituation = await db.trainSituation.create({
-      data:{
+      data: {
         staffId,
         trainContentId,
-        mustTrainTime:Math.floor(Math.random()*100),
+        mustTrainTime: Math.floor(Math.random() * 100),
-        alreadyTrainTime:Math.floor(Math.random()*100),
+        alreadyTrainTime: Math.floor(Math.random() * 100),
-        score:Math.floor(Math.random()*100),
+        score: Math.floor(Math.random() * 100),
-      }
+      },
-    })
+    });
-    return trainSituation
+    return trainSituation;
   }
 
-  private async generateTrainSituations(probability: number = 0.1){
+  private async generateTrainSituations(probability: number = 0.1) {
-    this.logger.log("Start generating train situations...")
+    this.logger.log('Start generating train situations...');
     const allTrainContents = await db.trainContent.findMany();
     // 这里相当于两次遍历 找到没有parentID的即是
-    const leafNodes = allTrainContents.filter((item)=>item.parentId !== null)
+    const leafNodes = allTrainContents.filter((item) => item.parentId !== null);
-    console.log(leafNodes.length)
+    console.log(leafNodes.length);
-    const staffs = await db.staff.findMany()
+    const staffs = await db.staff.findMany();
 
-    let situationCount = 0
+    let situationCount = 0;
-    const totalPossibleSituations = leafNodes.length * staffs.length
+    const totalPossibleSituations = leafNodes.length * staffs.length;
 
-    for (const staff of staffs){
+    for (const staff of staffs) {
-      for(const leaf of leafNodes){
+      for (const leaf of leafNodes) {
-        if(Math.random() < probability){
+        if (Math.random() < probability) {
-          await this.createTrainSituation(staff.id,leaf.id)
+          await this.createTrainSituation(staff.id, leaf.id);
-          situationCount++
+          situationCount++;
           if (situationCount % 100 === 0) {
-            this.logger.log(
+            this.logger.log(`Generated ${situationCount} train situations`);
-              `Generated ${situationCount} train situations`
-            );
           }
         }
       }
     }
     this.logger.log(
-      `Completed: Generated ${situationCount} train situations out of ${totalPossibleSituations} possible combinations.`
+      `Completed: Generated ${situationCount} train situations out of ${totalPossibleSituations} possible combinations.`,
     );
   }
 }

apps/server/src/tasks/init/init.module.ts

@@ -9,8 +9,15 @@ import { DepartmentModule } from '@server/models/department/department.module';
 import { TermModule } from '@server/models/term/term.module';
 
 @Module({
-  imports: [MinioModule, AuthModule, AppConfigModule, StaffModule, DepartmentModule, TermModule],
+  imports: [
+    MinioModule,
+    AuthModule,
+    AppConfigModule,
+    StaffModule,
+    DepartmentModule,
+    TermModule,
+  ],
   providers: [InitService, GenDevService],
-  exports: [InitService]
+  exports: [InitService],
 })
-export class InitModule { }
+export class InitModule {}

apps/server/src/tasks/init/init.service.ts

@@ -19,7 +19,7 @@ export class InitService {
     private readonly minioService: MinioService,
     private readonly authService: AuthService,
     private readonly genDevService: GenDevService,
-  ) { }
+  ) {}
   private async createRoles() {
     this.logger.log('Checking existing system roles');
     for (const role of InitRoles) {
@@ -122,16 +122,16 @@ export class InitService {
     const existingTrainContent = await db.trainContent.findFirst({
       where: {
         type: 'SPORTS',
-        title: '体能考核'
+        title: '体能考核',
-      }
+      },
     });
     if (!existingTrainContent) {
       await db.trainContent.create({
         data: {
           type: 'SPORTS',
-          title: '体能考核'
+          title: '体能考核',
-        }
+        },
-      })
+      });
     } else {
       this.logger.log('Sport train already exists');
     }

apps/server/src/tasks/init/utils.ts

@@ -16,7 +16,7 @@ export interface DevDataCounts {
 export async function getCounts(): Promise<DevDataCounts> {
   const counts = {
     deptCount: await db.department.count(),
-    trainContentCount:await db.trainContent.count(),
+    trainContentCount: await db.trainContent.count(),
     staffCount: await db.staff.count(),
     termCount: await db.term.count(),
     courseCount: await db.post.count({

apps/server/src/tasks/reminder/reminder.module.ts

@@ -3,8 +3,8 @@ import { ReminderService } from './reminder.service';
 import { MessageModule } from '@server/models/message/message.module';
 
 @Module({
-  imports: [ MessageModule],
+  imports: [MessageModule],
   providers: [ReminderService],
-  exports: [ReminderService]
+  exports: [ReminderService],
 })
-export class ReminderModule { }
+export class ReminderModule {}

apps/server/src/tasks/reminder/reminder.service.ts

@@ -15,67 +15,65 @@ import { MessageService } from '@server/models/message/message.service';
  */
 @Injectable()
 export class ReminderService {
-    /**
+  /**
-     * 日志记录器实例
+   * 日志记录器实例
-     * @private
+   * @private
-     */
+   */
-    private readonly logger = new Logger(ReminderService.name);
+  private readonly logger = new Logger(ReminderService.name);
 
-    /**
+  /**
-     * 构造函数
+   * 构造函数
-     * @param messageService 消息服务实例
+   * @param messageService 消息服务实例
-     */
+   */
-    constructor(private readonly messageService: MessageService) { }
+  constructor(private readonly messageService: MessageService) {}
 
-    /**
+  /**
-     * 生成提醒时间点
+   * 生成提醒时间点
-     * @param totalDays 总天数
+   * @param totalDays 总天数
-     * @returns 提醒时间点数组
+   * @returns 提醒时间点数组
-     */
+   */
-    generateReminderTimes(totalDays: number): number[] {
+  generateReminderTimes(totalDays: number): number[] {
-        // 如果总天数小于3天则不需要提醒
+    // 如果总天数小于3天则不需要提醒
-        if (totalDays < 3) return [];
+    if (totalDays < 3) return [];
-        // 使用Set存储提醒时间点,避免重复
+    // 使用Set存储提醒时间点,避免重复
-        const reminders: Set<number> = new Set();
+    const reminders: Set<number> = new Set();
-        // 按照2的幂次方划分时间点
+    // 按照2的幂次方划分时间点
-        for (let i = 1; i <= totalDays / 2; i++) {
+    for (let i = 1; i <= totalDays / 2; i++) {
-            reminders.add(Math.ceil(totalDays / Math.pow(2, i)));
+      reminders.add(Math.ceil(totalDays / Math.pow(2, i)));
-        }
-        // 将Set转为数组并升序排序
-        return Array.from(reminders).sort((a, b) => a - b);
     }
+    // 将Set转为数组并升序排序
+    return Array.from(reminders).sort((a, b) => a - b);
+  }
 
-    /**
+  /**
-     * 判断是否需要发送提醒
+   * 判断是否需要发送提醒
-     * @param createdAt 创建时间
+   * @param createdAt 创建时间
-     * @param deadline 截止时间
+   * @param deadline 截止时间
-     * @returns 是否需要提醒及剩余天数
+   * @returns 是否需要提醒及剩余天数
-     */
+   */
-    shouldSendReminder(createdAt: Date, deadline: Date) {
+  shouldSendReminder(createdAt: Date, deadline: Date) {
-        // 获取当前时间
+    // 获取当前时间
-        const now = dayjs();
+    const now = dayjs();
-        const end = dayjs(deadline);
+    const end = dayjs(deadline);
-        // 计算总时间和剩余时间(天)
+    // 计算总时间和剩余时间(天)
-        const totalTimeDays = end.diff(createdAt, 'day');
+    const totalTimeDays = end.diff(createdAt, 'day');
-        const timeLeftDays = end.diff(now, 'day');
+    const timeLeftDays = end.diff(now, 'day');
 
-        if (totalTimeDays > 1) {
+    if (totalTimeDays > 1) {
-            // 获取提醒时间点
+      // 获取提醒时间点
-            const reminderTimes = this.generateReminderTimes(totalTimeDays);
+      const reminderTimes = this.generateReminderTimes(totalTimeDays);
-            // 如果剩余时间在提醒时间点内,则需要提醒
+      // 如果剩余时间在提醒时间点内,则需要提醒
-            if (reminderTimes.includes(timeLeftDays)) {
+      if (reminderTimes.includes(timeLeftDays)) {
-                return { shouldSend: true, timeLeft: timeLeftDays };
+        return { shouldSend: true, timeLeft: timeLeftDays };
-            }
+      }
-        }
-        return { shouldSend: false, timeLeft: timeLeftDays };
     }
+    return { shouldSend: false, timeLeft: timeLeftDays };
+  }
 
-    /**
+  /**
-     * 发送截止日期提醒
+   * 发送截止日期提醒
-     */
+   */
-    async remindDeadline() {
+  async remindDeadline() {
-        this.logger.log('开始检查截止日期以发送提醒。');
+    this.logger.log('开始检查截止日期以发送提醒。');
-
+  }
-   
-    }
 }

apps/server/src/tasks/tasks.module.ts

@@ -1,9 +1,9 @@
 import { Module } from '@nestjs/common';
 import { TasksService } from './tasks.service';
 import { InitModule } from '@server/tasks/init/init.module';
-import { ReminderModule } from "@server/tasks/reminder/reminder.module"
+import { ReminderModule } from '@server/tasks/reminder/reminder.module';
 @Module({
   imports: [InitModule, ReminderModule],
-  providers: [TasksService]
+  providers: [TasksService],
 })
-export class TasksModule { }
+export class TasksModule {}

apps/server/src/tasks/tasks.service.ts

@@ -6,41 +6,47 @@ import { CronJob } from 'cron';
 
 @Injectable()
 export class TasksService implements OnModuleInit {
-    private readonly logger = new Logger(TasksService.name);
+  private readonly logger = new Logger(TasksService.name);
 
-    constructor(
+  constructor(
-        private readonly schedulerRegistry: SchedulerRegistry,
+    private readonly schedulerRegistry: SchedulerRegistry,
-        private readonly initService: InitService,
+    private readonly initService: InitService,
-        private readonly reminderService: ReminderService
+    private readonly reminderService: ReminderService,
-    ) { }
+  ) {}
 
-    async onModuleInit() {
+  async onModuleInit() {
-        this.logger.log('Main node launch');
+    this.logger.log('Main node launch');
-        await this.initService.init();
+    await this.initService.init();
-        this.logger.log('Initialization successful');
+    this.logger.log('Initialization successful');
 
+    try {
+      const cronExpression = process.env.DEADLINE_CRON;
+      if (!cronExpression) {
+        throw new Error('DEADLINE_CRON environment variable is not set');
+      }
+
+      const handleRemindJob = new CronJob(cronExpression, async () => {
         try {
-            const cronExpression = process.env.DEADLINE_CRON;
+          await this.reminderService.remindDeadline();
-            if (!cronExpression) {
+          this.logger.log('Reminder successfully processed');
-                throw new Error('DEADLINE_CRON environment variable is not set');
+        } catch (reminderErr) {
-            }
+          this.logger.error(
-
+            'Error occurred while processing reminder',
-            const handleRemindJob = new CronJob(cronExpression, async () => {
+            reminderErr,
-                try {
+          );
-                    await this.reminderService.remindDeadline();
-                    this.logger.log('Reminder successfully processed');
-                } catch (reminderErr) {
-                    this.logger.error('Error occurred while processing reminder', reminderErr);
-                }
-            });
-
-            this.schedulerRegistry.addCronJob('remindDeadline', handleRemindJob as any);
-            this.logger.log('Start remind cron job');
-            handleRemindJob.start();
-        } catch (cronJobErr) {
-            this.logger.error('Failed to initialize cron job', cronJobErr);
-            // Optionally rethrow the error if you want to halt further execution
-            // throw cronJobErr;
         }
+      });
+
+      this.schedulerRegistry.addCronJob(
+        'remindDeadline',
+        handleRemindJob as any,
+      );
+      this.logger.log('Start remind cron job');
+      handleRemindJob.start();
+    } catch (cronJobErr) {
+      this.logger.error('Failed to initialize cron job', cronJobErr);
+      // Optionally rethrow the error if you want to halt further execution
+      // throw cronJobErr;
     }
+  }
 }

apps/server/src/trpc/trpc.module.ts

@@ -40,7 +40,7 @@ import { SportProjectModule } from '@server/models/sport-project/sportProject.mo
     TrainContentModule,
     TrainSituationModule,
     DailyTrainModule,
-    SportProjectModule
+    SportProjectModule,
   ],
   controllers: [],
   providers: [TrpcService, TrpcRouter, Logger],

apps/server/src/trpc/trpc.router.ts

@@ -37,10 +37,10 @@ export class TrpcRouter {
     private readonly visitor: VisitRouter,
     private readonly resource: ResourceRouter,
     private readonly trainContent: TrainContentRouter,
-    private readonly trainSituation:TrainSituationRouter,
+    private readonly trainSituation: TrainSituationRouter,
-    private readonly dailyTrain:DailyTrainRouter,
+    private readonly dailyTrain: DailyTrainRouter,
-    private readonly sportStandard:SportStandardRouter,
+    private readonly sportStandard: SportStandardRouter,
-    private readonly sportProject:SportProjectRouter
+    private readonly sportProject: SportProjectRouter,
   ) {}
   getRouter() {
     return;
@@ -58,11 +58,11 @@ export class TrpcRouter {
     app_config: this.app_config.router,
     visitor: this.visitor.router,
     resource: this.resource.router,
-    trainContent:this.trainContent.router,
+    trainContent: this.trainContent.router,
-    trainSituation:this.trainSituation.router,
+    trainSituation: this.trainSituation.router,
-    dailyTrain:this.dailyTrain.router,
+    dailyTrain: this.dailyTrain.router,
-    sportStandard:this.sportStandard.router,
+    sportStandard: this.sportStandard.router,
-    sportProject:this.sportProject.router
+    sportProject: this.sportProject.router,
   });
   wss: WebSocketServer = undefined;
 

apps/server/src/trpc/trpc.service.ts

@@ -18,8 +18,9 @@ export class TrpcService {
     ip: string;
   }> {
     const token = opts.req.headers.authorization?.split(' ')[1];
-    const staff =
+    const staff = await UserProfileService.instance.getUserProfileByToken(
-      await UserProfileService.instance.getUserProfileByToken(token);
+      token,
+    );
     const ip = getClientIp(opts.req);
     return {
       staff: staff.staff,

apps/server/src/utils/minio/minio.module.ts

@@ -3,6 +3,6 @@ import { MinioService } from './minio.service';
 
 @Module({
   providers: [MinioService],
-  exports: [MinioService]
+  exports: [MinioService],
 })
 export class MinioModule {}

apps/server/src/utils/redis/utils.ts

@@ -1,13 +1,13 @@
-import { redis } from "./redis.service";
+import { redis } from './redis.service';
 
 export async function deleteByPattern(pattern: string) {
-    try {
+  try {
-        const keys = await redis.keys(pattern);
+    const keys = await redis.keys(pattern);
-        if (keys.length > 0) {
+    if (keys.length > 0) {
-            await redis.del(keys);
+      await redis.del(keys);
-            // this.logger.log(`Deleted ${keys.length} keys matching pattern ${pattern}`);
+      // this.logger.log(`Deleted ${keys.length} keys matching pattern ${pattern}`);
-        }
-    } catch (error) {
-        console.error(`Failed to delete keys by pattern ${pattern}:`, error);
     }
+  } catch (error) {
+    console.error(`Failed to delete keys by pattern ${pattern}:`, error);
+  }
 }

apps/server/src/utils/tool.ts

@@ -1,148 +1,149 @@
-import { createReadStream } from "fs";
+import { createReadStream } from 'fs';
-import { createInterface } from "readline";
+import { createInterface } from 'readline';
 
-import {  db } from '@nice/common';
+import { db } from '@nice/common';
-import * as tus from "tus-js-client";
+import * as tus from 'tus-js-client';
 import ExcelJS from 'exceljs';
 
 export function truncateStringByByte(str, maxBytes) {
-    let byteCount = 0;
+  let byteCount = 0;
-    let index = 0;
+  let index = 0;
-    while (index < str.length && byteCount + new TextEncoder().encode(str[index]).length <= maxBytes) {
+  while (
-        byteCount += new TextEncoder().encode(str[index]).length;
+    index < str.length &&
-        index++;
+    byteCount + new TextEncoder().encode(str[index]).length <= maxBytes
-    }
+  ) {
-    return str.substring(0, index) + (index < str.length ? "..." : "");
+    byteCount += new TextEncoder().encode(str[index]).length;
+    index++;
+  }
+  return str.substring(0, index) + (index < str.length ? '...' : '');
 }
 export async function loadPoliciesFromCSV(filePath: string) {
-    const policies = {
+  const policies = {
-        p: [],
+    p: [],
-        g: []
+    g: [],
-    };
+  };
-    const stream = createReadStream(filePath);
+  const stream = createReadStream(filePath);
-    const rl = createInterface({
+  const rl = createInterface({
-        input: stream,
+    input: stream,
-        crlfDelay: Infinity
+    crlfDelay: Infinity,
-    });
+  });
 
-    // Updated regex to handle commas inside parentheses as part of a single field
+  // Updated regex to handle commas inside parentheses as part of a single field
-    const regex = /(?:\((?:[^)(]+|\((?:[^)(]+|\([^)(]*\))*\))*\)|"(?:\\"|[^"])*"|[^,"()\s]+)(?=\s*,|\s*$)/g;
+  const regex =
+    /(?:\((?:[^)(]+|\((?:[^)(]+|\([^)(]*\))*\))*\)|"(?:\\"|[^"])*"|[^,"()\s]+)(?=\s*,|\s*$)/g;
 
-    for await (const line of rl) {
+  for await (const line of rl) {
-        // Ignore empty lines and comments
+    // Ignore empty lines and comments
-        if (line.trim() && !line.startsWith("#")) {
+    if (line.trim() && !line.startsWith('#')) {
-            const parts = [];
+      const parts = [];
-            let match;
+      let match;
-            while ((match = regex.exec(line)) !== null) {
+      while ((match = regex.exec(line)) !== null) {
-                // Remove quotes if present and trim whitespace
+        // Remove quotes if present and trim whitespace
-                parts.push(match[0].replace(/^"|"$/g, '').trim());
+        parts.push(match[0].replace(/^"|"$/g, '').trim());
-            }
+      }
 
-            // Check policy type (p or g)
+      // Check policy type (p or g)
-            const ptype = parts[0];
+      const ptype = parts[0];
-            const rule = parts.slice(1);
+      const rule = parts.slice(1);
 
-            if (ptype === 'p' || ptype === 'g') {
+      if (ptype === 'p' || ptype === 'g') {
-                policies[ptype].push(rule);
+        policies[ptype].push(rule);
-            } else {
+      } else {
-                console.warn(`Unknown policy type '${ptype}' in policy: ${line}`);
+        console.warn(`Unknown policy type '${ptype}' in policy: ${line}`);
-            }
+      }
-        }
     }
+  }
 
-    return policies;
+  return policies;
 }
 
 export function uploadFile(blob: any, fileName: string) {
-    return new Promise((resolve, reject) => {
+  return new Promise((resolve, reject) => {
-        const upload = new tus.Upload(blob, {
+    const upload = new tus.Upload(blob, {
-            endpoint: `${process.env.TUS_URL}/files/`,
+      endpoint: `${process.env.TUS_URL}/files/`,
-            retryDelays: [0, 1000, 3000, 5000],
+      retryDelays: [0, 1000, 3000, 5000],
-            metadata: {
+      metadata: {
-                filename: fileName,
+        filename: fileName,
-                filetype:
+        filetype:
-                    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+          'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-            },
+      },
-            onError: (error) => {
+      onError: (error) => {
-                console.error("Failed because: " + error);
+        console.error('Failed because: ' + error);
-                reject(error); // 错误时，我们要拒绝 promise
+        reject(error); // 错误时，我们要拒绝 promise
-            },
+      },
-            onProgress: (bytesUploaded, bytesTotal) => {
+      onProgress: (bytesUploaded, bytesTotal) => {
-                const percentage = ((bytesUploaded / bytesTotal) * 100).toFixed(2);
+        const percentage = ((bytesUploaded / bytesTotal) * 100).toFixed(2);
-                // console.log(bytesUploaded, bytesTotal, `${percentage}%`);
+        // console.log(bytesUploaded, bytesTotal, `${percentage}%`);
-            },
+      },
-            onSuccess: () => {
+      onSuccess: () => {
-                // console.log('Upload finished:', upload.url);
+        // console.log('Upload finished:', upload.url);
-                resolve(upload.url); // 成功后，我们解析 promise，并返回上传的 URL
+        resolve(upload.url); // 成功后，我们解析 promise，并返回上传的 URL
-            },
+      },
-        });
-        upload.start();
     });
+    upload.start();
+  });
 }
 
-
 class TreeNode {
-    value: string;
+  value: string;
-    children: TreeNode[];
+  children: TreeNode[];
-
-    constructor(value: string) {
-        this.value = value;
-        this.children = [];
-    }
-
-    addChild(childValue: string): TreeNode {
-        let newChild = undefined
-        if (this.children.findIndex(child => child.value === childValue) === -1) {
-            newChild = new TreeNode(childValue);
-            this.children.push(newChild)
-
-        }
-        return this.children.find(child => child.value === childValue)
 
+  constructor(value: string) {
+    this.value = value;
+    this.children = [];
+  }
+
+  addChild(childValue: string): TreeNode {
+    let newChild = undefined;
+    if (this.children.findIndex((child) => child.value === childValue) === -1) {
+      newChild = new TreeNode(childValue);
+      this.children.push(newChild);
     }
+    return this.children.find((child) => child.value === childValue);
+  }
 }
 function buildTree(data: string[][]): TreeNode {
-    const root = new TreeNode('root');
+  const root = new TreeNode('root');
-    try {
+  try {
-        for (const path of data) {
+    for (const path of data) {
-            let currentNode = root;
+      let currentNode = root;
-            for (const value of path) {
+      for (const value of path) {
-                currentNode = currentNode.addChild(value);
+        currentNode = currentNode.addChild(value);
-            }
+      }
-        }
-        return root;
     }
-    catch (error) {
+    return root;
-        console.error(error)
+  } catch (error) {
-    }
+    console.error(error);
-
+  }
-
 }
 export function printTree(node: TreeNode, level: number = 0): void {
-    const indent = '  '.repeat(level);
+  const indent = '  '.repeat(level);
-    // console.log(`${indent}${node.value}`);
+  // console.log(`${indent}${node.value}`);
-    for (const child of node.children) {
+  for (const child of node.children) {
-        printTree(child, level + 1);
+    printTree(child, level + 1);
-    }
+  }
 }
 export async function generateTreeFromFile(file: Buffer): Promise<TreeNode> {
-    const workbook = new ExcelJS.Workbook();
+  const workbook = new ExcelJS.Workbook();
-    await workbook.xlsx.load(file);
+  await workbook.xlsx.load(file);
-    const worksheet = workbook.getWorksheet(1);
+  const worksheet = workbook.getWorksheet(1);
 
-    const data: string[][] = [];
+  const data: string[][] = [];
 
-    worksheet.eachRow((row, rowNumber) => {
+  worksheet.eachRow((row, rowNumber) => {
-        if (rowNumber > 1) { // Skip header row if any
+    if (rowNumber > 1) {
-            const rowData: string[] = (row.values as string[]).slice(2).map(cell => (cell || '').toString());
+      // Skip header row if any
-            data.push(rowData.map(value => value.trim()));
+      const rowData: string[] = (row.values as string[])
-        }
+        .slice(2)
-    });
+        .map((cell) => (cell || '').toString());
-    // Fill forward values
+      data.push(rowData.map((value) => value.trim()));
-    for (let i = 1; i < data.length; i++) {
-        for (let j = 0; j < data[i].length; j++) {
-            if (!data[i][j]) data[i][j] = data[i - 1][j];
-        }
     }
-    return buildTree(data);
+  });
+  // Fill forward values
+  for (let i = 1; i < data.length; i++) {
+    for (let j = 0; j < data[i].length; j++) {
+      if (!data[i][j]) data[i][j] = data[i - 1][j];
+    }
+  }
+  return buildTree(data);
 }

apps/server/src/validation/index.ts

@@ -2,17 +2,17 @@ import { PipeTransform, BadRequestException } from '@nestjs/common';
 import { ZodSchema } from 'zod';
 
 export class ZodValidationPipe implements PipeTransform {
-    constructor(private schema: ZodSchema) { }
+  constructor(private schema: ZodSchema) {}
 
-    transform(value: unknown) {
+  transform(value: unknown) {
-        try {
+    try {
-            const result = this.schema.parse(value);
+      const result = this.schema.parse(value);
-            return result;
+      return result;
-        } catch (error: any) {
+    } catch (error: any) {
-            throw new BadRequestException('Validation failed', {
+      throw new BadRequestException('Validation failed', {
-                cause: error,
+        cause: error,
-                description: error.errors
+        description: error.errors,
-            });
+      });
-        }
     }
+  }
 }

apps/web/index.html

@@ -14,7 +14,7 @@
 			VITE_APP_FILE_PORT: "$FILE_PORT",
 		};
 	</script>
-	<title>$APP_NAME</title>
+	<title>trainng_DATA</title>
 </head>
 
 <body>