@gadmin2n/schematics 0.0.70 → 0.0.71

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

@@ -0,0 +1,249 @@
+import {
+  BadRequestException,
+  ConflictException,
+  Injectable,
+} from '@nestjs/common';
+import { PrismaService } from 'nestjs-prisma';
+import {
+  CreateCanvasDto,
+  CreateSavedQueryDto,
+  PublishCanvasDto,
+  UpdateCanvasDto,
+} from './canvas.dto';
+
+const SAVED_QUERY_FORBIDDEN =
+  /\b(INSERT|UPDATE|DELETE|DROP|ALTER|TRUNCATE|CREATE|REPLACE|MERGE)\b/i;
+
+@Injectable()
+export class CanvasService {
+  constructor(private prisma: PrismaService) {}
+
+  findAllByUser(userId: string) {
+    return this.prisma.canvas.findMany({
+      where: { userId },
+      orderBy: { createdAt: 'asc' },
+    });
+  }
+
+  findOne(id: string, userId: string) {
+    return this.prisma.canvas.findFirst({
+      where: { id, userId },
+    });
+  }
+
+  async findByPageCode(slug: string) {
+    const canvas = await this.prisma.canvas.findFirst({
+      where: { publishedPageCode: slug },
+    });
+    if (!canvas) {
+      throw new BadRequestException(`No published canvas for code: ${slug}`);
+    }
+    return { items: canvas.items, layout: canvas.layout, name: canvas.name };
+  }
+
+  async create(userId: string, dto: CreateCanvasDto) {
+    const existing = await this.prisma.canvas.findFirst({
+      where: { userId, name: dto.name },
+    });
+    if (existing) {
+      throw new ConflictException('Canvas 名称已存在');
+    }
+    return this.prisma.canvas.create({
+      data: {
+        userId,
+        name: dto.name,
+        items: dto.items ?? [],
+        layout: dto.layout ?? [],
+      },
+    });
+  }
+
+  async update(id: string, userId: string, dto: UpdateCanvasDto) {
+    if (dto.name !== undefined) {
+      const existing = await this.prisma.canvas.findFirst({
+        where: { userId, name: dto.name, NOT: { id } },
+      });
+      if (existing) {
+        throw new ConflictException('Canvas 名称已存在');
+      }
+    }
+
+    // 如果改名且已发布，同步更新 page 表的所有名称字段 + code + path
+    if (dto.name !== undefined) {
+      const canvas = await this.prisma.canvas.findFirst({
+        where: { id, userId },
+      });
+      if (canvas?.publishedPageCode) {
+        const newSlug =
+          dto.name
+            .toLowerCase()
+            .replace(/[\s_]+/g, '-')
+            .replace(/[^a-z0-9一-鿿-]/g, '')
+            .replace(/^-+|-+$/g, '') || 'canvas-page';
+
+        await this.prisma.page.updateMany({
+          where: { code: canvas.publishedPageCode },
+          data: {
+            code: newSlug,
+            name: dto.name,
+            zhName: dto.name,
+            path: `/admin/p/${newSlug}`,
+          },
+        });
+
+        // 同步更新 canvas 的 publishedPageCode 指向新 code
+        await this.prisma.canvas.update({
+          where: { id },
+          data: { publishedPageCode: newSlug },
+        });
+      }
+    }
+
+    return this.prisma.canvas.updateMany({
+      where: { id, userId },
+      data: {
+        ...(dto.name !== undefined && { name: dto.name }),
+        ...(dto.items !== undefined && { items: dto.items }),
+        ...(dto.layout !== undefined && { layout: dto.layout }),
+        ...(dto.publishedPageCode !== undefined && {
+          publishedPageCode: dto.publishedPageCode,
+        }),
+      },
+    });
+  }
+
+  async remove(id: string, userId: string) {
+    const canvas = await this.prisma.canvas.findFirst({
+      where: { id, userId },
+    });
+    if (!canvas) {
+      throw new BadRequestException('Canvas not found');
+    }
+
+    // If published, delete the page record
+    if (canvas.publishedPageCode) {
+      const page = await this.prisma.page.findFirst({
+        where: { code: canvas.publishedPageCode },
+      });
+      if (page) {
+        await this.prisma.rolePages.deleteMany({ where: { pageId: page.id } });
+        await this.prisma.page.delete({ where: { id: page.id } });
+      }
+    }
+
+    // Delete publish history
+    await this.prisma.canvasPublish.deleteMany({ where: { canvasId: id } });
+
+    // Delete canvas
+    return this.prisma.canvas.delete({ where: { id } });
+  }
+
+  async publish(id: string, userId: string, dto: PublishCanvasDto) {
+    const canvas = await this.prisma.canvas.findFirst({
+      where: { id, userId },
+    });
+    if (!canvas) {
+      throw new BadRequestException('Canvas not found');
+    }
+
+    // 确定 parentId
+    const parent = dto.parentPageCode
+      ? await this.prisma.page.findUnique({
+          where: { code: dto.parentPageCode },
+        })
+      : null;
+    const parentId = parent?.id ?? null;
+
+    // 算 sortOrder（插在同级末尾）
+    const siblings = await this.prisma.page.findMany({
+      where: { parentId },
+      orderBy: { sortOrder: 'desc' },
+      take: 1,
+    });
+    const nextSort = (siblings[0]?.sortOrder ?? 1000) + 10;
+
+    // upsert page 记录（导航栏）
+    const page = await this.prisma.page.upsert({
+      where: { code: dto.slug },
+      update: { zhName: dto.pageName, name: dto.pageName },
+      create: {
+        code: dto.slug,
+        name: dto.pageName,
+        zhName: dto.pageName,
+        enName: dto.slug,
+        path: `/admin/p/${dto.slug}`,
+        isVirtual: false,
+        sortOrder: nextSort,
+        parentId,
+      },
+    });
+
+    // 给 SYSTEM_ADMIN 授权
+    const role = await this.prisma.role.findFirst({
+      where: { name: 'SYSTEM_ADMIN' },
+    });
+    if (role) {
+      await this.prisma.rolePages.upsert({
+        where: { roleId_pageId: { roleId: role.id, pageId: page.id } },
+        update: {},
+        create: { roleId: role.id, pageId: page.id },
+      });
+    }
+
+    // 更新 canvas 的 publishedPageCode
+    await this.prisma.canvas.update({
+      where: { id },
+      data: { publishedPageCode: dto.slug, publishedAt: new Date() },
+    });
+
+    return { success: true, pageCode: dto.slug };
+  }
+
+  async unpublish(id: string, userId: string) {
+    const canvas = await this.prisma.canvas.findFirst({
+      where: { id, userId },
+    });
+    if (!canvas) {
+      throw new BadRequestException('Canvas not found');
+    }
+    if (!canvas.publishedPageCode) {
+      throw new BadRequestException('Canvas is not published');
+    }
+
+    // 删除 page 记录和权限
+    const page = await this.prisma.page.findFirst({
+      where: { code: canvas.publishedPageCode },
+    });
+    if (page) {
+      await this.prisma.rolePages.deleteMany({ where: { pageId: page.id } });
+      await this.prisma.page.delete({ where: { id: page.id } });
+    }
+
+    // 清空发布状态
+    await this.prisma.canvas.update({
+      where: { id },
+      data: { publishedPageCode: null, publishedAt: null },
+    });
+
+    return { success: true };
+  }
+
+  async savedQueryCreate(dto: CreateSavedQueryDto) {
+    const sql = dto.sql.trim();
+    if (!sql.toUpperCase().startsWith('SELECT')) {
+      throw new BadRequestException('Only SELECT statements are allowed');
+    }
+    if (SAVED_QUERY_FORBIDDEN.test(sql)) {
+      throw new BadRequestException('SQL contains forbidden keywords');
+    }
+    return this.prisma.savedQuery.create({
+      data: { sql, description: dto.description },
+    });
+  }
+
+  async savedQueryRun(id: number) {
+    const record = await this.prisma.savedQuery.findUnique({ where: { id } });
+    if (!record) throw new BadRequestException(`SavedQuery ${id} not found`);
+    return this.prisma.$queryRawUnsafe(record.sql);
+  }
+}

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

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

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

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

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

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { GameController } from './game.controller';
+import { GameService } from './game.service';
+
+@Module({
+  controllers: [GameController],
+  providers: [GameService],
+  exports: [GameService],
+})
+export class GameModule {}

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

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

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

@@ -0,0 +1,83 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { Game, 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 * as path from 'path';
+
+@Injectable()
+export class GameService {
+  constructor(
+    private prisma: PrismaService,
+    private readonly config: ConfigService,
+    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+  ) {
+    this.logger = this.logger.child({
+      file: path.basename(__filename),
+    });
+  }
+
+  async createOne(gameCreateArgs: Prisma.GameCreateArgs) {
+    return await this.prisma.game.create(gameCreateArgs);
+  }
+
+  async createMany(data: Prisma.GameCreateManyArgs['data']) {
+    return await this.prisma.game.createMany({
+      data,
+      skipDuplicates: true,
+    });
+  }
+
+  async findMany(
+    gameFindManyArgs: Prisma.GameFindManyArgs,
+  ): Promise<{ itemCount: number; entities: Game[] }> {
+    const itemCount = await this.prisma.game.count({
+      where: gameFindManyArgs.where,
+    });
+    const entities = await this.prisma.game.findMany(gameFindManyArgs);
+    return { itemCount, entities };
+  }
+
+  async findUnique(id: number, select: Prisma.GameFindUniqueArgs['select']) {
+    return await this.prisma.game.findUnique({
+      where: { id: id },
+      select,
+    });
+  }
+
+  async updateMany(gameUpdateManyArgs: Prisma.GameUpdateManyArgs) {
+    return await this.prisma.game.updateMany(gameUpdateManyArgs);
+  }
+
+  async updateUnique(id: number, data: Prisma.GameUpdateManyArgs['data']) {
+    return await this.prisma.game.update({
+      where: { id: id },
+      data,
+    });
+  }
+
+  async deleteMany(gameDeleteManyArgs: Prisma.GameDeleteManyArgs) {
+    return await this.prisma.game.deleteMany(gameDeleteManyArgs);
+  }
+
+  async deleteUnique(id: number) {
+    await this.prisma.game.delete({
+      where: { id: id },
+    });
+    return { count: 1 };
+  }
+
+  async count(gameCountArgs?: Prisma.GameCountArgs) {
+    return await this.prisma.game.count(gameCountArgs);
+  }
+
+  async groupBy(gameGroupByArgs: Prisma.GameGroupByArgs) {
+    return await this.prisma.game.groupBy(gameGroupByArgs as any);
+  }
+
+  async aggregate(gameAggregateArgs: Prisma.GameAggregateArgs) {
+    return await this.prisma.game.aggregate(gameAggregateArgs);
+  }
+}

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

@@ -0,0 +1,4 @@
+import generatedModules from '../generated/modules.index';
+import { CanvasModule } from './canvas/canvas.module';
+
+export default [...generatedModules, CanvasModule];

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

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