@gadmin2n/schematics 0.0.64 → 0.0.65

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

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

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

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

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { PageResourceController } from './pageResource.controller';
+import { PageResourceService } from './pageResource.service';
+
+import { RoleModule } from '../role/role.module';
+
+@Module({
+  imports: [RoleModule],
+  controllers: [PageResourceController],
+  providers: [PageResourceService],
+  exports: [PageResourceService],
+})
+export class PageResourceModule {}

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

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

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

@@ -0,0 +1,219 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { PageResource, Prisma } 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';
+
+import { RoleService } from '../role/role.service';
+
+@Injectable()
+export class PageResourceService {
+  constructor(
+    private prisma: PrismaService,
+    private readonly config: ConfigService,
+    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+    private readonly roleService: RoleService,
+  ) {}
+
+  async createOne(pageResourceCreateArgs: Prisma.PageResourceCreateArgs) {
+    this.logger.info(
+      '[PageResource] Creating page resource',
+      createSafeLogData({
+        operation: 'CREATE',
+        table: 'pageResource',
+        data: pageResourceCreateArgs.data,
+      }),
+    );
+    const result = await this.prisma.pageResource.create(
+      pageResourceCreateArgs,
+    );
+    this.logger.info(
+      '[PageResource] Page resource created successfully',
+      createSafeLogData({
+        operation: 'CREATE',
+        table: 'pageResource',
+        result: result,
+      }),
+    );
+    return result;
+  }
+
+  async createMany(data: Prisma.PageResourceCreateManyArgs['data']) {
+    this.logger.info(
+      '[PageResource] Creating multiple page resources',
+      createSafeLogData({
+        operation: 'CREATE_MANY',
+        table: 'pageResource',
+        count: Array.isArray(data) ? data.length : 1,
+        data: data,
+      }),
+    );
+    const result = await this.prisma.pageResource.createMany({
+      data,
+      skipDuplicates: true,
+    });
+    this.logger.info(
+      '[PageResource] Multiple page resources created successfully',
+      createSafeLogData({
+        operation: 'CREATE_MANY',
+        table: 'pageResource',
+        count: result.count,
+      }),
+    );
+    return result;
+  }
+
+  async findMany(
+    pageResourceFindManyArgs: Prisma.PageResourceFindManyArgs,
+  ): Promise<{ itemCount: number; entities: PageResource[] }> {
+    const itemCount = await this.prisma.pageResource.count({
+      where: pageResourceFindManyArgs.where,
+    });
+    const entities = await this.prisma.pageResource.findMany(
+      pageResourceFindManyArgs,
+    );
+    return { itemCount, entities };
+  }
+
+  async findUnique(
+    id: number,
+    select: Prisma.PageResourceFindUniqueArgs['select'],
+  ) {
+    return await this.prisma.pageResource.findUnique({
+      where: { id: id },
+      select,
+    });
+  }
+
+  async updateMany(
+    pageResourceUpdateManyArgs: Prisma.PageResourceUpdateManyArgs,
+  ) {
+    this.logger.info(
+      '[PageResource] Updating multiple page resources',
+      createSafeLogData({
+        operation: 'UPDATE_MANY',
+        table: 'pageResource',
+        where: pageResourceUpdateManyArgs.where,
+        data: pageResourceUpdateManyArgs.data,
+      }),
+    );
+    const result = await this.prisma.pageResource.updateMany(
+      pageResourceUpdateManyArgs,
+    );
+    this.logger.info(
+      '[PageResource] Multiple page resources updated successfully',
+      createSafeLogData({
+        operation: 'UPDATE_MANY',
+        table: 'pageResource',
+        count: result.count,
+      }),
+    );
+    return result;
+  }
+
+  async updateUnique(
+    id: number,
+    data: Prisma.PageResourceUpdateManyArgs['data'],
+  ) {
+    const oldData = await this.prisma.pageResource.findUnique({
+      where: { id },
+    });
+    this.logger.info(
+      '[PageResource] Updating page resource',
+      createSafeLogData({
+        operation: 'UPDATE',
+        table: 'pageResource',
+        id: id,
+        oldData: oldData,
+        newData: data,
+      }),
+    );
+    const result = await this.prisma.pageResource.update({
+      where: { id: id },
+      data,
+    });
+    this.logger.info(
+      '[PageResource] Page resource updated successfully',
+      createSafeLogData({
+        operation: 'UPDATE',
+        table: 'pageResource',
+        id: id,
+        result: result,
+      }),
+    );
+    return result;
+  }
+
+  async deleteMany(
+    pageResourceDeleteManyArgs: Prisma.PageResourceDeleteManyArgs,
+  ) {
+    const oldData = await this.prisma.pageResource.findMany({
+      where: pageResourceDeleteManyArgs.where,
+    });
+    this.logger.info(
+      '[PageResource] Deleting multiple page resources',
+      createSafeLogData({
+        operation: 'DELETE_MANY',
+        table: 'pageResource',
+        where: pageResourceDeleteManyArgs.where,
+        oldData: oldData,
+      }),
+    );
+    const result = await this.prisma.pageResource.deleteMany(
+      pageResourceDeleteManyArgs,
+    );
+    this.logger.info(
+      '[PageResource] Multiple page resources deleted successfully',
+      createSafeLogData({
+        operation: 'DELETE_MANY',
+        table: 'pageResource',
+        count: result.count,
+      }),
+    );
+    return result;
+  }
+
+  async deleteUnique(id: number) {
+    const oldData = await this.prisma.pageResource.findUnique({
+      where: { id },
+    });
+    this.logger.info(
+      '[PageResource] Deleting page resource',
+      createSafeLogData({
+        operation: 'DELETE',
+        table: 'pageResource',
+        id: id,
+        oldData: oldData,
+      }),
+    );
+    await this.prisma.pageResource.delete({
+      where: { id: id },
+    });
+    this.logger.info(
+      '[PageResource] Page resource deleted successfully',
+      createSafeLogData({
+        operation: 'DELETE',
+        table: 'pageResource',
+        id: id,
+      }),
+    );
+    return { count: 1 };
+  }
+
+  async count(pageResourceCountArgs?: Prisma.PageResourceCountArgs) {
+    return await this.prisma.pageResource.count(pageResourceCountArgs);
+  }
+
+  async groupBy(pageResourceGroupByArgs: Prisma.PageResourceGroupByArgs) {
+    return await this.prisma.pageResource.groupBy(
+      pageResourceGroupByArgs as any,
+    );
+  }
+
+  async aggregate(pageResourceAggregateArgs: Prisma.PageResourceAggregateArgs) {
+    return await this.prisma.pageResource.aggregate(pageResourceAggregateArgs);
+  }
+}

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

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

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

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

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { ResourceController } from './resource.controller';
+import { ResourceService } from './resource.service';
+
+@Module({
+  controllers: [ResourceController],
+  providers: [ResourceService],
+  exports: [ResourceService],
+})
+export class ResourceModule {}