@gadmin2n/schematics 0.0.70 → 0.0.71

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

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

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

@@ -0,0 +1,199 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { Prisma, Resource } 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 ResourceService {
+  constructor(
+    private prisma: PrismaService,
+    private readonly config: ConfigService,
+    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+  ) {}
+
+  async createOne(resourceCreateArgs: Prisma.ResourceCreateArgs) {
+    this.logger.info(
+      '[Resource] Creating resource',
+      createSafeLogData({
+        operation: 'CREATE',
+        table: 'resource',
+        data: resourceCreateArgs.data,
+      }),
+    );
+    const result = await this.prisma.resource.create(resourceCreateArgs);
+    this.logger.info(
+      '[Resource] Resource created successfully',
+      createSafeLogData({
+        operation: 'CREATE',
+        table: 'resource',
+        result: result,
+      }),
+    );
+    return result;
+  }
+
+  async createMany(data: Prisma.ResourceCreateManyArgs['data']) {
+    this.logger.info(
+      '[Resource] Creating multiple resources',
+      createSafeLogData({
+        operation: 'CREATE_MANY',
+        table: 'resource',
+        count: Array.isArray(data) ? data.length : 1,
+        data: data,
+      }),
+    );
+    const result = await this.prisma.resource.createMany({
+      data,
+      skipDuplicates: true,
+    });
+    this.logger.info(
+      '[Resource] Multiple resources created successfully',
+      createSafeLogData({
+        operation: 'CREATE_MANY',
+        table: 'resource',
+        count: result.count,
+      }),
+    );
+    return result;
+  }
+
+  async findMany(
+    resourceFindManyArgs: Prisma.ResourceFindManyArgs,
+  ): Promise<{ itemCount: number; entities: Resource[] }> {
+    const itemCount = await this.prisma.resource.count({
+      where: resourceFindManyArgs.where,
+    });
+    const entities = await this.prisma.resource.findMany(resourceFindManyArgs);
+    return { itemCount, entities };
+  }
+
+  async findUnique(
+    id: number,
+    select: Prisma.ResourceFindUniqueArgs['select'],
+  ) {
+    return await this.prisma.resource.findUnique({
+      where: { id: id },
+      select,
+    });
+  }
+
+  async updateMany(resourceUpdateManyArgs: Prisma.ResourceUpdateManyArgs) {
+    this.logger.info(
+      '[Resource] Updating multiple resources',
+      createSafeLogData({
+        operation: 'UPDATE_MANY',
+        table: 'resource',
+        where: resourceUpdateManyArgs.where,
+        data: resourceUpdateManyArgs.data,
+      }),
+    );
+    const result = await this.prisma.resource.updateMany(
+      resourceUpdateManyArgs,
+    );
+    this.logger.info(
+      '[Resource] Multiple resources updated successfully',
+      createSafeLogData({
+        operation: 'UPDATE_MANY',
+        table: 'resource',
+        count: result.count,
+      }),
+    );
+    return result;
+  }
+
+  async updateUnique(id: number, data: Prisma.ResourceUpdateManyArgs['data']) {
+    const oldData = await this.prisma.resource.findUnique({ where: { id } });
+    this.logger.info(
+      '[Resource] Updating resource',
+      createSafeLogData({
+        operation: 'UPDATE',
+        table: 'resource',
+        id: id,
+        oldData: oldData,
+        newData: data,
+      }),
+    );
+    const result = await this.prisma.resource.update({
+      where: { id: id },
+      data,
+    });
+    this.logger.info(
+      '[Resource] Resource updated successfully',
+      createSafeLogData({
+        operation: 'UPDATE',
+        table: 'resource',
+        id: id,
+        result: result,
+      }),
+    );
+    return result;
+  }
+
+  async deleteMany(resourceDeleteManyArgs: Prisma.ResourceDeleteManyArgs) {
+    const oldData = await this.prisma.resource.findMany({
+      where: resourceDeleteManyArgs.where,
+    });
+    this.logger.info(
+      '[Resource] Deleting multiple resources',
+      createSafeLogData({
+        operation: 'DELETE_MANY',
+        table: 'resource',
+        where: resourceDeleteManyArgs.where,
+        oldData: oldData,
+      }),
+    );
+    const result = await this.prisma.resource.deleteMany(
+      resourceDeleteManyArgs,
+    );
+    this.logger.info(
+      '[Resource] Multiple resources deleted successfully',
+      createSafeLogData({
+        operation: 'DELETE_MANY',
+        table: 'resource',
+        count: result.count,
+      }),
+    );
+    return result;
+  }
+
+  async deleteUnique(id: number) {
+    const oldData = await this.prisma.resource.findUnique({ where: { id } });
+    this.logger.info(
+      '[Resource] Deleting resource',
+      createSafeLogData({
+        operation: 'DELETE',
+        table: 'resource',
+        id: id,
+        oldData: oldData,
+      }),
+    );
+    await this.prisma.resource.delete({
+      where: { id: id },
+    });
+    this.logger.info(
+      '[Resource] Resource deleted successfully',
+      createSafeLogData({
+        operation: 'DELETE',
+        table: 'resource',
+        id: id,
+      }),
+    );
+    return { count: 1 };
+  }
+
+  async count(resourceCountArgs?: Prisma.ResourceCountArgs) {
+    return await this.prisma.resource.count(resourceCountArgs);
+  }
+
+  async groupBy(resourceGroupByArgs: Prisma.ResourceGroupByArgs) {
+    return await this.prisma.resource.groupBy(resourceGroupByArgs as any);
+  }
+
+  async aggregate(resourceAggregateArgs: Prisma.ResourceAggregateArgs) {
+    return await this.prisma.resource.aggregate(resourceAggregateArgs);
+  }
+}

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

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

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

@@ -0,0 +1,210 @@
+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 { CreateRoleDto } from '../../generated/role/dto/create-role.dto';
+import {
+  EffectedCount,
+  RoleFindManyArgs,
+  RoleWhereSelect,
+  UploudResponse,
+} from '../../generated/role/dto/role-types.dto';
+import { UpdateRoleDto } from '../../generated/role/dto/update-role.dto';
+import { RoleEntity } from '../../generated/role/entities/role.entity';
+import { RoleService } from './role.service';
+
+import { ConfigService } from '@nestjs/config';
+import { FileInterceptor } from '@nestjs/platform-express';
+import { Type } from 'class-transformer';
+import { IsArray, IsOptional } from 'class-validator';
+
+// 自定义控制器层输入类型,扩展 pageIds 字段
+export class UpdateRoleWithPagesDto extends UpdateRoleDto {
+  @IsOptional()
+  @IsArray()
+  @Type(() => Number)
+  pageIds?: number[];
+}
+
+export class CreateRoleWithPagesDto extends CreateRoleDto {
+  @IsOptional()
+  @IsArray()
+  @Type(() => Number)
+  pageIds?: number[];
+}
+
+@UseGuards(ACGuard)
+@Controller('role')
+@ApiTags('role')
+export class RoleController {
+  constructor(
+    private readonly roleService: RoleService,
+    private readonly config: ConfigService,
+    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+  ) {}
+
+  @Post('createOne')
+  @UseRoles({
+    resource: 'role',
+    action: 'create',
+    possession: 'any',
+  })
+  @ApiCreatedResponse({ type: RoleEntity })
+  async createOne(
+    @Body() body: CreateRoleWithPagesDto,
+    @ACAttrFilter() acAttrFilter,
+    @Req() request: Request & { user: UserType },
+  ) {
+    body.creator = request.user.username;
+    const { pageIds, ...roleData } = body;
+
+    // 使用 Prisma 事务创建角色及其页面权限
+    const role = await this.roleService.createRoleWithPages(
+      acAttrFilter(roleData),
+      pageIds,
+    );
+
+    return new RoleEntity(acAttrFilter(role));
+  }
+
+  @Post('findMany')
+  @UseRoles({
+    resource: 'role',
+    action: 'read',
+    possession: 'any',
+  })
+  @ApiPaginatedResponse(RoleEntity)
+  async findMany(
+    @Body() body: RoleFindManyArgs,
+    @ACAttrFilter() acAttrFilter,
+  ): Promise<PageDto<RoleEntity>> {
+    const { itemCount, entities } = await this.roleService.findMany(
+      body as Prisma.RoleFindManyArgs,
+    );
+    const { skip = 0, take = 10 } = body as Prisma.RoleFindManyArgs;
+    const pageOptionsDto: PageOptionsDto = { skip, take };
+    const pageMetaDto = new PageMetaDto({ itemCount, pageOptionsDto });
+
+    return new PageDto(
+      entities.map((item) => new RoleEntity(acAttrFilter(item))),
+      pageMetaDto,
+    );
+  }
+
+  @Post('/findUnique/:id')
+  @UseRoles({
+    resource: 'role',
+    action: 'read',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: RoleEntity })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async findUnique(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() body: RoleWhereSelect,
+    @ACAttrFilter() acAttrFilter,
+  ) {
+    const item = await this.roleService.findUnique(id, body);
+    if (!item) {
+      throw new NotFoundException();
+    }
+    return new RoleEntity(acAttrFilter(item));
+  }
+
+  @Patch('updateUnique/:id')
+  @UseRoles({
+    resource: 'role',
+    action: 'update',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: RoleEntity })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async updateUnique(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() body: UpdateRoleWithPagesDto,
+    @ACAttrFilter() acAttrFilter,
+  ) {
+    const { pageIds, ...roleData } = body;
+
+    // 删除 createdAt 字段，防止被更新
+    delete (roleData as any).createdAt;
+
+    // 使用 Prisma 事务确保原子性
+    const item = await this.roleService.updateRoleWithPages(
+      id,
+      acAttrFilter(roleData),
+      pageIds,
+    );
+
+    return new RoleEntity(acAttrFilter(item));
+  }
+
+  @Delete('deleteUnique/:id')
+  @UseRoles({
+    resource: 'role',
+    action: 'delete',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: EffectedCount })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async deleteUnique(@Param('id', ParseIntPipe) id: number) {
+    const res = await this.roleService.deleteUnique(id);
+    if (!res.count) {
+      throw new NotFoundException();
+    }
+    return res;
+  }
+
+  @Post('upload')
+  @UseRoles({
+    resource: 'role',
+    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'] + '/role/',
+    );
+
+    return {
+      ...pick(file, ['mimetype', 'originalname', 'size']),
+      url: this.config.get('media')['address'] + '/role/' + fileName,
+      name: fileName,
+    };
+  }
+}

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

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { PrismaService } from 'nestjs-prisma';
+import { RoleController } from './role.controller';
+import { RoleService } from './role.service';
+import { RolesRefresherService } from './roles-refresher.service';
+
+@Module({
+  providers: [RoleService, RolesRefresherService, PrismaService],
+  controllers: [RoleController],
+  exports: [RoleService],
+})
+export class RoleModule {}

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

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