add

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: [{
+  providers: [
+    {
       provide: APP_FILTER,
       useClass: ExceptionsFilter,
-  }],
+    },
+  ],
 })
-export class AppModule { }
+export class AppModule {}

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

@@ -12,7 +12,7 @@ import { extractTokenFromHeader } from './utils';
 
 @Injectable()
 export class AuthGuard implements CanActivate {
-    constructor(private jwtService: JwtService) { }
+  constructor(private jwtService: JwtService) {}
   async canActivate(context: ExecutionContext): Promise<boolean> {
     const request = context.switchToHttp().getRequest();
     const token = extractTokenFromHeader(request);
@@ -20,18 +20,13 @@ export class AuthGuard implements CanActivate {
       throw new UnauthorizedException();
     }
     try {
-            const payload: JwtPayload = await this.jwtService.verifyAsync(
-                token,
-                {
-                    secret: env.JWT_SECRET
-                }
-            );
+      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: [
-    AuthService,
-    TrpcService,
-    DepartmentService,
-    SessionService],
+  providers: [AuthService, TrpcService, DepartmentService, SessionService],
   exports: [AuthService],
   controllers: [AuthController],
 })
-export class AuthModule { }
+export class AuthModule {}

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

@@ -29,16 +29,21 @@ export class SessionService {
     const sessionInfo: SessionInfo = {
       session_id: uuidv4(),
       access_token: accessToken,
-            access_token_expires_at: Date.now() + expirationConfig.accessTokenExpirationMs,
+      access_token_expires_at:
+        Date.now() + expirationConfig.accessTokenExpirationMs,
       refresh_token: refreshToken,
-            refresh_token_expires_at: Date.now() + expirationConfig.refreshTokenExpirationMs,
+      refresh_token_expires_at:
+        Date.now() + expirationConfig.refreshTokenExpirationMs,
     };
 
     await this.saveSession(userId, sessionInfo, expirationConfig.sessionTTL);
     return sessionInfo;
   }
 
-    async getSession(userId: string, sessionId: string): Promise<SessionInfo | null> {
+  async getSession(
+    userId: string,
+    sessionId: string,
+  ): Promise<SessionInfo | null> {
     const sessionData = await redis.get(this.getSessionKey(userId, sessionId));
     return sessionData ? JSON.parse(sessionData) : null;
   }

apps/server/src/auth/types.ts

@@ -9,10 +9,10 @@ export interface TokenConfig {
 }
 
 export interface FileAuthResult {
-    isValid: boolean
-    userId?: string
-    resourceType?: string
-    error?: string
+  isValid: boolean;
+  userId?: string;
+  resourceType?: string;
+  error?: string;
 }
 export interface FileRequest {
   originalUri: string;
@@ -20,12 +20,12 @@ export interface FileRequest {
   method: string;
   queryParams: string;
   host: string;
-    authorization: string
+  authorization: string;
 }
 export enum FileValidationErrorType {
   INVALID_URI = 'INVALID_URI',
   RESOURCE_NOT_FOUND = 'RESOURCE_NOT_FOUND',
   AUTHORIZATION_REQUIRED = 'AUTHORIZATION_REQUIRED',
   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
-        ? this.departmentService.getAncestorIds([staff.deptId])
-        : [],
+      staff.deptId ? this.departmentService.getAncestorIds([staff.deptId]) : [],
       this.roleMapService.getPermsForObject({
         domainId: staff.domainId,
         staffId: staff.id,

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

@@ -3,9 +3,9 @@ import {
   NotFoundException,
   ConflictException,
   InternalServerErrorException,
-  } from '@nestjs/common';
+} from '@nestjs/common';
 
-  export const PrismaErrorCode = Object.freeze({
+export const PrismaErrorCode = Object.freeze({
   P2000: 'P2000',
   P2001: 'P2001',
   P2002: 'P2002',
@@ -35,32 +35,33 @@ import {
   P1002: 'P1002',
   P1015: 'P1015',
   P1017: 'P1017',
-  });
+});
 
-  export type PrismaErrorCode = keyof typeof PrismaErrorCode;
+export type PrismaErrorCode = keyof typeof PrismaErrorCode;
 
-  
-  interface PrismaErrorMeta {
+interface PrismaErrorMeta {
   target?: string;
   model?: string;
   relationName?: string;
   details?: string;
-  }
+}
 
-  export type operationT = 'create' | 'read' | 'update' | 'delete';
+export type operationT = 'create' | 'read' | 'update' | 'delete';
 
-  export type PrismaErrorHandler = (
+export type PrismaErrorHandler = (
   operation: operationT,
   meta?: PrismaErrorMeta,
-  ) => Error;
+) => Error;
 
-  export const ERROR_MAP: Record<PrismaErrorCode, PrismaErrorHandler> = {
-      P2000: (_operation, meta) => new BadRequestException(
-          `The provided value for ${meta?.target || 'a field'} is too long. Please use a shorter value.`
+export const ERROR_MAP: Record<PrismaErrorCode, PrismaErrorHandler> = {
+  P2000: (_operation, meta) =>
+    new BadRequestException(
+      `The provided value for ${meta?.target || 'a field'} is too long. Please use a shorter value.`,
     ),
 
-      P2001: (operation, meta) => new NotFoundException(
-          `The ${meta?.model || 'record'} you are trying to ${operation} could not be found.`
+  P2001: (operation, meta) =>
+    new NotFoundException(
+      `The ${meta?.model || 'record'} you are trying to ${operation} could not be found.`,
     ),
 
   P2002: (operation, meta) => {
@@ -68,131 +69,154 @@ import {
     switch (operation) {
       case 'create':
         return new ConflictException(
-                      `A record with the same ${field} already exists. Please use a different value.`
+          `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.`
+          `The new value for ${field} conflicts with an existing record.`,
         );
       default:
         return new ConflictException(
-                      `Unique constraint violation on ${field}.`
+          `Unique constraint violation on ${field}.`,
         );
     }
   },
 
-      P2003: (operation) => new BadRequestException(
-          `Foreign key constraint failed. Unable to ${operation} the record because related data is invalid or missing.`
+  P2003: (operation) =>
+    new BadRequestException(
+      `Foreign key constraint failed. Unable to ${operation} the record because related data is invalid or missing.`,
     ),
 
-      P2006: (_operation, meta) => new BadRequestException(
-          `The provided value for ${meta?.target || 'a field'} is invalid. Please correct it.`
+  P2006: (_operation, meta) =>
+    new BadRequestException(
+      `The provided value for ${meta?.target || 'a field'} is invalid. Please correct it.`,
     ),
 
-      P2007: (operation) => new InternalServerErrorException(
-          `Data validation error during ${operation}. Please ensure all inputs are valid and try again.`
+  P2007: (operation) =>
+    new InternalServerErrorException(
+      `Data validation error during ${operation}. Please ensure all inputs are valid and try again.`,
     ),
 
-      P2008: (operation) => new InternalServerErrorException(
-          `Failed to query the database during ${operation}. Please try again later.`
+  P2008: (operation) =>
+    new InternalServerErrorException(
+      `Failed to query the database during ${operation}. Please try again later.`,
     ),
 
-      P2009: (operation) => new InternalServerErrorException(
-          `Invalid data fetched during ${operation}. Check query structure.`
+  P2009: (operation) =>
+    new InternalServerErrorException(
+      `Invalid data fetched during ${operation}. Check query structure.`,
     ),
 
-      P2010: () => new InternalServerErrorException(
-          `Invalid raw query. Ensure your query is correct and try again.`
+  P2010: () =>
+    new InternalServerErrorException(
+      `Invalid raw query. Ensure your query is correct and try again.`,
     ),
 
-      P2011: (_operation, meta) => new BadRequestException(
-          `The required field ${meta?.target || 'a field'} is missing. Please provide it to continue.`
+  P2011: (_operation, meta) =>
+    new BadRequestException(
+      `The required field ${meta?.target || 'a field'} is missing. Please provide it to continue.`,
     ),
 
-      P2012: (operation, meta) => new BadRequestException(
-          `Missing required relation ${meta?.relationName || ''}. Ensure all related data exists before ${operation}.`
+  P2012: (operation, meta) =>
+    new BadRequestException(
+      `Missing required relation ${meta?.relationName || ''}. Ensure all related data exists before ${operation}.`,
     ),
 
   P2014: (operation) => {
     switch (operation) {
       case 'create':
         return new BadRequestException(
-                      `Cannot create record because the referenced data does not exist. Ensure related data exists.`
+          `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.`
+          `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(
-          `A record with the required ID was expected but not found. Please retry.`
+  P2015: () =>
+    new InternalServerErrorException(
+      `A record with the required ID was expected but not found. Please retry.`,
     ),
 
-      P2016: (operation) => new InternalServerErrorException(
-          `Query ${operation} failed because the record could not be fetched. Ensure the query is correct.`
+  P2016: (operation) =>
+    new InternalServerErrorException(
+      `Query ${operation} failed because the record could not be fetched. Ensure the query is correct.`,
     ),
 
-      P2017: (operation) => new InternalServerErrorException(
-          `Connected records were not found for ${operation}. Check related data.`
+  P2017: (operation) =>
+    new InternalServerErrorException(
+      `Connected records were not found for ${operation}. Check related data.`,
     ),
 
-      P2018: () => new InternalServerErrorException(
-          `The required connection could not be established. Please check relationships.`
+  P2018: () =>
+    new InternalServerErrorException(
+      `The required connection could not be established. Please check relationships.`,
     ),
 
-      P2019: (_operation, meta) => new InternalServerErrorException(
-          `Invalid input for ${meta?.details || 'a field'}. Please ensure data conforms to expectations.`
+  P2019: (_operation, meta) =>
+    new InternalServerErrorException(
+      `Invalid input for ${meta?.details || 'a field'}. Please ensure data conforms to expectations.`,
     ),
 
-      P2021: (_operation, meta) => new InternalServerErrorException(
-          `The ${meta?.model || 'model'} was not found in the database.`
+  P2021: (_operation, meta) =>
+    new InternalServerErrorException(
+      `The ${meta?.model || 'model'} was not found in the database.`,
     ),
 
-      P2025: (operation, meta) => new NotFoundException(
-          `The ${meta?.model || 'record'} you are trying to ${operation} does not exist. It may have been deleted.`
+  P2025: (operation, meta) =>
+    new NotFoundException(
+      `The ${meta?.model || 'record'} you are trying to ${operation} does not exist. It may have been deleted.`,
     ),
 
-      P2031: () => new InternalServerErrorException(
-          `Invalid Prisma Client initialization error. Please check configuration.`
+  P2031: () =>
+    new InternalServerErrorException(
+      `Invalid Prisma Client initialization error. Please check configuration.`,
     ),
 
-      P2033: (operation) => new InternalServerErrorException(
-          `Insufficient database write permissions for ${operation}.`
+  P2033: (operation) =>
+    new InternalServerErrorException(
+      `Insufficient database write permissions for ${operation}.`,
     ),
 
-      P2034: (operation) => new InternalServerErrorException(
-          `Database read-only transaction failed during ${operation}.`
+  P2034: (operation) =>
+    new InternalServerErrorException(
+      `Database read-only transaction failed during ${operation}.`,
     ),
 
-      P2037: (operation) => new InternalServerErrorException(
-          `Unsupported combinations of input types for ${operation}. Please correct the query or input.`
+  P2037: (operation) =>
+    new InternalServerErrorException(
+      `Unsupported combinations of input types for ${operation}. Please correct the query or input.`,
     ),
 
-      P1000: () => new InternalServerErrorException(
-          `Database authentication failed. Verify your credentials and try again.`
+  P1000: () =>
+    new InternalServerErrorException(
+      `Database authentication failed. Verify your credentials and try again.`,
     ),
 
-      P1001: () => new InternalServerErrorException(
-          `The database server could not be reached. Please check its availability.`
+  P1001: () =>
+    new InternalServerErrorException(
+      `The database server could not be reached. Please check its availability.`,
     ),
 
-      P1002: () => new InternalServerErrorException(
-          `Connection to the database timed out. Verify network connectivity and server availability.`
+  P1002: () =>
+    new InternalServerErrorException(
+      `Connection to the database timed out. Verify network connectivity and server availability.`,
     ),
 
-      P1015: (operation) => 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.`
+  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,25 +1,28 @@
-import { UserProfile, RowModelRequest, RowRequestSchema } from "@nice/common";
-import { RowModelService } from "./row-model.service";
-import { isFieldCondition, LogicalCondition, SQLBuilder } from "./sql-builder";
-import EventBus from "@server/utils/event-bus";
-import supejson from "superjson-cjs"
-import { deleteByPattern } from "@server/utils/redis/utils";
-import { redis } from "@server/utils/redis/redis.service";
-import { z } from "zod";
+import { UserProfile, RowModelRequest, RowRequestSchema } from '@nice/common';
+import { RowModelService } from './row-model.service';
+import { isFieldCondition, LogicalCondition, SQLBuilder } from './sql-builder';
+import EventBus from '@server/utils/event-bus';
+import supejson from 'superjson-cjs';
+import { deleteByPattern } from '@server/utils/redis/utils';
+import { redis } from '@server/utils/redis/redis.service';
+import { z } from 'zod';
 export class RowCacheService extends RowModelService {
-    constructor(tableName: string, private enableCache: boolean = true) {
-        super(tableName)
+  constructor(
+    tableName: string,
+    private enableCache: boolean = true,
+  ) {
+    super(tableName);
     if (this.enableCache) {
-            EventBus.on("dataChanged", async ({ type, data }) => {
+      EventBus.on('dataChanged', async ({ type, data }) => {
         if (type === tableName) {
           const dataArray = Array.isArray(data) ? data : [data];
           for (const item of dataArray) {
             try {
               if (item.id) {
-                                this.invalidateRowCacheById(item.id)
+                this.invalidateRowCacheById(item.id);
               }
               if (item.parentId) {
-                                this.invalidateRowCacheById(item.parentId)
+                this.invalidateRowCacheById(item.parentId);
               }
             } catch (err) {
               console.error(`Error deleting cache for type ${tableName}:`, err);
@@ -38,21 +41,15 @@ export class RowCacheService extends RowModelService {
     await deleteByPattern(pattern);
   }
   createJoinSql(request?: RowModelRequest): string[] {
-        return []
+    return [];
   }
-    protected async getRowRelation(args: { data: any, staff?: UserProfile }) {
+  protected async getRowRelation(args: { data: any; staff?: UserProfile }) {
     return args.data;
   }
-    protected async setResPermissions(
-        data: any,
-        staff?: UserProfile,
-    ) {
-        return data
+  protected async setResPermissions(data: any, staff?: UserProfile) {
+    return data;
   }
-    protected async getRowDto(
-        data: any,
-        staff?: UserProfile,
-    ): Promise<any> {
+  protected async getRowDto(data: any, staff?: UserProfile): Promise<any> {
     // 如果没有id，直接返回原数据
     if (!data?.id) return data;
     // 如果未启用缓存，直接处理并返回数据
@@ -77,25 +74,21 @@ export class RowCacheService extends RowModelService {
 
   private async getCachedData(
     key: string,
-        staff?: UserProfile
+    staff?: UserProfile,
   ): Promise<any | null> {
     const cachedDataStr = await redis.get(key);
     if (!cachedDataStr) return null;
     const cachedData = supejson.parse(cachedDataStr) as any;
     if (!cachedData?.id) return null;
-        return staff
-            ? this.setResPermissions(cachedData, staff)
-            : cachedData;
+    return staff ? this.setResPermissions(cachedData, staff) : cachedData;
   }
 
   private async processDataWithPermissions(
     data: any,
-        staff?: UserProfile
+    staff?: UserProfile,
   ): Promise<any> {
     // 处理权限
-        const permData = staff
-            ? await this.setResPermissions(data, staff)
-            : data;
+    const permData = staff ? await this.setResPermissions(data, staff) : data;
     // 获取关联数据
     return this.getRowRelation({ data: permData, staff });
   }

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;
   }

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

@@ -1,21 +1,38 @@
 export interface FieldCondition {
   field: string;
-    op: OperatorType
-    type?: "text" | "number" | "date";
+  op: OperatorType;
+  type?: 'text' | 'number' | 'date';
   value?: any;
   valueTo?: any;
-};
-export type OperatorType = 'equals' | 'notEqual' | 'contains' | 'startsWith' | 'endsWith' | 'blank' | 'notBlank' | 'greaterThan' | 'lessThanOrEqual' | 'inRange' | 'lessThan' | 'greaterThan' | 'in';
-export type LogicalCondition = FieldCondition | {
+}
+export type OperatorType =
+  | 'equals'
+  | 'notEqual'
+  | '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(
+  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) {
     case 'equals':
       return `${field} = '${value}'`;
@@ -28,15 +45,11 @@ function buildCondition(condition: FieldCondition): string {
     case 'endsWith':
       return `${field} LIKE '%${value}'`;
     case 'blank':
-            if (type !== "date")
-                return `(${field} IS NULL OR ${field} = '')`;
-            else
-                return `${field} IS NULL`;
+      if (type !== 'date') return `(${field} IS NULL OR ${field} = '')`;
+      else return `${field} IS NULL`;
     case 'notBlank':
-            if (type !== 'date')
-                return `${field} IS NOT NULL AND ${field} != ''`;
-            else
-                return `${field} IS NOT NULL`;
+      if (type !== 'date') return `${field} IS NOT NULL AND ${field} != ''`;
+      else return `${field} IS NOT NULL`;
     case 'greaterThan':
       return `${field} > '${value}'`;
     case 'lessThanOrEqual':
@@ -52,7 +65,7 @@ function buildCondition(condition: FieldCondition): string {
         // Return a condition that is always false if value is empty or an empty array
         return '1 = 0';
       }
-            return `${field} IN (${(value as any[]).map(val => `'${val}'`).join(', ')})`;
+      return `${field} IN (${(value as any[]).map((val) => `'${val}'`).join(', ')})`;
     default:
       return 'true'; // Default return for unmatched conditions
   }
@@ -63,18 +76,18 @@ function buildLogicalCondition(logicalCondition: LogicalCondition): string {
   }
   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
+    const andParts = logicalCondition.AND.map((c) =>
+      buildLogicalCondition(c),
+    ).filter((part) => part !== ''); // Filter out empty conditions
     if (andParts.length > 0) {
       parts.push(`(${andParts.join(' AND ')})`);
     }
   }
   // Process OR conditions
   if (logicalCondition.OR && logicalCondition.OR.length > 0) {
-        const orParts = logicalCondition.OR
-            .map(c => buildLogicalCondition(c))
-            .filter(part => part !== ''); // Filter out empty conditions
+    const orParts = logicalCondition.OR.map((c) =>
+      buildLogicalCondition(c),
+    ).filter((part) => part !== ''); // Filter out empty conditions
     if (orParts.length > 0) {
       parts.push(`(${orParts.join(' OR ')})`);
     }
@@ -85,12 +98,18 @@ function buildLogicalCondition(logicalCondition: LogicalCondition): string {
 
 export class SQLBuilder {
   static select(fields: string[], distinctField?: string): string {
-        const distinctClause = distinctField ? `DISTINCT ON (${distinctField}) ` : "";
-        return `SELECT ${distinctClause}${fields.join(", ")}`;
+    const distinctClause = distinctField
+      ? `DISTINCT ON (${distinctField}) `
+      : '';
+    return `SELECT ${distinctClause}${fields.join(', ')}`;
   }
-    static rowNumber(orderBy: string, partitionBy: string | null = null, alias: string = 'row_num'): string {
+  static rowNumber(
+    orderBy: string,
+    partitionBy: string | null = null,
+    alias: string = 'row_num',
+  ): string {
     if (!orderBy) {
-            throw new Error("orderBy 参数不能为空");
+      throw new Error('orderBy 参数不能为空');
     }
 
     let partitionClause = '';
@@ -106,15 +125,15 @@ export class SQLBuilder {
 
   static where(conditions: LogicalCondition): string {
     const whereClause = buildLogicalCondition(conditions);
-        return whereClause ? `WHERE ${whereClause}` : "";
+    return whereClause ? `WHERE ${whereClause}` : '';
   }
 
   static groupBy(columns: string[]): string {
-        return columns.length ? `GROUP BY ${columns.join(", ")}` : "";
+    return columns.length ? `GROUP BY ${columns.join(', ')}` : '';
   }
 
   static orderBy(columns: string[]): string {
-        return columns.length ? `ORDER BY ${columns.join(", ")}` : "";
+    return columns.length ? `ORDER BY ${columns.join(', ')}` : '';
   }
 
   static limit(pageSize: number, offset: number = 0): string {
@@ -125,14 +144,27 @@ export class SQLBuilder {
     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> = {
+    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)
-
+      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/rbac/rbac.module.ts

@@ -8,7 +8,13 @@ import { DepartmentModule } from '../department/department.module';
 
 @Module({
   imports: [DepartmentModule],
-  providers: [RoleMapService, RoleRouter, TrpcService, RoleService, RoleMapRouter],
-  exports: [RoleRouter, RoleService, RoleMapService, RoleMapRouter]
+  providers: [
+    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,21 +3,21 @@ 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 RoleUpdateArgsSchema: ZodType<Prisma.RoleUpdateArgs> = z.any()
-const RoleCreateManyInputSchema: ZodType<Prisma.RoleCreateManyInput> = z.any()
-const RoleDeleteManyArgsSchema: ZodType<Prisma.RoleDeleteManyArgs> = z.any()
-const RoleFindManyArgsSchema: ZodType<Prisma.RoleFindManyArgs> = z.any()
-const RoleFindFirstArgsSchema: ZodType<Prisma.RoleFindFirstArgs> = z.any()
-const RoleWhereInputSchema: ZodType<Prisma.RoleWhereInput> = z.any()
-const RoleSelectSchema: ZodType<Prisma.RoleSelect> = z.any()
+const RoleCreateArgsSchema: ZodType<Prisma.RoleCreateArgs> = z.any();
+const RoleUpdateArgsSchema: ZodType<Prisma.RoleUpdateArgs> = z.any();
+const RoleCreateManyInputSchema: ZodType<Prisma.RoleCreateManyInput> = z.any();
+const RoleDeleteManyArgsSchema: ZodType<Prisma.RoleDeleteManyArgs> = z.any();
+const RoleFindManyArgsSchema: ZodType<Prisma.RoleFindManyArgs> = z.any();
+const RoleFindFirstArgsSchema: ZodType<Prisma.RoleFindFirstArgs> = z.any();
+const RoleWhereInputSchema: ZodType<Prisma.RoleWhereInput> = z.any();
+const RoleSelectSchema: ZodType<Prisma.RoleSelect> = z.any();
 const RoleUpdateInputSchema: ZodType<Prisma.RoleUpdateInput> = z.any();
 @Injectable()
 export class RoleRouter {
   constructor(
     private readonly trpc: TrpcService,
     private readonly roleService: RoleService,
-    ) { }
+  ) {}
   router = this.trpc.router({
     create: this.trpc.protectProcedure
       .input(RoleCreateArgsSchema)
@@ -31,7 +31,8 @@ export class RoleRouter {
         const { staff } = ctx;
         return await this.roleService.update(input, staff);
       }),
-        createMany: this.trpc.protectProcedure.input(z.array(RoleCreateManyInputSchema))
+    createMany: this.trpc.protectProcedure
+      .input(z.array(RoleCreateManyInputSchema))
       .mutation(async ({ ctx, input }) => {
         const { staff } = ctx;
 
@@ -41,7 +42,7 @@ export class RoleRouter {
       .input(
         z.object({
           ids: z.array(z.string()),
-                    data: RoleUpdateInputSchema.optional()
+          data: RoleUpdateInputSchema.optional(),
         }),
       )
       .mutation(async ({ input }) => {
@@ -64,23 +65,27 @@ export class RoleRouter {
         return await this.roleService.findMany(input);
       }),
     findManyWithCursor: this.trpc.protectProcedure
-            .input(z.object({
+      .input(
+        z.object({
           cursor: z.any().nullish(),
           take: z.number().optional(),
           where: RoleWhereInputSchema.optional(),
-                select: RoleSelectSchema.optional()
-            }))
+          select: RoleSelectSchema.optional(),
+        }),
+      )
       .query(async ({ ctx, input }) => {
         const { staff } = ctx;
         return await this.roleService.findManyWithCursor(input);
       }),
     findManyWithPagination: this.trpc.procedure
-            .input(z.object({
+      .input(
+        z.object({
           page: z.number(),
           pageSize: z.number().optional(),
           where: RoleWhereInputSchema.optional(),
-                select: RoleSelectSchema.optional()
-            })) // Assuming StaffMethodSchema.findMany is the Zod schema for finding staffs by keyword
+          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,45 +1,57 @@
-import { db, ObjectType, RowModelRequest, RowRequestSchema, UserProfile } from "@nice/common";
-import { RowCacheService } from "../base/row-cache.service";
-import { isFieldCondition, LogicalCondition } from "../base/sql-builder";
-import { z } from "zod";
+import {
+  db,
+  ObjectType,
+  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(
     request: z.infer<typeof RowRequestSchema>,
-        staff?: UserProfile
+    staff?: UserProfile,
   ) {
-        const condition = super.createGetRowsFilters(request)
-        if (isFieldCondition(condition))
-            return {}
-        const baseModelCondition: LogicalCondition[] = [{
+    const condition = super.createGetRowsFilters(request);
+    if (isFieldCondition(condition)) return {};
+    const baseModelCondition: LogicalCondition[] = [
+      {
         field: `${this.tableName}.deleted_at`,
-            op: "blank",
-            type: "date"
-        }]
-        condition.AND = [...baseModelCondition, ...condition.AND!]
-        return condition
+        op: 'blank',
+        type: 'date',
+      },
+    ];
+    condition.AND = [...baseModelCondition, ...condition.AND!];
+    return condition;
   }
   createUnGroupingRowSelect(): string[] {
     return [
       `${this.tableName}.id AS id`,
       `${this.tableName}.name AS name`,
       `${this.tableName}.system AS system`,
-            `${this.tableName}.permissions AS permissions`
+      `${this.tableName}.permissions AS permissions`,
     ];
   }
   protected async getRowDto(data: any, staff?: UserProfile): Promise<any> {
-        if (!data.id)
-            return data
+    if (!data.id) return data;
     const roleMaps = await db.roleMap.findMany({
       where: {
-                roleId: data.id
-            }
-        })
-        const deptIds = roleMaps.filter(item => item.objectType === ObjectType.DEPARTMENT).map(roleMap => roleMap.objectId)
-        const staffIds = roleMaps.filter(item => item.objectType === ObjectType.STAFF).map(roleMap => roleMap.objectId)
-        const depts = await db.department.findMany({ where: { id: { in: deptIds } } })
-        const staffs = await db.staff.findMany({ where: { id: { in: staffIds } } })
-        const result = { ...data, depts, staffs }
-        return result
+        roleId: data.id,
+      },
+    });
+    const deptIds = roleMaps
+      .filter((item) => item.objectType === ObjectType.DEPARTMENT)
+      .map((roleMap) => roleMap.objectId);
+    const staffIds = roleMaps
+      .filter((item) => item.objectType === ObjectType.STAFF)
+      .map((roleMap) => roleMap.objectId);
+    const depts = await db.department.findMany({
+      where: { id: { in: deptIds } },
+    });
+    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 {
-  ObjectType,
-  RoleMapMethodSchema,
-} from '@nice/common';
+import { 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(
-    row: any,
-    staff?: UserProfile,
-  ): Promise<any> {
+  protected async getRowDto(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(
+      result.map(async (item) => {
         const staff = await db.staff.findMany({
           include: { department: true },
           where: {
-          id: item.objectId
-        }
-      })
-      return { ...item, staff }
-    }))
+            id: item.objectId,
+          },
+        });
+        return { ...item, staff };
+      }),
+    );
     return wrapResult;
   }
   async addRoleForObjects(
@@ -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 { FileMetadata, VideoMetadata, ResourceProcessor } from "../types";
-import { Resource, ResourceStatus, db } from "@nice/common";
-import { Logger } from "@nestjs/common";
+import path, { dirname } from 'path';
+import { FileMetadata, VideoMetadata, ResourceProcessor } from '../types';
+import { Resource, ResourceStatus, db } from '@nice/common';
+import { Logger } from '@nestjs/common';
 import fs from 'fs/promises';
 
 export abstract class BaseProcessor implements ResourceProcessor {
-    constructor() { }
-    protected logger = new Logger(BaseProcessor.name)
+  constructor() {}
+  protected logger = new Logger(BaseProcessor.name);
 
-    abstract process(resource: Resource): Promise<Resource>
-    protected createOutputDir(filepath: string, subdirectory: string = 'assets'): string {
-        const outputDir = path.join(
-            path.dirname(filepath),
-            subdirectory,
+  abstract process(resource: Resource): Promise<Resource>;
+  protected createOutputDir(
+    filepath: string,
+    subdirectory: string = 'assets',
+  ): 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;
-    
   }
 }
 //

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

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

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

@@ -1,4 +1,4 @@
-import { Injectable ,Logger} from '@nestjs/common';
+import { Injectable, Logger } from '@nestjs/common';
 import { BaseService } from '../base/base.service';
 
 import {

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

@@ -1,20 +1,20 @@
-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
-    resource: Resource
-    error?: Error
+  success: boolean;
+  resource: Resource;
+  error?: Error;
 }
 
 export interface BaseMetadata {
-    size: number
-    filetype: string
-    filename: string
-    extension: string
-    modifiedAt: Date
+  size: number;
+  filetype: string;
+  filename: string;
+  extension: string;
+  modifiedAt: Date;
 }
 /**
  * 图片特有元数据接口
@@ -37,7 +37,7 @@ export interface VideoMetadata {
   duration?: number;
   videoCodec?: string;
   audioCodec?: string;
-    coverUrl?: string
+  coverUrl?: string;
 }
 
 /**
@@ -51,5 +51,7 @@ export interface AudioMetadata {
   codec?: string; // 音频编码格式
 }
 
-
-export type FileMetadata = ImageMetadata & VideoMetadata & AudioMetadata & BaseMetadata
+export type FileMetadata = ImageMetadata &
+  VideoMetadata &
+  AudioMetadata &
+  BaseMetadata;

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/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/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: [
-    DepartmentModule,
-    StaffModule,
-    TermModule,
-    TaxonomyModule,
-  ],
+  imports: [DepartmentModule, StaffModule, TermModule, TaxonomyModule],
   providers: [TransformService, TransformRouter, TrpcService],
   exports: [TransformRouter, TransformService],
   // controllers:[TransformController]

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

@@ -1,7 +1,6 @@
-
-import { WebSocketServer, WebSocket } from "ws";
-import { Logger } from "@nestjs/common";
-import { WebSocketServerConfig, WSClient, WebSocketType } from "../types";
+import { WebSocketServer, WebSocket } from 'ws';
+import { Logger } from '@nestjs/common';
+import { WebSocketServerConfig, WSClient, WebSocketType } from '../types';
 import { SocketMessage } from '@nice/common';
 
 const DEFAULT_CONFIG: WebSocketServerConfig = {
@@ -25,9 +24,7 @@ export abstract class BaseWebSocketServer implements IWebSocketServer {
   protected readonly logger = new Logger(this.constructor.name);
   protected readonly finalConfig: WebSocketServerConfig;
   private userClientMap: Map<string, WSClient> = new Map();
-    constructor(
-        protected readonly config: Partial<WebSocketServerConfig> = {}
-    ) {
+  constructor(protected readonly config: Partial<WebSocketServerConfig> = {}) {
     this.finalConfig = {
       ...DEFAULT_CONFIG,
       ...config,
@@ -39,7 +36,7 @@ export abstract class BaseWebSocketServer implements IWebSocketServer {
     }
   }
   public getClientCount() {
-        return this.clients.size
+    return this.clients.size;
   }
   // 暴露 WebSocketServer 实例的只读访问
   public get wss(): WebSocketServer | null {
@@ -62,7 +59,7 @@ export abstract class BaseWebSocketServer implements IWebSocketServer {
 
     this._wss = new WebSocketServer({
       noServer: true,
-            path: this.serverPath
+      path: this.serverPath,
     });
 
     this.debugLog(`WebSocket server starting on path: ${this.serverPath}`);
@@ -76,12 +73,12 @@ export abstract class BaseWebSocketServer implements IWebSocketServer {
       this.pingIntervalId = undefined;
     }
 
-        this.clients.forEach(client => client.close());
+    this.clients.forEach((client) => client.close());
     this.clients.clear();
     this.timeouts.clear();
 
     if (this._wss) {
-            await new Promise(resolve => this._wss!.close(resolve));
+      await new Promise((resolve) => this._wss!.close(resolve));
       this._wss = null;
     }
 
@@ -89,33 +86,36 @@ export abstract class BaseWebSocketServer implements IWebSocketServer {
   }
 
   public broadcast(data: SocketMessage): void {
-        this.clients.forEach(client =>
-            client.readyState === WebSocket.OPEN && client.send(JSON.stringify(data))
+    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)
+    client?.send(message);
   }
   public sendToUsers(ids: string[], data: SocketMessage) {
     const message = JSON.stringify(data);
-        ids.forEach(id => {
+    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 => {
+    this.clients.forEach((client) => {
       if (client.readyState === WebSocket.OPEN && client.roomId === roomId) {
-                client.send(message)
+        client.send(message);
       }
-        })
+    });
   }
   protected getRoomClientsCount(roomId?: string): number {
     if (!roomId) return 0;
-        return Array.from(this.clients).filter(client => client.roomId === roomId).length;
+    return Array.from(this.clients).filter((client) => client.roomId === roomId)
+      .length;
   }
 
   public handleConnection(ws: WSClient): void {
@@ -161,7 +161,10 @@ export abstract class BaseWebSocketServer implements IWebSocketServer {
     ws.on('pong', () => this.handlePong(ws))
       .on('close', () => this.handleDisconnection(ws))
       .on('error', (error) => {
-                this.logger.error(`[${this.serverType}] client error on path ${this.serverPath}:`, error);
+        this.logger.error(
+          `[${this.serverType}] client error on path ${this.serverPath}:`,
+          error,
+        );
         this.handleDisconnection(ws);
       });
   }
@@ -178,19 +181,19 @@ export abstract class BaseWebSocketServer implements IWebSocketServer {
   private startPingInterval(): void {
     this.pingIntervalId = setInterval(
       () => this.pingClients(),
-            this.finalConfig.pingInterval
+      this.finalConfig.pingInterval,
     );
   }
 
   private pingClients(): void {
-        this.clients.forEach(ws => {
+    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.finalConfig.pingTimeout,
       );
       this.timeouts.set(ws, timeout);
     });
@@ -200,6 +203,8 @@ export abstract class BaseWebSocketServer implements IWebSocketServer {
     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));
+      .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<
+    string,
+    {
       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 'Map': return doc.getMap(objName);
-    case 'Text': return doc.getText(objName);
-    case 'XmlFragment': return doc.getXmlFragment(objName);
-    case 'XmlElement': return doc.getXmlElement(objName);
-    default: return {};
+    case 'Array':
+      return doc.getArray(objName);
+    case 'Map':
+      return doc.getMap(objName);
+    case 'Text':
+      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;
   gc: boolean;
-  }
-  
+}

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

@@ -1,17 +1,28 @@
 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_MAXWAIT = parseInt(process.env.CALLBACK_DEBOUNCE_MAXWAIT || '10000');
+export const CALLBACK_DEBOUNCE_WAIT = parseInt(
+  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);
 };
@@ -27,7 +38,9 @@ export const send = (doc: WSSharedDoc, conn: WebSocket, m: Uint8Array) => {
     return;
   }
   try {
-        conn.send(m, {}, err => { err != null && closeConn(doc, conn) });
+    conn.send(m, {}, (err) => {
+      err != null && closeConn(doc, conn);
+    });
   } catch (e) {
     closeConn(doc, conn);
   }
@@ -36,14 +49,12 @@ export const closeConn = (doc: WSSharedDoc, conn: WebSocket) => {
   if (doc.conns.has(conn)) {
     const controlledIds = doc.conns.get(conn) as Set<number>;
     doc.conns.delete(conn);
-        removeAwarenessStates(
-            doc.awareness,
-            Array.from(controlledIds),
-            null
-        );
+    removeAwarenessStates(doc.awareness, Array.from(controlledIds), null);
 
     if (doc.conns.size === 0 && getPersistence() !== null) {
-            getPersistence()?.writeState(doc.name, doc).then(() => {
+      getPersistence()
+        ?.writeState(doc.name, doc)
+        .then(() => {
           doc.destroy();
         });
       docs.delete(doc.name);
@@ -52,7 +63,11 @@ export const closeConn = (doc: WSSharedDoc, conn: WebSocket) => {
   conn.close();
 };
 
-export const messageListener = (conn: WSClient, doc: WSSharedDoc, message: Uint8Array) => {
+export const messageListener = (
+  conn: WSClient,
+  doc: WSSharedDoc,
+  message: Uint8Array,
+) => {
   try {
     const encoder = encoding.createEncoder();
     const decoder = decoding.createDecoder(message);
@@ -71,7 +86,7 @@ export const messageListener = (conn: WSClient, doc: WSSharedDoc, message: Uint8
         applyAwarenessUpdate(
           doc.awareness,
           decoding.readVarUint8Array(decoder),
-                    conn
+          conn,
         );
         // console.log(`received awareness message from ${conn.origin} total ${doc.awareness.states.size}`)
         break;
@@ -83,7 +98,12 @@ export const messageListener = (conn: WSClient, doc: WSSharedDoc, message: Uint8
   }
 };
 
-const updateHandler = (update: Uint8Array, _origin: any, doc: WSSharedDoc, _tr: any) => {
+const updateHandler = (
+  update: Uint8Array,
+  _origin: any,
+  doc: WSSharedDoc,
+  _tr: any,
+) => {
   const encoder = encoding.createEncoder();
   encoding.writeVarUint(encoder, YMessageType.Sync);
   writeUpdate(encoder, update);
@@ -91,7 +111,8 @@ const updateHandler = (update: Uint8Array, _origin: any, doc: WSSharedDoc, _tr:
   doc.conns.forEach((_, conn) => send(doc, conn, message));
 };
 
-let contentInitializor: (ydoc: Y.Doc) => Promise<void> = (_ydoc) => Promise.resolve();
+let contentInitializor: (ydoc: Y.Doc) => Promise<void> = (_ydoc) =>
+  Promise.resolve();
 export const setContentInitializor = (f: (ydoc: Y.Doc) => Promise<void>) => {
   contentInitializor = f;
 };
@@ -110,22 +131,29 @@ export class WSSharedDoc extends Y.Doc {
     this.awareness = new Awareness(this);
     this.awareness.setLocalState(null);
 
-        const awarenessUpdateHandler = ({
+    const awarenessUpdateHandler = (
+      {
         added,
         updated,
-            removed
+        removed,
       }: {
-            added: number[],
-            updated: number[],
-            removed: number[]
-        }, conn: WebSocket) => {
+        added: number[];
+        updated: number[];
+        removed: number[];
+      },
+      conn: WebSocket,
+    ) => {
       const changedClients = added.concat(updated, removed);
-            if (changedClients.length === 0) return
+      if (changedClients.length === 0) return;
       if (conn !== null) {
         const connControlledIDs = this.conns.get(conn) as Set<number>;
         if (connControlledIDs !== undefined) {
-                    added.forEach(clientID => { connControlledIDs.add(clientID); });
-                    removed.forEach(clientID => { connControlledIDs.delete(clientID); });
+          added.forEach((clientID) => {
+            connControlledIDs.add(clientID);
+          });
+          removed.forEach((clientID) => {
+            connControlledIDs.delete(clientID);
+          });
         }
       }
 
@@ -133,7 +161,7 @@ export class WSSharedDoc extends Y.Doc {
       encoding.writeVarUint(encoder, YMessageType.Awareness);
       encoding.writeVarUint8Array(
         encoder,
-                encodeAwarenessUpdate(this.awareness, changedClients)
+        encodeAwarenessUpdate(this.awareness, changedClients),
       );
       const buff = encoding.toUint8Array(encoder);
 
@@ -146,11 +174,12 @@ export class WSSharedDoc extends Y.Doc {
     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.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,25 +1,36 @@
-import { Injectable } from "@nestjs/common";
-import { WebSocketType, WSClient } from "../types";
-import { BaseWebSocketServer } from "../base/base-websocket-server";
-import { encoding } from "lib0";
-import { YMessageType, writeSyncStep1, encodeAwarenessUpdate } from "@nice/common";
-import { getYDoc, closeConn, WSSharedDoc, messageListener, send } from "./ws-shared-doc";
+import { Injectable } from '@nestjs/common';
+import { WebSocketType, WSClient } from '../types';
+import { BaseWebSocketServer } from '../base/base-websocket-server';
+import { encoding } from 'lib0';
+import {
+  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 {
     return WebSocketType.YJS;
   }
-    public override handleConnection(
-        connection: WSClient
-    ): void {
-        super.handleConnection(connection)
+  public override handleConnection(connection: WSClient): void {
+    super.handleConnection(connection);
     try {
       connection.binaryType = 'arraybuffer';
       const doc = this.initializeDocument(connection, connection.roomId, true);
       this.setupConnectionHandlers(connection, doc);
       this.sendInitialSync(connection, doc);
     } catch (error: any) {
-            this.logger.error(`Error in handleNewConnection: ${error.message}`, error.stack);
+      this.logger.error(
+        `Error in handleNewConnection: ${error.message}`,
+        error.stack,
+      );
       connection.close();
     }
   }
@@ -31,7 +42,10 @@ export class YjsServer extends BaseWebSocketServer {
     return doc;
   }
 
-    private setupConnectionHandlers(connection: WSClient, doc: WSSharedDoc): void {
+  private setupConnectionHandlers(
+    connection: WSClient,
+    doc: WSSharedDoc,
+  ): void {
     connection.on('message', (message: ArrayBuffer) => {
       this.handleMessage(connection, doc, message);
     });
@@ -39,9 +53,14 @@ export class YjsServer extends BaseWebSocketServer {
       this.handleClose(doc, connection);
     });
     connection.on('error', (error) => {
-            this.logger.error(`WebSocket error for doc ${doc.name}: ${error.message}`, error.stack);
+      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}`);
+      this.logger.warn(
+        `Connection closed due to error for doc: ${doc.name}. Remaining connections: ${doc.conns.size}`,
+      );
     });
   }
 
@@ -49,14 +68,24 @@ export class YjsServer extends BaseWebSocketServer {
     try {
       closeConn(doc, connection);
     } 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 {
+  private handleMessage(
+    connection: WSClient,
+    doc: WSSharedDoc,
+    message: ArrayBuffer,
+  ): void {
     try {
       messageListener(connection, doc, new Uint8Array(message));
     } catch (error: any) {
-            this.logger.error(`Error handling message: ${error.message}`, error.stack);
+      this.logger.error(
+        `Error handling message: ${error.message}`,
+        error.stack,
+      );
     }
   }
   private sendInitialSync(connection: WSClient, doc: any): void {
@@ -77,7 +106,10 @@ export class YjsServer extends BaseWebSocketServer {
       encoding.writeVarUint(encoder, YMessageType.Awareness);
       encoding.writeVarUint8Array(
         encoder,
-                encodeAwarenessUpdate(doc.awareness, Array.from(awarenessStates.keys()))
+        encodeAwarenessUpdate(
+          doc.awareness,
+          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],
-    exports: [ RealtimeServer]
+  providers: [RealtimeServer],
+  exports: [RealtimeServer],
 })
-export class RealTimeModule { }
+export class RealTimeModule {}

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

@@ -1,23 +1,23 @@
-import { Injectable, OnModuleInit } from "@nestjs/common";
-import { WebSocketType } from "../types";
-import { BaseWebSocketServer } from "../base/base-websocket-server";
-import EventBus, { CrudOperation } from "@server/utils/event-bus";
-import { ObjectType, SocketMsgType } from "@nice/common";
+import { Injectable, OnModuleInit } from '@nestjs/common';
+import { WebSocketType } from '../types';
+import { BaseWebSocketServer } from '../base/base-websocket-server';
+import EventBus, { CrudOperation } from '@server/utils/event-bus';
+import { ObjectType, SocketMsgType } from '@nice/common';
 @Injectable()
-export class RealtimeServer extends BaseWebSocketServer implements OnModuleInit {
+export class RealtimeServer
+  extends BaseWebSocketServer
+  implements OnModuleInit
+{
   onModuleInit() {
-        EventBus.on("dataChanged", ({ data, type, operation }) => {
+    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) {
       //     const post = data as Partial<PostDto>
-
       // }
-        })
-
+    });
   }
   public get serverType(): WebSocketType {
     return WebSocketType.REALTIME;

apps/server/src/socket/types.ts

@@ -1,16 +1,16 @@
-import { WebSocketServer, WebSocket } from "ws";
+import { WebSocketServer, WebSocket } from 'ws';
 
 // 类型定义
 export enum WebSocketType {
-    YJS = "yjs",
-    REALTIME = "realtime"
+  YJS = 'yjs',
+  REALTIME = 'realtime',
 }
 
 export interface WebSocketServerConfig {
   path?: string;
   pingInterval?: number;
   pingTimeout?: number;
-    debug?: boolean
+  debug?: boolean;
 }
 
 export interface ServerInstance {
@@ -23,7 +23,7 @@ export interface ServerInstance {
 export interface WSClient extends WebSocket {
   isAlive?: boolean;
   type?: WebSocketType;
-    userId?: string
-    origin?: string
-    roomId?: string
+  userId?: string;
+  origin?: 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,9 +1,9 @@
-import { Injectable, Logger } from "@nestjs/common";
-import { Server } from "http";
-import { WSClient } from "./types";
-import { RealtimeServer } from "./realtime/realtime.server";
-import { YjsServer } from "./collaboration/yjs.server";
-import { BaseWebSocketServer } from "./base/base-websocket-server";
+import { Injectable, Logger } from '@nestjs/common';
+import { Server } from 'http';
+import { WSClient } from './types';
+import { RealtimeServer } from './realtime/realtime.server';
+import { YjsServer } from './collaboration/yjs.server';
+import { BaseWebSocketServer } from './base/base-websocket-server';
 
 @Injectable()
 export class WebSocketService {
@@ -11,14 +11,14 @@ export class WebSocketService {
   private readonly servers: BaseWebSocketServer[] = [];
   constructor(
     private realTimeServer: RealtimeServer,
-        private yjsServer: YjsServer
+    private yjsServer: YjsServer,
   ) {
-        this.servers.push(this.realTimeServer)
-        this.servers.push(this.yjsServer)
+    this.servers.push(this.realTimeServer);
+    this.servers.push(this.yjsServer);
   }
   public async initialize(httpServer: Server): Promise<void> {
     try {
-            await Promise.all(this.servers.map(server => server.start()));
+      await Promise.all(this.servers.map((server) => server.start()));
       this.setupUpgradeHandler(httpServer);
     } catch (error) {
       this.logger.error('Failed to initialize:', error);
@@ -36,7 +36,7 @@ export class WebSocketService {
         const urlParams = new URLSearchParams(url.search);
         const roomId = urlParams.get('roomId');
         const userId = urlParams.get('userId');
-                const server = this.servers.find(server => {
+        const server = this.servers.find((server) => {
           const serverPathClean = server.serverPath.replace(/\/$/, '');
           const pathnameClean = pathname.replace(/\/$/, '');
           return serverPathClean === pathnameClean;
@@ -48,8 +48,8 @@ export class WebSocketService {
 
         server.wss!.handleUpgrade(request, socket, head, (ws: WSClient) => {
           ws.userId = userId;
-                    ws.origin = request.url
-                    ws.roomId = roomId
+          ws.origin = request.url;
+          ws.roomId = roomId;
           server.wss!.emit('connection', ws, request);
         });
       } catch (error) {

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

@@ -38,7 +38,7 @@ export class GenDevService {
     private readonly departmentService: DepartmentService,
     private readonly staffService: StaffService,
     private readonly termService: TermService,
-  ) { }
+  ) {}
   async genDataEvent() {
     EventBus.emit('genDataEvent', { type: 'start' });
     try {
@@ -87,16 +87,57 @@ export class GenDevService {
 
     // 定义网系类别
     const systemTypes = [
-      { name: '文印系统', children: ['电源故障', '主板故障', '内存故障', '硬盘故障', '显示器故障', '键盘故障', '鼠标故障'] },
-      { name: '内网系统', children: ['系统崩溃', '应用程序错误', '病毒感染', '驱动问题', '系统更新失败'] },
-      { name: 'Windows系统', children: ['系统响应慢', '资源占用过高', '过热', '电池寿命短', '存储空间不足'] },
-      { name: 'Linux系统', children: ['未知错误', '用户操作错误', '环境因素', '设备老化'] },
-      { name: '移动设备系统', children: ['参数设置错误', '配置文件损坏', '兼容性问题', '初始化失败'] },
+      {
+        name: '文印系统',
+        children: [
+          '电源故障',
+          '主板故障',
+          '内存故障',
+          '硬盘故障',
+          '显示器故障',
+          '键盘故障',
+          '鼠标故障',
+        ],
+      },
+      {
+        name: '内网系统',
+        children: [
+          '系统崩溃',
+          '应用程序错误',
+          '病毒感染',
+          '驱动问题',
+          '系统更新失败',
+        ],
+      },
+      {
+        name: 'Windows系统',
+        children: [
+          '系统响应慢',
+          '资源占用过高',
+          '过热',
+          '电池寿命短',
+          '存储空间不足',
+        ],
+      },
+      {
+        name: 'Linux系统',
+        children: ['未知错误', '用户操作错误', '环境因素', '设备老化'],
+      },
+      {
+        name: '移动设备系统',
+        children: ['参数设置错误', '配置文件损坏', '兼容性问题', '初始化失败'],
+      },
     ];
 
     // 定义安防设备的子类型
     const securityDevices = {
-      未知错误: ['未授权访问', '数据泄露', '密码重置', '权限异常', '安全策略冲突'] ,
+      未知错误: [
+        '未授权访问',
+        '数据泄露',
+        '密码重置',
+        '权限异常',
+        '安全策略冲突',
+      ],
     };
 
     // 创建网系类别及其关联的设备类型

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

@@ -4,6 +4,6 @@ import { ReminderService } from './reminder.service';
 @Module({
   imports: [],
   providers: [ReminderService],
-  exports: [ReminderService]
+  exports: [ReminderService],
 })
-export class ReminderModule { }
+export class ReminderModule {}

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

@@ -8,7 +8,6 @@
 import { Injectable, Logger } from '@nestjs/common';
 import dayjs from 'dayjs';
 
-
 /**
  * 提醒服务类
  */
@@ -24,7 +23,7 @@ export class ReminderService {
    * 构造函数
    * @param messageService 消息服务实例
    */
-    constructor() { }
+  constructor() {}
 
   /**
    * 生成提醒时间点
@@ -74,7 +73,5 @@ export class ReminderService {
    */
   async remindDeadline() {
     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

@@ -11,8 +11,8 @@ export class TasksService implements OnModuleInit {
   constructor(
     private readonly schedulerRegistry: SchedulerRegistry,
     private readonly initService: InitService,
-        private readonly reminderService: ReminderService
-    ) { }
+    private readonly reminderService: ReminderService,
+  ) {}
 
   async onModuleInit() {
     this.logger.log('Main node launch');
@@ -30,11 +30,17 @@ export class TasksService implements OnModuleInit {
           await this.reminderService.remindDeadline();
           this.logger.log('Reminder successfully processed');
         } catch (reminderErr) {
-                    this.logger.error('Error occurred while processing reminder', reminderErr);
+          this.logger.error(
+            'Error occurred while processing reminder',
+            reminderErr,
+          );
         }
       });
 
-            this.schedulerRegistry.addCronJob('remindDeadline', handleRemindJob as any);
+      this.schedulerRegistry.addCronJob(
+        'remindDeadline',
+        handleRemindJob as any,
+      );
       this.logger.log('Start remind cron job');
       handleRemindJob.start();
     } catch (cronJobErr) {

apps/server/src/upload/upload.controller.ts

@@ -66,5 +66,4 @@ export class UploadController {
   async handleUpload(@Req() req: Request, @Res() res: Response) {
     return this.tusService.handleTus(req, res);
   }
-
 }

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,4 +1,4 @@
-import { redis } from "./redis.service";
+import { redis } from './redis.service';
 
 export async function deleteByPattern(pattern: string) {
   try {

apps/server/src/utils/tool.ts

@@ -1,36 +1,40 @@
-import { createReadStream } from "fs";
-import { createInterface } from "readline";
+import { createReadStream } from 'fs';
+import { createInterface } from 'readline';
 
 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 index = 0;
-    while (index < str.length && byteCount + new TextEncoder().encode(str[index]).length <= maxBytes) {
+  while (
+    index < str.length &&
+    byteCount + new TextEncoder().encode(str[index]).length <= maxBytes
+  ) {
     byteCount += new TextEncoder().encode(str[index]).length;
     index++;
   }
-    return str.substring(0, index) + (index < str.length ? "..." : "");
+  return str.substring(0, index) + (index < str.length ? '...' : '');
 }
 export async function loadPoliciesFromCSV(filePath: string) {
   const policies = {
     p: [],
-        g: []
+    g: [],
   };
   const stream = createReadStream(filePath);
   const rl = createInterface({
     input: stream,
-        crlfDelay: Infinity
+    crlfDelay: Infinity,
   });
 
   // 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) {
     // Ignore empty lines and comments
-        if (line.trim() && !line.startsWith("#")) {
+    if (line.trim() && !line.startsWith('#')) {
       const parts = [];
       let match;
       while ((match = regex.exec(line)) !== null) {
@@ -61,10 +65,10 @@ export function uploadFile(blob: any, fileName: string) {
       metadata: {
         filename: fileName,
         filetype:
-                    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+          'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
       },
       onError: (error) => {
-                console.error("Failed because: " + error);
+        console.error('Failed because: ' + error);
         reject(error); // 错误时，我们要拒绝 promise
       },
       onProgress: (bytesUploaded, bytesTotal) => {
@@ -80,7 +84,6 @@ export function uploadFile(blob: any, fileName: string) {
   });
 }
 
-
 class TreeNode {
   value: string;
   children: TreeNode[];
@@ -91,14 +94,12 @@ class TreeNode {
   }
 
   addChild(childValue: string): TreeNode {
-        let newChild = undefined
-        if (this.children.findIndex(child => child.value === childValue) === -1) {
+    let newChild = undefined;
+    if (this.children.findIndex((child) => child.value === childValue) === -1) {
       newChild = new TreeNode(childValue);
-            this.children.push(newChild)
-
+      this.children.push(newChild);
     }
-        return this.children.find(child => child.value === childValue)
-
+    return this.children.find((child) => child.value === childValue);
   }
 }
 function buildTree(data: string[][]): TreeNode {
@@ -111,12 +112,9 @@ function buildTree(data: string[][]): TreeNode {
       }
     }
     return root;
+  } catch (error) {
+    console.error(error);
   }
-    catch (error) {
-        console.error(error)
-    }
-
-
 }
 export function printTree(node: TreeNode, level: number = 0): void {
   const indent = '  '.repeat(level);
@@ -133,9 +131,12 @@ export async function generateTreeFromFile(file: Buffer): Promise<TreeNode> {
   const data: string[][] = [];
 
   worksheet.eachRow((row, rowNumber) => {
-        if (rowNumber > 1) { // Skip header row if any
-            const rowData: string[] = (row.values as string[]).slice(2).map(cell => (cell || '').toString());
-            data.push(rowData.map(value => value.trim()));
+    if (rowNumber > 1) {
+      // Skip header row if any
+      const rowData: string[] = (row.values as string[])
+        .slice(2)
+        .map((cell) => (cell || '').toString());
+      data.push(rowData.map((value) => value.trim()));
     }
   });
   // Fill forward values

apps/server/src/validation/index.ts

@@ -2,7 +2,7 @@ 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) {
     try {
@@ -11,7 +11,7 @@ export class ZodValidationPipe implements PipeTransform {
     } catch (error: any) {
       throw new BadRequestException('Validation failed', {
         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>故障检索</title>
 </head>
 
 <body>

apps/web/src/app/main/devicepage/dashboard/page.tsx

@@ -1,8 +1,388 @@
+import { useState, useEffect, useRef } from 'react';
+import { Card, Row, Col, DatePicker, Select, Spin } from 'antd';
+import ReactECharts from 'echarts-for-react';
+import dayjs from 'dayjs';
+import { api } from "@nice/client";
+
+const { RangePicker } = DatePicker;
+const { Option } = Select;
+
 const DashboardPage = () => {
+    const [dateRange, setDateRange] = useState<[dayjs.Dayjs, dayjs.Dayjs]>([
+        dayjs().subtract(30, 'days'),
+        dayjs()
+    ]);
+    const [loading, setLoading] = useState(true);
+
+
+    // 使用useRef跟踪是否已执行过刷新
+    const hasRefetched = useRef(false);
+
+    // 获取网系类别数据
+    const { data: systemTypeTerms, isLoading: loadingTypes, refetch: refetchSypes } = api.term.findMany.useQuery({
+        where: {
+            taxonomy: { slug: "system_type" },
+            deletedAt: null,
+        },
+        orderBy: { order: "asc" },
+    });
+
+    // 获取设备故障数据
+    const { data: devices, isLoading: loadingDevices, refetch: refetchDevices } = api.device.findMany.useQuery({
+        where: {
+            deletedAt: null,
+            createdAt: {
+                // 将开始日期设置为当天的开始时间 00:00:00
+                gte: dateRange[0].startOf('day').toISOString(),
+                // 将结束日期设置为当天的结束时间 23:59:59
+                lte: dateRange[1].endOf('day').toISOString(),
+            }
+        },
+        include: {
+            department: true,
+        },
+    });
+    useEffect(() => {
+        // 只在数据加载完成后执行一次刷新
+        if (!loadingTypes && !loadingDevices && !hasRefetched.current) {
+            // 标记为已执行
+            hasRefetched.current = true
+            // 刷新数据
+            refetchSypes();
+            refetchDevices();
+            setLoading(false);
+        }
+    }, [loadingTypes, loadingDevices]);
+
+
+    // 处理日期范围变化
+    const handleDateRangeChange = (dates, dateStrings) => {
+        if (dates) {
+            setDateRange([dates[0], dates[1]]);
+        } else {
+            setDateRange([dayjs().subtract(30, 'days'), dayjs()]);
+        }
+    };
+
+    // 准备各个网系故障情况数据（按时间段）
+    const prepareSystemFaultsByTimeData = () => {
+        if (!devices || !systemTypeTerms) return { xAxis: [], series: [] };
+
+        // 获取选择的日期范围
+        const startDate = dateRange[0];
+        const endDate = dateRange[1];
+        const diffDays = endDate.diff(startDate, 'day');
+
+        // 根据时间跨度选择合适的间隔
+        const intervals = [];
+        let format = '';
+
+        if (diffDays <= 14) {
+            // 小于等于两周，按天展示
+            format = 'MM-DD';
+            for (let i = 0; i <= diffDays; i++) {
+                intervals.push(startDate.add(i, 'day'));
+            }
+        } else if (diffDays <= 90) {
+            // 小于等于3个月，按周展示
+            format = 'MM-DD';
+            const weeks = Math.ceil(diffDays / 7);
+            for (let i = 0; i < weeks; i++) {
+                const weekStart = startDate.add(i * 7, 'day');
+                intervals.push(weekStart);
+            }
+        } else {
+            // 大于3个月，按月展示
+            format = 'YYYY-MM';
+            const months = Math.ceil(diffDays / 30);
+            for (let i = 0; i < months; i++) {
+                const monthStart = startDate.add(i, 'month').startOf('month');
+                intervals.push(monthStart);
+            }
+        }
+
+        // 格式化时间段显示
+        const timeLabels = intervals.map(date => {
+            if (diffDays <= 14) {
+                return date.format(format);
+            } else if (diffDays <= 90) {
+                return `${date.format(format)}至${date.add(6, 'day').format(format)}`;
+            } else {
+                return date.format(format);
+            }
+        });
+
+        // 统计每个网系在每个时间段的故障数
+        const systemNames = systemTypeTerms.map(type => type.name);
+        const systemIdMap = {};
+        systemTypeTerms.forEach(type => {
+            systemIdMap[type.id] = type.name;
+        });
+
+        const seriesData = systemNames.map(name => ({
+            name,
+            type: 'bar',
+            data: new Array(intervals.length).fill(0)
+        }));
+
+        devices.forEach(device => {
+            const systemName = systemIdMap[device.systemType] || '未知';
+            const systemIndex = systemNames.indexOf(systemName);
+            if (systemIndex !== -1) {
+                const createDate = dayjs(device.createdAt);
+
+                for (let i = 0; i < intervals.length; i++) {
+                    const nextInterval = null;
+
+                    if (diffDays <= 14) {
+                        // 按天，检查是否是同一天
+                        if (createDate.format('YYYY-MM-DD') === intervals[i].format('YYYY-MM-DD')) {
+                            seriesData[systemIndex].data[i]++;
+                        }
+                    } else if (diffDays <= 90) {
+                        // 按周，检查是否在这周内
+                        const weekEnd = intervals[i].add(6, 'day').endOf('day');
+                        if (createDate.isAfter(intervals[i]) && createDate.isBefore(weekEnd)) {
+                            seriesData[systemIndex].data[i]++;
+                        }
+                    } else {
+                        // 按月，检查是否在这个月内
+                        const monthEnd = intervals[i].endOf('month');
+                        if (createDate.isAfter(intervals[i]) && createDate.isBefore(monthEnd)) {
+                            seriesData[systemIndex].data[i]++;
+                        }
+                    }
+                }
+            }
+        });
+
+        return {
+            xAxis: timeLabels,
+            series: seriesData
+        };
+    };
+
+    // 准备各个网系故障率数据
+    const prepareSystemFaultRateData = () => {
+        if (!devices || !systemTypeTerms) return { names: [], values: [] };
+
+        const systemCounts = {};
+        const totalDevices = devices.length;
+        console.log("devices", devices.length);
+
+        // 初始化所有网系的计数
+        systemTypeTerms.forEach(type => {
+            systemCounts[type.name] = 0;
+        });
+
+        // 统计每个网系的故障数
+        devices.forEach(device => {
+            const systemType = systemTypeTerms?.find(t => t.id === device.systemType);
+            if (systemType) {
+                systemCounts[systemType.name] = (systemCounts[systemType.name] || 0) + 1;
+            }
+        });
+
+        const names = Object.keys(systemCounts);
+        const values = names.map(name => ({
+            value: totalDevices ? ((systemCounts[name] / totalDevices) * 100).toFixed(2) : 0,
+            name
+        }));
+
+        return { names, values };
+    };
+
+    // 准备故障处置完成率数据
+    const prepareFaultCompletionRateData = () => {
+        if (!devices) return { value: 0 };
+        const completedFaults = devices.filter(device =>
+            device.deviceStatus === 'normal'
+        ).length;
+
+        const totalFaults = devices.length;
+        const completionRate = totalFaults ? (completedFaults / totalFaults) * 100 : 0;
+
+        return { value: parseFloat(completionRate.toFixed(2)) };
+    };
+
+    // 网系故障时间段分布选项
+    const getSystemFaultsByTimeOption = () => {
+        const data = prepareSystemFaultsByTimeData();
+        return {
+            title: {
+                text: '各网系故障时间分布',
+                left: 'center'
+            },
+            tooltip: {
+                trigger: 'axis',
+                axisPointer: {
+                    type: 'shadow'
+                }
+            },
+            legend: {
+                data: data.series.map(item => item.name),
+                bottom: 10
+            },
+            grid: {
+                left: '3%',
+                right: '4%',
+                bottom: '15%',
+                top: '15%',
+                containLabel: true
+            },
+            xAxis: {
+                type: 'category',
+                data: data.xAxis
+            },
+            yAxis: {
+                type: 'value',
+                name: '故障数量'
+            },
+            series: data.series
+        };
+    };
+
+    // 网系故障率选项
+    const getSystemFaultRateOption = () => {
+        const data = prepareSystemFaultRateData();
+        return {
+            title: {
+                text: '各网系故障率',
+                left: 'center'
+            },
+            tooltip: {
+                trigger: 'item',
+                formatter: '{a} <br/>{b}: {c}%'
+            },
+            legend: {
+                orient: 'vertical',
+                left: 10,
+                top: 'center',
+                data: data.names
+            },
+            series: [
+                {
+                    name: '故障率',
+                    type: 'pie',
+                    radius: ['40%', '70%'],
+                    avoidLabelOverlap: false,
+                    itemStyle: {
+                        borderRadius: 10,
+                        borderColor: '#fff',
+                        borderWidth: 2
+                    },
+                    label: {
+                        show: true,
+                        formatter: '{b}: {c}%'
+                    },
+                    emphasis: {
+                        label: {
+                            show: true,
+                            fontSize: '15',
+                            fontWeight: 'bold'
+                        }
+                    },
+                    data: data.values
+                }
+            ]
+        };
+    };
+
+    // 故障处置完成率选项
+    const getFaultCompletionRateOption = () => {
+        const data = prepareFaultCompletionRateData();
+        return {
+            title: {
+                text: '故障处置完成率',
+                left: 'center'
+            },
+            tooltip: {
+                formatter: '{a} <br/>{b} : {c}%'
+            },
+            series: [
+                {
+                    name: '完成率',
+                    type: 'gauge',
+                    detail: { formatter: '{value}%' },
+                    data: [{ value: data.value, name: '完成率' }],
+                    axisLine: {
+                        lineStyle: {
+                            width: 30,
+                            color: [
+                                [0.3, '#ff6e76'],
+                                [0.7, '#fddd60'],
+                                [1, '#7cffb2']
+                            ]
+                        }
+                    },
+                    pointer: {
+                        itemStyle: {
+                            color: 'auto'
+                        }
+                    }
+                }
+            ]
+        };
+    };
 
     return (
-		<div className="min-h-screen">
-            <h1>Dashboard</h1>
+        <div className="p-4 min-h-screen bg-gray-50">
+            <h1 className="text-2xl font-bold mb-6">故障数据可视化面板</h1>
+            {/* <RangePicker
+                value={dateRange}
+                onChange={handleDateRangeChange}
+                format="YYYY-MM-DD"
+                className="mb-2"
+            /> */}
+
+            <Row className="mb-4">
+                <Col span={24}>
+                    <Card className="shadow-sm">
+                        <div className="flex justify-between items-center ">
+                            <span className="text-lg font-medium">数据筛选</span>
+                            <RangePicker
+                                value={dateRange}
+                                onChange={handleDateRangeChange}
+                                format="YYYY-MM-DD"
+                            />
+                        </div>
+                    </Card>
+                </Col>
+            </Row>
+
+            {loading ? (
+                <div className="flex justify-center items-center h-64">
+                    <Spin size="large" tip="数据加载中..." />
+                </div>
+            ) : (
+                <Row gutter={[16, 16]}>
+                    <Col span={12}>
+                        <Card className="shadow-sm hover:shadow-md transition-shadow duration-300">
+                            <ReactECharts
+                                option={getFaultCompletionRateOption()}
+                                style={{ height: '400px' }}
+                            />
+                        </Card>
+                    </Col>
+                    <Col span={12}>
+                        <Card className="shadow-sm hover:shadow-md transition-shadow duration-300">
+                            <ReactECharts
+                                option={getSystemFaultRateOption()}
+                                style={{ height: '400px' }}
+                            />
+                        </Card>
+                    </Col>
+
+                    <Col span={24}>
+                        <Card className="shadow-sm hover:shadow-md transition-shadow duration-300">
+                            <ReactECharts
+                                option={getSystemFaultsByTimeOption()}
+                                style={{ height: '450px' }}
+                            />
+                        </Card>
+                    </Col>
+                </Row>
+            )}
         </div>
     );
 };

apps/web/src/app/main/devicepage/devicemodal/page.tsx

@@ -85,7 +85,7 @@ export default function DeviceModal() {
                 label="故障名称 "
                 rules={[{ required: true, message: "请输入故障名称" }]}
               >
-                <Input className="rounded-lg" />
+                <Input className="rounded-lg" placeholder="请输入故障名称" />
               </Form.Item>
             </Col>  
           </Row>
@@ -98,11 +98,10 @@ export default function DeviceModal() {
     
             <Col span={8}>
               <Form.Item name="deviceStatus" label="故障状态">
-                <Select className="rounded-lg">
-                  <Select.Option value="normal">正常</Select.Option>
+                <Select className="rounded-lg" placeholder="请选择故障状态">
+                  <Select.Option value="normal">已修复</Select.Option>
                   <Select.Option value="maintenance">维修中</Select.Option>
-                  <Select.Option value="broken">损坏</Select.Option>
-                  <Select.Option value="idle">闲置</Select.Option>
+                  <Select.Option value="broken">未修复</Select.Option>
                 </Select>
               </Form.Item>
             </Col>

apps/web/src/app/main/devicepage/devicetable/page.tsx

@@ -1,4 +1,4 @@
-import { Button, Checkbox, Modal, Table, Upload } from "antd";
+import { Button, Checkbox, Modal, Table, Upload, Tag } from "antd"; // 添加 Tag 导入
 import { ColumnsType } from "antd/es/table";
 import { api, useDevice, useStaff } from "@nice/client";
 import { useEffect, useState, useImperativeHandle, forwardRef, useRef } from "react";
@@ -51,6 +51,8 @@ const DeviceTable = forwardRef(({ onSelectedChange }: DeviceTableProps, ref) =>
       enabled: true,
     }
   );
+  console.log("devices",devices);
+  
   const { data: systemTypeTerms, refetch: refetchSystemType } =
     api.term.findMany.useQuery({
       where: {
@@ -181,21 +183,39 @@ const DeviceTable = forwardRef(({ onSelectedChange }: DeviceTableProps, ref) =>
       key: "deviceStatus",
       align: "center",
       render: (status) => {
-        const statusMap = {
-          normal: "正常",
-          maintenance: "维修中",
-          broken: "损坏",
-          idle: "闲置"
-        };
-        return statusMap[status] || "未知";
+        const statusConfig = {
+          normal: {
+            text: "已修复",
+            color: "success"
           },
+          maintenance: {
+            text: "维修中",
+            color: "processing"
+          },
+          broken: {
+            text: "未修复",
+            color: "error"
+          }
+        };
+
+        const config = statusConfig[status] || {
+          text: "未知",
+          color: "default"
+        };
+
+        return (
+          <Tag color={config.color} style={{ minWidth: '60px' , textAlign: 'center' }}>
+            {config.text}
+          </Tag>
+        );
+      }
     },
     {
       title: "时间",
       dataIndex: "createdAt",
       key: "createdAt",
       align: "center",
-      render: (text, record) => record.createdAt ? dayjs(record.createdAt).format('YYYY-MM-DD') : "未知",
+      render: (text, record) => record.createdAt ? dayjs(record.createdAt).format('YYYY-MM-DD HH:mm:ss') : "未知",
     },
     {
       title: "操作",
@@ -262,7 +282,7 @@ const DeviceTable = forwardRef(({ onSelectedChange }: DeviceTableProps, ref) =>
         '故障名称': item?.showname || "未命名故障",
         '故障状态': (() => {
           const statusMap = {
-            normal: "正常",
+            normal: "已修复",
             maintenance: "维修中",
             broken: "损坏",
             idle: "闲置"
@@ -366,10 +386,9 @@ const DeviceTable = forwardRef(({ onSelectedChange }: DeviceTableProps, ref) =>
   // 获取状态键
   const getStatusKeyByValue = (value: string) => {
     const statusMap: Record<string, string> = {
-      "正常": "normal",
+      "已修复": "normal",
       "维修中": "maintenance",
-      "损坏": "broken",
-      "闲置": "idle"
+      "未修复 ": "broken",
     };
     return statusMap[value] || "normal";
   };
@@ -388,15 +407,12 @@ const DeviceTable = forwardRef(({ onSelectedChange }: DeviceTableProps, ref) =>
         toast.error("没有找到有效的记录数据");
         return;
       }
-
       // 设置批处理大小
       const batchSize = 5;
       let successCount = 0;
       let totalProcessed = 0;
-
       // 显示进度提示
       const loadingToast = toast.loading(`正在导入数据...`);
-
       // 分批处理数据
       for (let i = 0; i < validRecords.length; i += batchSize) {
         const batch = validRecords.slice(i, i + batchSize);
@@ -444,7 +460,7 @@ const DeviceTable = forwardRef(({ onSelectedChange }: DeviceTableProps, ref) =>
           '故障类型': deviceTypeTerms?.[0]?.name || '故障类型1',
           '单位': '单位名称',
           '故障名称': '示例故障名称',
-          '故障状态': '正常', // 可选值: 正常、维修中、损坏、闲置
+          '故障状态': '未修复', // 可选值:已修复, 维修中, 未修复
           '描述': '这是一个示例描述'
         }
       ];
@@ -490,7 +506,10 @@ const DeviceTable = forwardRef(({ onSelectedChange }: DeviceTableProps, ref) =>
       </div>
     ),
     preserveSelectedRowKeys: true // 这个属性保证翻页时选中状态不丢失
+  
   }
+ 
+  
   const TableHeader = () => (
     <div className="w-full flex justify-between mb-2">
       <span>
@@ -562,6 +581,10 @@ const DeviceTable = forwardRef(({ onSelectedChange }: DeviceTableProps, ref) =>
           pageSize: 10,
           showSizeChanger: true,
           pageSizeOptions: ["10", "20", "30"],
+          hideOnSinglePage: true,
+          responsive: true,
+          showTotal: (total, range) => `共${total} 条数据`,
+          showQuickJumper: true,
         }}
         components={{
           header: {

apps/web/src/app/main/devicepage/page.tsx

@@ -20,6 +20,7 @@ import DepartmentSelect from "@web/src/components/models/department/department-s
 import SystemTypeSelect from "@web/src/app/main/devicepage/select/System-select";
 import DeviceTypeSelect from "@web/src/app/main/devicepage/select/Device-select";
 import dayjs from "dayjs";
+import FixTypeSelect from "./select/Fix-select";
 // 添加筛选条件类型
 type SearchCondition = {
   deletedAt: null;
@@ -58,6 +59,7 @@ export default function DeviceMessage() {
   const [location, setLocation] = useState<string>("");
   const [status, setStatus] = useState<string | null>(null);
   const [selectedSystemTypeId, setSelectedSystemTypeId] = useState<string>("");
+  const [selectedFixType, setSelectedFixType] = useState<string | null>(null);
 
   // 创建ref以访问DeviceTable内部方法
   const tableRef = useRef(null);
@@ -78,6 +80,7 @@ export default function DeviceMessage() {
       deletedAt: null,
       ...(selectedSystem && { systemType: selectedSystem }),
       ...(selectedDeviceType && { deviceType: selectedDeviceType }),
+      ...(selectedFixType && { deviceStatus: selectedFixType }),
       ...(selectedDept && { deptId: selectedDept }),
       ...(time && {
         createdAt: {
@@ -166,6 +169,14 @@ export default function DeviceMessage() {
             systemTypeId={selectedSystemTypeId}
           />
         </div>  
+        <div className="flex-1 min-w-[200px]"> 
+          <FixTypeSelect
+            value={selectedFixType}
+            onChange={setSelectedFixType}
+            placeholder="选择故障状态"
+            className="w-full"
+          />
+        </div>
         <div className="flex-1 min-w-[200px]">
           <DepartmentSelect
             placeholder="单位"

apps/web/src/app/main/devicepage/select/Fix-select.tsx

@@ -0,0 +1,41 @@
+// apps/web/src/components/models/term/system-type-select.tsx
+import { Select } from "antd";
+import { api } from "@nice/client";
+import React from "react";
+
+interface FixTypeSelectProps {
+  value?: string;
+  onChange?: (value: string) => void;
+  placeholder?: string;
+  disabled?: boolean;
+  className?: string;
+  style?: React.CSSProperties;
+}
+
+export default function FixTypeSelect({ value,onChange,placeholder = "选择故障状态",disabled = false,className,style,}: FixTypeSelectProps) {
+  // 故障状态是固定的，直接定义选项
+  const options = [
+    { label: "已修复", value: "normal" },
+    { label: "维修中", value: "maintenance" },  
+    { label: "未修复", value: "broken" },
+  ];  
+
+  return (
+    <Select
+      value={value}
+      onChange={onChange}
+      options={options}
+      placeholder={placeholder}
+      disabled={disabled}
+      className={className}
+      style={style}
+      showSearch
+      filterOption={(input, option) =>
+        (option?.label?.toString() || "")
+          .toLowerCase()
+          .includes(input.toLowerCase())
+      }
+      allowClear
+    />
+  );
+}

apps/web/src/app/main/layout/NavigationMenu.tsx

@@ -29,12 +29,9 @@ function getItem(
   };
 }
 const items = [
-  getItem("首页", "/dashboard", <HomeOutlined />, null, null),
+  getItem("数据看板", "/dashboard", <HomeOutlined />, null, null),
   getItem("故障收录检索", "/device", <BookOutlined />, null, null),
-  getItem(
-    "系统设置",
-    "/admin",
-    <SettingOutlined />,
+  getItem("系统设置","/admin",<SettingOutlined />,
     [
       getItem("基本设置", "/admin/base-setting", <FormOutlined />, null, null),
       getItem("用户管理", "/admin/user", <UserOutlined />, null, null),

config/nginx/conf.d/web.conf

@@ -2,7 +2,7 @@ server {
     # 监听80端口
     listen 80;
     # 服务器域名/IP地址，使用环境变量
-    server_name 192.168.119.194;
+    server_name 192.168.21.194;
 
     # 基础性能优化配置
     # 启用tcp_nopush以优化数据发送
@@ -100,7 +100,7 @@ server {
         # 仅供内部使用
         internal;
         # 代理到认证服务
-        proxy_pass http://192.168.119.194:3000/auth/file;
+        proxy_pass http://192.168.21.194:3000/auth/file;
         
         # 请求优化：不传递请求体
         proxy_pass_request_body off;

package.json

@@ -11,5 +11,9 @@
   },
   "keywords": [],
   "author": "insiinc",
-  "license": "ISC"
+  "license": "ISC",
+  "dependencies": {
+    "echarts": "^5.6.0",
+    "echarts-for-react": "^3.0.2"
+  }
 }

packages/common/prisma/schema.prisma

@@ -217,8 +217,6 @@ model Device {
     deviceStatus         String?     @map("device_status")
     confidentialLabelId  String?     @map("confidential_label_id")
     confidentialityLevel String?     @map("confidentiality_level")
-    ipAddress            String?     @map("ip_address")
-    macAddress           String?     @map("mac_address")
     diskSerialNumber     String?     @map("disk_serial_number")
     storageLocation      String?     @map("storage_location")
     responsiblePerson    String?     @map("responsible_person")