@gadmin2n/schematics 0.0.70 → 0.0.71

package/src/lib/application/files/gadmin2-game-angle-demo/server/src/modules/roleResource/roleResource.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 { CreateRoleResourceDto } from '../../generated/roleResource/dto/create-roleResource.dto';
+import {
+  EffectedCount,
+  RoleResourceFindManyArgs,
+  RoleResourceWhereSelect,
+  UploudResponse,
+} from '../../generated/roleResource/dto/roleResource-types.dto';
+import { UpdateRoleResourceDto } from '../../generated/roleResource/dto/update-roleResource.dto';
+import { RoleResourceEntity } from '../../generated/roleResource/entities/roleResource.entity';
+import { RoleResourceService } from './roleResource.service';
+
+import { ConfigService } from '@nestjs/config';
+import { FileInterceptor } from '@nestjs/platform-express';
+
+@UseGuards(ACGuard)
+@Controller('roleResource')
+@ApiTags('roleResource')
+export class RoleResourceController {
+  constructor(
+    private readonly roleResourceService: RoleResourceService,
+    private readonly config: ConfigService,
+    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+  ) {}
+
+  @Post('createOne')
+  @UseRoles({
+    resource: 'roleResource',
+    action: 'create',
+    possession: 'any',
+  })
+  @ApiCreatedResponse({ type: RoleResourceEntity })
+  async createOne(
+    @Body() body: CreateRoleResourceDto,
+    @ACAttrFilter() acAttrFilter,
+    @Req() request: Request & { user: UserType },
+  ) {
+    body.creator = request.user.username;
+    return new RoleResourceEntity(
+      await this.roleResourceService.createOne({ data: acAttrFilter(body) }),
+    );
+  }
+
+  @Post('findMany')
+  @UseRoles({
+    resource: 'roleResource',
+    action: 'read',
+    possession: 'any',
+  })
+  @ApiPaginatedResponse(RoleResourceEntity)
+  async findMany(
+    @Body() body: RoleResourceFindManyArgs,
+    @ACAttrFilter() acAttrFilter,
+  ): Promise<PageDto<RoleResourceEntity>> {
+    const { itemCount, entities } = await this.roleResourceService.findMany(
+      body as Prisma.RoleResourceFindManyArgs,
+    );
+    const { skip = 0, take = 10 } = body as Prisma.RoleResourceFindManyArgs;
+    const pageOptionsDto: PageOptionsDto = { skip, take };
+    const pageMetaDto = new PageMetaDto({ itemCount, pageOptionsDto });
+
+    return new PageDto(
+      entities.map((item) => new RoleResourceEntity(acAttrFilter(item))),
+      pageMetaDto,
+    );
+  }
+
+  @Post('/findUnique/:id')
+  @UseRoles({
+    resource: 'roleResource',
+    action: 'read',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: RoleResourceEntity })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async findUnique(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() body: RoleResourceWhereSelect,
+    @ACAttrFilter() acAttrFilter,
+  ) {
+    const item = await this.roleResourceService.findUnique(id, body);
+    if (!item) {
+      throw new NotFoundException();
+    }
+    return new RoleResourceEntity(acAttrFilter(item));
+  }
+
+  @Patch('updateUnique/:id')
+  @UseRoles({
+    resource: 'roleResource',
+    action: 'update',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: RoleResourceEntity })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async updateUnique(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() body: UpdateRoleResourceDto,
+    @ACAttrFilter() acAttrFilter,
+  ) {
+    /* 
+    const origin = (await this.roleResourceService.findUnique(id, {
+      id: true,
+      // 这里需要根据实际情况填写
+    })) as RoleResourceEntity | null;
+    if (!origin) {
+      throw new NotFoundException();
+    }
+    // 需要兼容从列表页change_value入口进来的情况，这里进来的是只有少量字段的数据
+    const newBody = {
+      ...origin,
+      ...body,
+    };
+
+    // 其他个性化逻辑
+    */
+
+    const item = await this.roleResourceService.updateUnique(
+      id,
+      acAttrFilter(body),
+    );
+    return new RoleResourceEntity(acAttrFilter(item));
+  }
+
+  @Delete('deleteUnique/:id')
+  @UseRoles({
+    resource: 'roleResource',
+    action: 'delete',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: EffectedCount })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async deleteUnique(@Param('id', ParseIntPipe) id: number) {
+    const res = await this.roleResourceService.deleteUnique(id);
+    if (!res.count) {
+      throw new NotFoundException();
+    }
+    return res;
+  }
+
+  @Post('upload')
+  @UseRoles({
+    resource: 'roleResource',
+    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'] + '/roleResource/',
+    );
+
+    return {
+      ...pick(file, ['mimetype', 'originalname', 'size']),
+      url: this.config.get('media')['address'] + '/roleResource/' + fileName,
+      name: fileName,
+    };
+  }
+}

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

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { RoleResourceController } from './roleResource.controller';
+import { RoleResourceService } from './roleResource.service';
+
+@Module({
+  controllers: [RoleResourceController],
+  providers: [RoleResourceService],
+  exports: [RoleResourceService],
+})
+export class RoleResourceModule {}

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

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

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

@@ -0,0 +1,216 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { Prisma, RoleResource } 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 RoleResourceService {
+  constructor(
+    private prisma: PrismaService,
+    private readonly config: ConfigService,
+    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+  ) {}
+
+  async createOne(roleResourceCreateArgs: Prisma.RoleResourceCreateArgs) {
+    this.logger.info(
+      '[RoleResource] Creating role resource',
+      createSafeLogData({
+        operation: 'CREATE',
+        table: 'roleResource',
+        data: roleResourceCreateArgs.data,
+      }),
+    );
+    const result = await this.prisma.roleResource.create(
+      roleResourceCreateArgs,
+    );
+    this.logger.info(
+      '[RoleResource] Role resource created successfully',
+      createSafeLogData({
+        operation: 'CREATE',
+        table: 'roleResource',
+        result: result,
+      }),
+    );
+    return result;
+  }
+
+  async createMany(data: Prisma.RoleResourceCreateManyArgs['data']) {
+    this.logger.info(
+      '[RoleResource] Creating multiple role resources',
+      createSafeLogData({
+        operation: 'CREATE_MANY',
+        table: 'roleResource',
+        count: Array.isArray(data) ? data.length : 1,
+        data: data,
+      }),
+    );
+    const result = await this.prisma.roleResource.createMany({
+      data,
+      skipDuplicates: true,
+    });
+    this.logger.info(
+      '[RoleResource] Multiple role resources created successfully',
+      createSafeLogData({
+        operation: 'CREATE_MANY',
+        table: 'roleResource',
+        count: result.count,
+      }),
+    );
+    return result;
+  }
+
+  async findMany(
+    roleResourceFindManyArgs: Prisma.RoleResourceFindManyArgs,
+  ): Promise<{ itemCount: number; entities: RoleResource[] }> {
+    const itemCount = await this.prisma.roleResource.count({
+      where: roleResourceFindManyArgs.where,
+    });
+    const entities = await this.prisma.roleResource.findMany(
+      roleResourceFindManyArgs,
+    );
+    return { itemCount, entities };
+  }
+
+  async findUnique(
+    id: number,
+    select: Prisma.RoleResourceFindUniqueArgs['select'],
+  ) {
+    return await this.prisma.roleResource.findUnique({
+      where: { id: id },
+      select,
+    });
+  }
+
+  async updateMany(
+    roleResourceUpdateManyArgs: Prisma.RoleResourceUpdateManyArgs,
+  ) {
+    this.logger.info(
+      '[RoleResource] Updating multiple role resources',
+      createSafeLogData({
+        operation: 'UPDATE_MANY',
+        table: 'roleResource',
+        where: roleResourceUpdateManyArgs.where,
+        data: roleResourceUpdateManyArgs.data,
+      }),
+    );
+    const result = await this.prisma.roleResource.updateMany(
+      roleResourceUpdateManyArgs,
+    );
+    this.logger.info(
+      '[RoleResource] Multiple role resources updated successfully',
+      createSafeLogData({
+        operation: 'UPDATE_MANY',
+        table: 'roleResource',
+        count: result.count,
+      }),
+    );
+    return result;
+  }
+
+  async updateUnique(
+    id: number,
+    data: Prisma.RoleResourceUpdateManyArgs['data'],
+  ) {
+    const oldData = await this.prisma.roleResource.findUnique({
+      where: { id },
+    });
+    this.logger.info(
+      '[RoleResource] Updating role resource',
+      createSafeLogData({
+        operation: 'UPDATE',
+        table: 'roleResource',
+        id: id,
+        oldData: oldData,
+        newData: data,
+      }),
+    );
+    const result = await this.prisma.roleResource.update({
+      where: { id: id },
+      data,
+    });
+    this.logger.info(
+      '[RoleResource] Role resource updated successfully',
+      createSafeLogData({
+        operation: 'UPDATE',
+        table: 'roleResource',
+        id: id,
+        result: result,
+      }),
+    );
+    return result;
+  }
+
+  async deleteMany(
+    roleResourceDeleteManyArgs: Prisma.RoleResourceDeleteManyArgs,
+  ) {
+    const oldData = await this.prisma.roleResource.findMany({
+      where: roleResourceDeleteManyArgs.where,
+    });
+    this.logger.info(
+      '[RoleResource] Deleting multiple role resources',
+      createSafeLogData({
+        operation: 'DELETE_MANY',
+        table: 'roleResource',
+        where: roleResourceDeleteManyArgs.where,
+        oldData: oldData,
+      }),
+    );
+    const result = await this.prisma.roleResource.deleteMany(
+      roleResourceDeleteManyArgs,
+    );
+    this.logger.info(
+      '[RoleResource] Multiple role resources deleted successfully',
+      createSafeLogData({
+        operation: 'DELETE_MANY',
+        table: 'roleResource',
+        count: result.count,
+      }),
+    );
+    return result;
+  }
+
+  async deleteUnique(id: number) {
+    const oldData = await this.prisma.roleResource.findUnique({
+      where: { id },
+    });
+    this.logger.info(
+      '[RoleResource] Deleting role resource',
+      createSafeLogData({
+        operation: 'DELETE',
+        table: 'roleResource',
+        id: id,
+        oldData: oldData,
+      }),
+    );
+    await this.prisma.roleResource.delete({
+      where: { id: id },
+    });
+    this.logger.info(
+      '[RoleResource] Role resource deleted successfully',
+      createSafeLogData({
+        operation: 'DELETE',
+        table: 'roleResource',
+        id: id,
+      }),
+    );
+    return { count: 1 };
+  }
+
+  async count(roleResourceCountArgs?: Prisma.RoleResourceCountArgs) {
+    return await this.prisma.roleResource.count(roleResourceCountArgs);
+  }
+
+  async groupBy(roleResourceGroupByArgs: Prisma.RoleResourceGroupByArgs) {
+    return await this.prisma.roleResource.groupBy(
+      roleResourceGroupByArgs as any,
+    );
+  }
+
+  async aggregate(roleResourceAggregateArgs: Prisma.RoleResourceAggregateArgs) {
+    return await this.prisma.roleResource.aggregate(roleResourceAggregateArgs);
+  }
+}

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

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

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

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

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

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { UserController } from './user.controller';
+import { UserService } from './user.service';
+
+@Module({
+  controllers: [UserController],
+  providers: [UserService],
+  exports: [UserService],
+})
+export class UserModule {}

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

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