@gadmin2n/schematics 0.0.69 → 0.0.71

package/src/lib/application/files/gadmin2-game-angle-demo/server/src/modules/role/roles-refresher.service.ts

@@ -0,0 +1,133 @@
+import { CACHE_MANAGER } from '@nestjs/cache-manager';
+import { Inject, Injectable, OnModuleInit } from '@nestjs/common';
+import { Cron, CronExpression } from '@nestjs/schedule';
+import { Cache } from 'cache-manager';
+import { ROLES_BUILDER_TOKEN, RolesBuilder } from 'nest-access-control';
+import { RoleService } from './role.service';
+
+/**
+ * 1. 启动时优先从缓存加载权限数据，缓存不存在则从数据库加载
+ * 2. 每分钟从数据库刷新权限数据
+ * 3. 刷新成功后同时更新缓存和 RolesBuilder
+ * 4. 刷新失败时保持使用缓存中的旧数据，确保服务可用性
+ */
+@Injectable()
+export class RolesRefresherService implements OnModuleInit {
+  private static readonly CACHE_KEY = 'roles:grants';
+  // 使用全局 TTL 配置（5分钟），无需单独设置
+
+  constructor(
+    @Inject(ROLES_BUILDER_TOKEN) private readonly rolesBuilder: RolesBuilder,
+    @Inject(CACHE_MANAGER) private readonly cacheManager: Cache,
+    private readonly roleService: RoleService,
+  ) {}
+
+  async onModuleInit() {
+    // 启动时优先从缓存加载，失败则从数据库加载
+    await this.initializeRoles();
+  }
+
+  /**
+   * 初始化权限数据
+   * 优先从缓存加载，缓存不存在则从数据库加载
+   */
+  private async initializeRoles() {
+    try {
+      // 1. 尝试从缓存加载
+      const cachedGrants = await this.cacheManager.get<any>(
+        RolesRefresherService.CACHE_KEY,
+      );
+
+      if (cachedGrants) {
+        // console.log('[RolesRefresher] Loading roles from cache...');
+        this.updateRolesBuilder(cachedGrants);
+        // console.log('[RolesRefresher] ✅ Roles loaded from cache successfully');
+
+        // 后台异步刷新数据库数据（不阻塞启动）
+        this.refreshRolesFromDB().catch((error) => {
+          console.error('[RolesRefresher] Background refresh failed:', error);
+        });
+        return;
+      }
+
+      // 如果缓存不存在，从数据库加载
+      console.log(
+        '[RolesRefresher] Cache miss, loading roles from database...',
+      );
+      await this.refreshRolesFromDB();
+    } catch (error) {
+      console.error('[RolesRefresher] ❌ Failed to initialize roles:', error);
+      // 初始化失败，RolesBuilder 保持为空，权限检查会失败（fail-safe）
+    }
+  }
+
+  /**
+   * 定时刷新任务（每1分钟执行一次）
+   */
+  @Cron(CronExpression.EVERY_MINUTE)
+  async handleCron() {
+    await this.refreshRolesFromDB();
+  }
+
+  /**
+   * 从数据库刷新权限数据
+   * 成功后同时更新缓存和 RolesBuilder
+   * 失败时保持使用缓存中的旧数据
+   */
+  private async refreshRolesFromDB() {
+    try {
+      console.log('[RolesRefresher] Refreshing roles from database...');
+      const newBuilder = await this.roleService.getBuilder();
+      const newGrants =
+        (newBuilder as any)._grants || (newBuilder as any).grants || null;
+
+      if (!newGrants) {
+        console.error(
+          '[RolesRefresher] ❌ Failed to extract grants from builder',
+        );
+        return;
+      }
+      // 先更新缓存（使用全局 TTL：5分钟）
+      await this.cacheManager.set(RolesRefresherService.CACHE_KEY, newGrants);
+      // console.log('[RolesRefresher] ✅ Roles cached successfully');
+      // 更新 RolesBuilder（内存中的权限数据）
+      this.updateRolesBuilder(newGrants);
+
+      // console.log('[RolesRefresher] ✅ Roles refreshed successfully');
+    } catch (error) {
+      console.error(
+        '[RolesRefresher] ❌ Failed to refresh roles from DB:',
+        error,
+      );
+
+      // 失败时尝试从缓存恢复
+      try {
+        const cachedGrants = await this.cacheManager.get<any>(
+          RolesRefresherService.CACHE_KEY,
+        );
+        if (cachedGrants) {
+          // console.log('[RolesRefresher] Using cached roles as fallback');
+          this.updateRolesBuilder(cachedGrants);
+        } else {
+          // console.error('[RolesRefresher] No cached roles available');
+        }
+      } catch (cacheError) {
+        console.error(
+          '[RolesRefresher] Failed to load from cache:',
+          cacheError,
+        );
+      }
+    }
+  }
+
+  /**
+   * 更新 RolesBuilder 的内部状态
+   * @param grants 权限数据
+   */
+  private updateRolesBuilder(grants: any) {
+    (this.rolesBuilder as any)._grants = grants;
+    if ((this.rolesBuilder as any).grants !== undefined) {
+      (this.rolesBuilder as any).grants = grants;
+    }
+  }
+}

package/src/lib/application/files/gadmin2-game-angle-demo/server/src/modules/rolePages/rolePages.controller.spec.ts

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

package/src/lib/application/files/gadmin2-game-angle-demo/server/src/modules/rolePages/rolePages.controller.ts

@@ -0,0 +1,196 @@
+import {
+  ACAttrFilter,
+  ACGuard,
+  ApiPaginatedResponse,
+  diskStorage,
+  PageDto,
+  PageMetaDto,
+  PageOptionsDto,
+  pick,
+  UserType,
+} from '@gadmin2n/nest-common';
+import {
+  Body,
+  Controller,
+  Delete,
+  Inject,
+  NotFoundException,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  Req,
+  UploadedFile,
+  UseGuards,
+  UseInterceptors,
+} from '@nestjs/common';
+import {
+  ApiCreatedResponse,
+  ApiNotFoundResponse,
+  ApiOkResponse,
+  ApiTags,
+} from '@nestjs/swagger';
+import { Prisma } from '@prisma/client';
+import { UseRoles } from 'nest-access-control';
+import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
+import { Logger } from 'winston';
+import { CreateRolePagesDto } from '../../generated/rolePages/dto/create-rolePages.dto';
+import {
+  EffectedCount,
+  RolePagesFindManyArgs,
+  RolePagesWhereSelect,
+  UploudResponse,
+} from '../../generated/rolePages/dto/rolePages-types.dto';
+import { UpdateRolePagesDto } from '../../generated/rolePages/dto/update-rolePages.dto';
+import { RolePagesEntity } from '../../generated/rolePages/entities/rolePages.entity';
+import { RolePagesService } from './rolePages.service';
+
+import { ConfigService } from '@nestjs/config';
+import { FileInterceptor } from '@nestjs/platform-express';
+
+@UseGuards(ACGuard)
+@Controller('rolePages')
+@ApiTags('rolePages')
+export class RolePagesController {
+  constructor(
+    private readonly rolePagesService: RolePagesService,
+    private readonly config: ConfigService,
+    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+  ) {}
+
+  @Post('createOne')
+  @UseRoles({
+    resource: 'rolePages',
+    action: 'create',
+    possession: 'any',
+  })
+  @ApiCreatedResponse({ type: RolePagesEntity })
+  async createOne(
+    @Body() body: CreateRolePagesDto,
+    @ACAttrFilter() acAttrFilter,
+    @Req() request: Request & { user: UserType },
+  ) {
+    body.creator = request.user.username;
+    return new RolePagesEntity(
+      await this.rolePagesService.createOne({ data: acAttrFilter(body) }),
+    );
+  }
+
+  @Post('findMany')
+  @UseRoles({
+    resource: 'rolePages',
+    action: 'read',
+    possession: 'any',
+  })
+  @ApiPaginatedResponse(RolePagesEntity)
+  async findMany(
+    @Body() body: RolePagesFindManyArgs,
+    @ACAttrFilter() acAttrFilter,
+  ): Promise<PageDto<RolePagesEntity>> {
+    const { itemCount, entities } = await this.rolePagesService.findMany(
+      body as Prisma.RolePagesFindManyArgs,
+    );
+    const { skip = 0, take = 10 } = body as Prisma.RolePagesFindManyArgs;
+    const pageOptionsDto: PageOptionsDto = { skip, take };
+    const pageMetaDto = new PageMetaDto({ itemCount, pageOptionsDto });
+
+    return new PageDto(
+      entities.map((item) => new RolePagesEntity(acAttrFilter(item))),
+      pageMetaDto,
+    );
+  }
+
+  @Post('/findUnique/:id')
+  @UseRoles({
+    resource: 'rolePages',
+    action: 'read',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: RolePagesEntity })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async findUnique(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() body: RolePagesWhereSelect,
+    @ACAttrFilter() acAttrFilter,
+  ) {
+    const item = await this.rolePagesService.findUnique(id, body);
+    if (!item) {
+      throw new NotFoundException();
+    }
+    return new RolePagesEntity(acAttrFilter(item));
+  }
+
+  @Patch('updateUnique/:id')
+  @UseRoles({
+    resource: 'rolePages',
+    action: 'update',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: RolePagesEntity })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async updateUnique(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() body: UpdateRolePagesDto,
+    @ACAttrFilter() acAttrFilter,
+  ) {
+    /* 
+    const origin = (await this.rolePagesService.findUnique(id, {
+      id: true,
+      // 这里需要根据实际情况填写
+    })) as RolePagesEntity | null;
+    if (!origin) {
+      throw new NotFoundException();
+    }
+    // 需要兼容从列表页change_value入口进来的情况，这里进来的是只有少量字段的数据
+    const newBody = {
+      ...origin,
+      ...body,
+    };
+
+    // 其他个性化逻辑
+    */
+
+    const item = await this.rolePagesService.updateUnique(
+      id,
+      acAttrFilter(body),
+    );
+    return new RolePagesEntity(acAttrFilter(item));
+  }
+
+  @Delete('deleteUnique/:id')
+  @UseRoles({
+    resource: 'rolePages',
+    action: 'delete',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: EffectedCount })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async deleteUnique(@Param('id', ParseIntPipe) id: number) {
+    const res = await this.rolePagesService.deleteUnique(id);
+    if (!res.count) {
+      throw new NotFoundException();
+    }
+    return res;
+  }
+
+  @Post('upload')
+  @UseRoles({
+    resource: 'rolePages',
+    action: 'create',
+    possession: 'any',
+  })
+  @ApiCreatedResponse({ type: UploudResponse })
+  @UseInterceptors(FileInterceptor('file'))
+  async uploadFile(@UploadedFile() file: Express.Multer.File) {
+    const fileName = await diskStorage(
+      file,
+      this.config.get('media')['rootDir'] + '/rolePages/',
+    );
+
+    return {
+      ...pick(file, ['mimetype', 'originalname', 'size']),
+      url: this.config.get('media')['address'] + '/rolePages/' + fileName,
+      name: fileName,
+    };
+  }
+}

package/src/lib/application/files/gadmin2-game-angle-demo/server/src/modules/rolePages/rolePages.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { RolePagesController } from './rolePages.controller';
+import { RolePagesService } from './rolePages.service';
+
+@Module({
+  controllers: [RolePagesController],
+  providers: [RolePagesService],
+  exports: [RolePagesService],
+})
+export class RolePagesModule {}

package/src/lib/application/files/gadmin2-game-angle-demo/server/src/modules/rolePages/rolePages.service.spec.ts

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

package/src/lib/application/files/gadmin2-game-angle-demo/server/src/modules/rolePages/rolePages.service.ts

@@ -0,0 +1,201 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { Prisma, RolePages } from '@prisma/client';
+import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
+import { PrismaService } from 'nestjs-prisma';
+import { Logger } from 'winston';
+
+import { ConfigService } from '@nestjs/config';
+import { createSafeLogData } from '../../lib/safe-log.util';
+
+@Injectable()
+export class RolePagesService {
+  constructor(
+    private prisma: PrismaService,
+    private readonly config: ConfigService,
+    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+  ) {}
+
+  async createOne(rolePagesCreateArgs: Prisma.RolePagesCreateArgs) {
+    this.logger.info(
+      '[RolePages] Creating role page',
+      createSafeLogData({
+        operation: 'CREATE',
+        table: 'rolePages',
+        data: rolePagesCreateArgs.data,
+      }),
+    );
+    const result = await this.prisma.rolePages.create(rolePagesCreateArgs);
+    this.logger.info(
+      '[RolePages] Role page created successfully',
+      createSafeLogData({
+        operation: 'CREATE',
+        table: 'rolePages',
+        result: result,
+      }),
+    );
+    return result;
+  }
+
+  async createMany(data: Prisma.RolePagesCreateManyArgs['data']) {
+    this.logger.info(
+      '[RolePages] Creating multiple role pages',
+      createSafeLogData({
+        operation: 'CREATE_MANY',
+        table: 'rolePages',
+        count: Array.isArray(data) ? data.length : 1,
+        data: data,
+      }),
+    );
+    const result = await this.prisma.rolePages.createMany({
+      data,
+      skipDuplicates: true,
+    });
+    this.logger.info(
+      '[RolePages] Multiple role pages created successfully',
+      createSafeLogData({
+        operation: 'CREATE_MANY',
+        table: 'rolePages',
+        count: result.count,
+      }),
+    );
+    return result;
+  }
+
+  async findMany(
+    rolePagesFindManyArgs: Prisma.RolePagesFindManyArgs,
+  ): Promise<{ itemCount: number; entities: RolePages[] }> {
+    const itemCount = await this.prisma.rolePages.count({
+      where: rolePagesFindManyArgs.where,
+    });
+    const entities = await this.prisma.rolePages.findMany(
+      rolePagesFindManyArgs,
+    );
+    return { itemCount, entities };
+  }
+
+  async findUnique(
+    id: number,
+    select: Prisma.RolePagesFindUniqueArgs['select'],
+  ) {
+    return await this.prisma.rolePages.findUnique({
+      where: { id: id },
+      select,
+    });
+  }
+
+  async updateMany(rolePagesUpdateManyArgs: Prisma.RolePagesUpdateManyArgs) {
+    this.logger.info(
+      '[RolePages] Updating multiple role pages',
+      createSafeLogData({
+        operation: 'UPDATE_MANY',
+        table: 'rolePages',
+        where: rolePagesUpdateManyArgs.where,
+        data: rolePagesUpdateManyArgs.data,
+      }),
+    );
+    const result = await this.prisma.rolePages.updateMany(
+      rolePagesUpdateManyArgs,
+    );
+    this.logger.info(
+      '[RolePages] Multiple role pages updated successfully',
+      createSafeLogData({
+        operation: 'UPDATE_MANY',
+        table: 'rolePages',
+        count: result.count,
+      }),
+    );
+    return result;
+  }
+
+  async updateUnique(id: number, data: Prisma.RolePagesUpdateManyArgs['data']) {
+    const oldData = await this.prisma.rolePages.findUnique({ where: { id } });
+    this.logger.info(
+      '[RolePages] Updating role page',
+      createSafeLogData({
+        operation: 'UPDATE',
+        table: 'rolePages',
+        id: id,
+        oldData: oldData,
+        newData: data,
+      }),
+    );
+    const result = await this.prisma.rolePages.update({
+      where: { id: id },
+      data,
+    });
+    this.logger.info(
+      '[RolePages] Role page updated successfully',
+      createSafeLogData({
+        operation: 'UPDATE',
+        table: 'rolePages',
+        id: id,
+        result: result,
+      }),
+    );
+    return result;
+  }
+
+  async deleteMany(rolePagesDeleteManyArgs: Prisma.RolePagesDeleteManyArgs) {
+    const oldData = await this.prisma.rolePages.findMany({
+      where: rolePagesDeleteManyArgs.where,
+    });
+    this.logger.info(
+      '[RolePages] Deleting multiple role pages',
+      createSafeLogData({
+        operation: 'DELETE_MANY',
+        table: 'rolePages',
+        where: rolePagesDeleteManyArgs.where,
+        oldData: oldData,
+      }),
+    );
+    const result = await this.prisma.rolePages.deleteMany(
+      rolePagesDeleteManyArgs,
+    );
+    this.logger.info(
+      '[RolePages] Multiple role pages deleted successfully',
+      createSafeLogData({
+        operation: 'DELETE_MANY',
+        table: 'rolePages',
+        count: result.count,
+      }),
+    );
+    return result;
+  }
+
+  async deleteUnique(id: number) {
+    const oldData = await this.prisma.rolePages.findUnique({ where: { id } });
+    this.logger.info(
+      '[RolePages] Deleting role page',
+      createSafeLogData({
+        operation: 'DELETE',
+        table: 'rolePages',
+        id: id,
+        oldData: oldData,
+      }),
+    );
+    await this.prisma.rolePages.delete({
+      where: { id: id },
+    });
+    this.logger.info(
+      '[RolePages] Role page deleted successfully',
+      createSafeLogData({
+        operation: 'DELETE',
+        table: 'rolePages',
+        id: id,
+      }),
+    );
+    return { count: 1 };
+  }
+
+  async count(rolePagesCountArgs?: Prisma.RolePagesCountArgs) {
+    return await this.prisma.rolePages.count(rolePagesCountArgs);
+  }
+
+  async groupBy(rolePagesGroupByArgs: Prisma.RolePagesGroupByArgs) {
+    return await this.prisma.rolePages.groupBy(rolePagesGroupByArgs as any);
+  }
+
+  async aggregate(rolePagesAggregateArgs: Prisma.RolePagesAggregateArgs) {
+    return await this.prisma.rolePages.aggregate(rolePagesAggregateArgs);
+  }
+}

package/src/lib/application/files/gadmin2-game-angle-demo/server/src/modules/roleResource/roleResource.controller.spec.ts

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