@gadmin2n/schematics 0.0.136 → 0.0.138

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

@@ -0,0 +1,203 @@
+import {
+  BadRequestException,
+  Injectable,
+  NotFoundException,
+  UnauthorizedException,
+} from '@nestjs/common';
+import * as jwt from 'jsonwebtoken';
+import { PrismaService } from 'nestjs-prisma';
+import { ExportPayload, ImportPreviewResponse } from './canvas-export.dto';
+
+const EXPORT_TOKEN_SECRET =
+  process.env.TAIHU_ODC_APP_TOKEN || 'gadmin-default-secret';
+const EXPORT_TOKEN_EXPIRY = 30 * 60; // 30 minutes in seconds
+
+// 匹配 Canvas Item 代码里硬编码的 saved-query 调用，如 fetch('/api/canvas/saved-query/42/run')
+const SAVED_QUERY_ID_PATTERN = /\/canvas\/saved-query\/(\d+)\/run/g;
+
+interface ExportTokenPayload {
+  canvasCode: string;
+}
+
+@Injectable()
+export class CanvasExportService {
+  constructor(private prisma: PrismaService) {}
+
+  /** Generate a JWT export token for a canvas */
+  async generateExportToken(
+    canvasId: string,
+    baseUrl: string,
+  ): Promise<{ url: string }> {
+    const canvas = await this.prisma.canvas.findUnique({
+      where: { id: canvasId },
+      select: { code: true },
+    });
+    if (!canvas) throw new NotFoundException('Canvas not found');
+
+    const token = jwt.sign(
+      { canvasCode: canvas.code } as ExportTokenPayload,
+      EXPORT_TOKEN_SECRET,
+      { expiresIn: EXPORT_TOKEN_EXPIRY },
+    );
+
+    const url = `${baseUrl}/canvas/export/${canvas.code}?token=${token}`;
+    return { url };
+  }
+
+  /** 从 canvas items 的 code 字符串里提取所有引用到的 SavedQuery id */
+  private extractSavedQueryIds(items: any[]): number[] {
+    const ids = new Set<number>();
+    for (const item of items ?? []) {
+      const code = item?.code ?? '';
+      let match: RegExpExecArray | null;
+      const pattern = new RegExp(SAVED_QUERY_ID_PATTERN);
+      while ((match = pattern.exec(code)) !== null) {
+        ids.add(Number(match[1]));
+      }
+    }
+    return Array.from(ids);
+  }
+
+  /** Verify export token and return the full export payload */
+  async getExportPayload(code: string, token: string): Promise<ExportPayload> {
+    let decoded: ExportTokenPayload;
+    try {
+      decoded = jwt.verify(token, EXPORT_TOKEN_SECRET) as ExportTokenPayload;
+    } catch {
+      throw new UnauthorizedException('Export token is invalid or expired');
+    }
+
+    if (decoded.canvasCode !== code) {
+      throw new UnauthorizedException('Token does not match this canvas');
+    }
+
+    const canvas = await this.prisma.canvas.findUnique({
+      where: { code },
+    });
+    if (!canvas) throw new NotFoundException('Canvas not found');
+
+    const items = (canvas.items as any[]) ?? [];
+    const savedQueryIds = this.extractSavedQueryIds(items);
+
+    const savedQueries =
+      savedQueryIds.length > 0
+        ? await this.prisma.savedQuery.findMany({
+            where: { id: { in: savedQueryIds } },
+          })
+        : [];
+
+    return {
+      version: 1,
+      exportedAt: new Date().toISOString(),
+      canvas: {
+        code: canvas.code,
+        name: canvas.name,
+        items,
+        layout: (canvas.layout as any[]) ?? [],
+      },
+      savedQueries: savedQueries.map((sq) => ({
+        sourceId: String(sq.id),
+        sql: sq.sql,
+        description: sq.description,
+      })),
+    };
+  }
+
+  /** Preview import — return current state vs incoming for diff */
+  async importPreview(payload: ExportPayload): Promise<ImportPreviewResponse> {
+    if (!payload?.canvas?.code) {
+      throw new BadRequestException('Invalid payload: missing canvas code');
+    }
+
+    const existing = await this.prisma.canvas.findFirst({
+      where: { code: payload.canvas.code },
+    });
+
+    const current: Partial<ExportPayload> | null = existing
+      ? {
+          canvas: {
+            code: existing.code,
+            name: existing.name,
+            items: (existing.items as any[]) ?? [],
+            layout: (existing.layout as any[]) ?? [],
+          },
+        }
+      : null;
+
+    return { current, incoming: payload };
+  }
+
+  /** Confirm import — execute upsert with SavedQuery id remapping in a transaction */
+  async importConfirm(
+    payload: ExportPayload,
+    userId: string,
+  ): Promise<{ success: boolean; canvasId: string; canvasName: string }> {
+    if (!payload?.canvas?.code) {
+      throw new BadRequestException('Invalid payload: missing canvas code');
+    }
+
+    return this.prisma.$transaction(async (tx) => {
+      // 1. 若目标环境已存在同 code 的已发布 Canvas，先清理旧的 Page/RolePages
+      const existing = await tx.canvas.findFirst({
+        where: { code: payload.canvas.code },
+      });
+      if (existing?.publishedPageCode) {
+        const page = await tx.page.findFirst({
+          where: { code: existing.publishedPageCode },
+        });
+        if (page) {
+          await tx.rolePages.deleteMany({ where: { pageId: page.id } });
+          await tx.page.delete({ where: { id: page.id } });
+        }
+      }
+
+      // 2. 按 sql 文本 upsert SavedQuery，建立 sourceId → newId 映射
+      const idMap = new Map<string, string>();
+      for (const sq of payload.savedQueries) {
+        let record = await tx.savedQuery.findFirst({ where: { sql: sq.sql } });
+        if (!record) {
+          record = await tx.savedQuery.create({
+            data: { sql: sq.sql, description: sq.description },
+          });
+        }
+        idMap.set(sq.sourceId, String(record.id));
+      }
+
+      // 3. 深拷贝 items，重写引用到的 saved-query id
+      const items = JSON.parse(JSON.stringify(payload.canvas.items ?? []));
+      for (const item of items) {
+        if (typeof item.code !== 'string') continue;
+        item.code = item.code.replace(
+          /\/canvas\/saved-query\/(\d+)\/run/g,
+          (match: string, oldId: string) => {
+            const newId = idMap.get(oldId);
+            return newId ? `/canvas/saved-query/${newId}/run` : match;
+          },
+        );
+      }
+
+      // 4. 按 code upsert Canvas（发布状态不参与导入，始终不带 publishedPageCode/publishedAt）
+      const canvas = await tx.canvas.upsert({
+        where: { code: payload.canvas.code },
+        create: {
+          code: payload.canvas.code,
+          name: payload.canvas.name,
+          userId,
+          items,
+          layout: payload.canvas.layout ?? [],
+        },
+        update: {
+          name: payload.canvas.name,
+          items,
+          layout: payload.canvas.layout ?? [],
+        },
+      });
+
+      return {
+        success: true,
+        canvasId: canvas.id,
+        canvasName: canvas.name,
+      };
+    });
+  }
+}

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

@@ -8,12 +8,15 @@ import {
   ParseIntPipe,
   Post,
   Put,
+  Query,
   Req,
-  UseGuards,
+  UnauthorizedException,
 } from '@nestjs/common';
 import { ApiTags } from '@nestjs/swagger';
 import { PrismaService } from 'nestjs-prisma';
-import AuthGuard, { AllowUnauthorizedRequest } from '../../lib/auth.guard';
+import { AllowUnauthorizedRequest } from '../../lib/auth.guard';
+import { ImportPayloadDto } from './canvas-export.dto';
+import { CanvasExportService } from './canvas-export.service';
 import {
   CreateCanvasDto,
   CreateSavedQueryDto,
@@ -23,12 +26,12 @@ import {
 import { CanvasService } from './canvas.service';
 
 @ApiTags('canvas')
-@UseGuards(AuthGuard)
 @Controller('canvas')
 export class CanvasController {
   constructor(
     private readonly canvasService: CanvasService,
     private readonly prisma: PrismaService,
+    private readonly canvasExportService: CanvasExportService,
   ) {}
 
   @Get()
@@ -98,6 +101,36 @@ export class CanvasController {
     return this.canvasService.remove(id, req.user.userid);
   }
 
+  // ─── Export/Import Endpoints ──────────────────────────────────────────────────
+
+  @Post(':id/export-token')
+  async generateExportToken(@Param('id') id: string, @Req() req) {
+    const baseUrl = `${req.protocol}://${req.get('host')}/api`;
+    return this.canvasExportService.generateExportToken(id, baseUrl);
+  }
+
+  @Get('export/:code')
+  @AllowUnauthorizedRequest()
+  async getExportPayload(
+    @Param('code') code: string,
+    @Query('token') token: string,
+  ) {
+    if (!token) {
+      throw new UnauthorizedException('Export token is required');
+    }
+    return this.canvasExportService.getExportPayload(code, token);
+  }
+
+  @Post('import-preview')
+  async importPreview(@Body() dto: ImportPayloadDto) {
+    return this.canvasExportService.importPreview(dto.payload);
+  }
+
+  @Post('import-confirm')
+  async importConfirm(@Body() dto: ImportPayloadDto, @Req() req) {
+    return this.canvasExportService.importConfirm(dto.payload, req.user.userid);
+  }
+
   @Post(':id/publish')
   publish(@Req() req, @Param('id') id: string, @Body() dto: PublishCanvasDto) {
     return this.canvasService.publish(id, req.user.userid, dto);

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

@@ -1,11 +1,12 @@
 import { Module } from '@nestjs/common';
 import { UserModule } from '../user/user.module';
+import { CanvasExportService } from './canvas-export.service';
 import { CanvasController } from './canvas.controller';
 import { CanvasService } from './canvas.service';
 
 @Module({
   imports: [UserModule],
   controllers: [CanvasController],
-  providers: [CanvasService],
+  providers: [CanvasService, CanvasExportService],
 })
 export class CanvasModule {}

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

@@ -0,0 +1,54 @@
+/// <reference types="jest" />
+import { ConfigService } from '@nestjs/config';
+import { Test, TestingModule } from '@nestjs/testing';
+import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
+import { TemporalTenantConfigController } from './temporalTenantConfig.controller';
+import { TemporalTenantConfigService } from './temporalTenantConfig.service';
+
+// Mock TemporalTenantConfigService：用空对象屏蔽真实 Service 的依赖（PrismaService 等），
+// 避免 NestJS 在测试模块编译时去解析 Service 的构造参数。
+const mockTemporalTenantConfigService = {};
+
+// Mock ConfigService
+const mockConfigService = {
+  get: jest.fn(),
+};
+
+// Mock Logger
+const mockLogger = {
+  child: jest.fn().mockReturnThis(),
+  info: jest.fn(),
+  error: jest.fn(),
+  warn: jest.fn(),
+  debug: jest.fn(),
+};
+
+describe('TemporalTenantConfigController', () => {
+  let controller: TemporalTenantConfigController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [TemporalTenantConfigController],
+      providers: [
+        {
+          provide: TemporalTenantConfigService,
+          useValue: mockTemporalTenantConfigService,
+        },
+        { provide: ConfigService, useValue: mockConfigService },
+        { provide: WINSTON_MODULE_PROVIDER, useValue: mockLogger },
+      ],
+    })
+      // 兜底：自动 mock 任何未显式提供的依赖
+      // （例如 ACGuard 内部的 __roles_builder__ token）
+      .useMocker(() => ({}))
+      .compile();
+
+    controller = module.get<TemporalTenantConfigController>(
+      TemporalTenantConfigController,
+    );
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

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

@@ -0,0 +1,245 @@
+import {
+  ACAttrFilter,
+  ACGuard,
+  ApiPaginatedResponse,
+  diskStorage,
+  PageDto,
+  PageMetaDto,
+  PageOptionsDto,
+  pick,
+  UserType,
+} from '@gadmin2n/nest-common';
+import {
+  BadRequestException,
+  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 { CreateTemporalTenantConfigDto } from '../../generated/temporalTenantConfig/dto/create-temporalTenantConfig.dto';
+import {
+  EffectedCount,
+  TemporalTenantConfigFindManyArgs,
+  TemporalTenantConfigWhereSelect,
+  UploadResponse,
+} from '../../generated/temporalTenantConfig/dto/temporalTenantConfig-types.dto';
+import { UpdateTemporalTenantConfigDto } from '../../generated/temporalTenantConfig/dto/update-temporalTenantConfig.dto';
+import { TemporalTenantConfigEntity } from '../../generated/temporalTenantConfig/entities/temporalTenantConfig.entity';
+import { TemporalTenantConfigService } from './temporalTenantConfig.service';
+
+import { ConfigService } from '@nestjs/config';
+import { FileInterceptor } from '@nestjs/platform-express';
+
+@UseGuards(ACGuard)
+@Controller('temporalTenantConfig')
+@ApiTags('temporalTenantConfig')
+export class TemporalTenantConfigController {
+  constructor(
+    private readonly temporalTenantConfigService: TemporalTenantConfigService,
+    private readonly config: ConfigService,
+    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+  ) {}
+
+  @Post('createOne')
+  @UseRoles({
+    resource: 'temporalTenantConfig',
+    action: 'create',
+    possession: 'any',
+  })
+  @ApiCreatedResponse({ type: TemporalTenantConfigEntity })
+  async createOne(
+    @Body() body: CreateTemporalTenantConfigDto,
+    @ACAttrFilter() acAttrFilter,
+    @Req() request: Request & { user: UserType },
+  ) {
+    body.creator = request.user.username;
+
+    // 先调 shared temporal admin API（原子：失败则不写 DB）
+    const res = await fetch(`${body.adminUrl}/admin/tenants`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Admin-Token': body.adminToken,
+      },
+      body: JSON.stringify({
+        namespace: body.namespace,
+        displayName: body.displayName,
+        dbUrl: body.dbUrl,
+      }),
+    });
+    if (!res.ok) {
+      const detail = await res.text().catch(() => '');
+      throw new BadRequestException(
+        `shared temporal API 注册失败 (${res.status}): ${detail}`,
+      );
+    }
+
+    return new TemporalTenantConfigEntity(
+      await this.temporalTenantConfigService.createOne({
+        data: acAttrFilter(body),
+      }),
+    );
+  }
+
+  @Post('findMany')
+  @UseRoles({
+    resource: 'temporalTenantConfig',
+    action: 'read',
+    possession: 'any',
+  })
+  @ApiPaginatedResponse(TemporalTenantConfigEntity)
+  async findMany(
+    @Body() body: TemporalTenantConfigFindManyArgs,
+    @ACAttrFilter() acAttrFilter,
+  ): Promise<PageDto<TemporalTenantConfigEntity>> {
+    const { itemCount, entities } =
+      await this.temporalTenantConfigService.findMany(
+        body as Prisma.TemporalTenantConfigFindManyArgs,
+      );
+    const { skip = 0, take = 10 } =
+      body as Prisma.TemporalTenantConfigFindManyArgs;
+    const pageOptionsDto: PageOptionsDto = { skip, take };
+    const pageMetaDto = new PageMetaDto({ itemCount, pageOptionsDto });
+
+    return new PageDto(
+      entities.map(
+        (item) => new TemporalTenantConfigEntity(acAttrFilter(item)),
+      ),
+      pageMetaDto,
+    );
+  }
+
+  @Post('/findUnique/:id')
+  @UseRoles({
+    resource: 'temporalTenantConfig',
+    action: 'read',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: TemporalTenantConfigEntity })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async findUnique(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() body: TemporalTenantConfigWhereSelect,
+    @ACAttrFilter() acAttrFilter,
+  ) {
+    const item = await this.temporalTenantConfigService.findUnique(id, body);
+    if (!item) {
+      throw new NotFoundException();
+    }
+    return new TemporalTenantConfigEntity(acAttrFilter(item));
+  }
+
+  @Patch('updateUnique/:id')
+  @UseRoles({
+    resource: 'temporalTenantConfig',
+    action: 'update',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: TemporalTenantConfigEntity })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async updateUnique(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() body: UpdateTemporalTenantConfigDto,
+    @ACAttrFilter() acAttrFilter,
+  ) {
+    const existing = await this.temporalTenantConfigService.findUnique(id, {
+      adminUrl: true,
+      adminToken: true,
+      namespace: true,
+    });
+    if (!existing) throw new NotFoundException();
+
+    const adminUrl = (body.adminUrl ?? existing.adminUrl) as string;
+    const adminToken = (body.adminToken ?? existing.adminToken) as string;
+    const namespace = (body.namespace ?? existing.namespace) as string;
+
+    const patchBody: Record<string, string> = {};
+    if (body.dbUrl) patchBody.dbUrl = body.dbUrl;
+    if (body.displayName) patchBody.displayName = body.displayName;
+
+    if (Object.keys(patchBody).length > 0) {
+      const res = await fetch(
+        `${adminUrl}/admin/tenants/${encodeURIComponent(namespace)}`,
+        {
+          method: 'PATCH',
+          headers: {
+            'Content-Type': 'application/json',
+            'X-Admin-Token': adminToken,
+          },
+          body: JSON.stringify(patchBody),
+        },
+      );
+      if (!res.ok) {
+        const detail = await res.text().catch(() => '');
+        throw new BadRequestException(
+          `shared temporal API 更新失败 (${res.status}): ${detail}`,
+        );
+      }
+    }
+
+    const item = await this.temporalTenantConfigService.updateUnique(
+      id,
+      acAttrFilter(body),
+    );
+    return new TemporalTenantConfigEntity(acAttrFilter(item));
+  }
+
+  @Delete('deleteUnique/:id')
+  @UseRoles({
+    resource: 'temporalTenantConfig',
+    action: 'delete',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: EffectedCount })
+  @ApiNotFoundResponse({ description: 'Cannot found this record.' })
+  async deleteUnique(@Param('id', ParseIntPipe) id: number) {
+    const res = await this.temporalTenantConfigService.deleteUnique(id);
+    if (!res.count) {
+      throw new NotFoundException();
+    }
+    return res;
+  }
+
+  @Post('upload')
+  @UseRoles({
+    resource: 'temporalTenantConfig',
+    action: 'create',
+    possession: 'any',
+  })
+  @ApiCreatedResponse({ type: UploadResponse })
+  @UseInterceptors(FileInterceptor('file'))
+  async uploadFile(@UploadedFile() file: Express.Multer.File) {
+    const fileName = await diskStorage(
+      file,
+      this.config.get('media')['rootDir'] + '/temporalTenantConfig/',
+    );
+
+    return {
+      ...pick(file, ['mimetype', 'originalname', 'size']),
+      url:
+        this.config.get('media')['address'] +
+        '/temporalTenantConfig/' +
+        fileName,
+      name: fileName,
+    };
+  }
+}

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

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { TemporalTenantConfigController } from './temporalTenantConfig.controller';
+import { TemporalTenantConfigService } from './temporalTenantConfig.service';
+
+@Module({
+  controllers: [TemporalTenantConfigController],
+  providers: [TemporalTenantConfigService],
+  exports: [TemporalTenantConfigService],
+})
+export class TemporalTenantConfigModule {}