@gadmin2n/schematics 0.0.150 → 0.0.152

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

@@ -0,0 +1,28 @@
+import { Module } from '@nestjs/common';
+import { PageTransferService } from './page-transfer.service';
+import { ResourceTransferService } from './resource-transfer.service';
+import { RoleTransferService } from './role-transfer.service';
+import { TransferTokenService } from './transfer-token.service';
+import { UserTransferService } from './user-transfer.service';
+
+/**
+ * Cross-environment import/export for permission data
+ * (user / role / page / resource). Core logic lives here;
+ * each entity's controller only declares thin endpoints.
+ */
+@Module({
+  providers: [
+    TransferTokenService,
+    UserTransferService,
+    RoleTransferService,
+    PageTransferService,
+    ResourceTransferService,
+  ],
+  exports: [
+    UserTransferService,
+    RoleTransferService,
+    PageTransferService,
+    ResourceTransferService,
+  ],
+})
+export class PermTransferModule {}

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

@@ -0,0 +1,137 @@
+import { Inject, Injectable, NotFoundException } from '@nestjs/common';
+import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
+import { PrismaService } from 'nestjs-prisma';
+import * as path from 'path';
+import { Logger } from 'winston';
+import {
+  assertTransferPayload,
+  ImportPreviewResponse,
+  ResourceExportPayload,
+  TRANSFER_PAYLOAD_VERSION,
+  TransferPayload,
+} from './perm-transfer.dto';
+import { TransferTokenService } from './transfer-token.service';
+
+@Injectable()
+export class ResourceTransferService {
+  constructor(
+    private prisma: PrismaService,
+    private readonly tokenService: TransferTokenService,
+    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+  ) {
+    this.logger = this.logger.child({ file: path.basename(__filename) });
+  }
+
+  async generateExportToken(
+    code: string,
+    baseUrl: string,
+  ): Promise<{ url: string }> {
+    const resource = await this.prisma.resource.findUnique({
+      where: { code },
+      select: { code: true },
+    });
+    if (!resource) throw new NotFoundException('Resource not found');
+
+    const token = this.tokenService.sign('resource', code);
+    return {
+      url: this.tokenService.buildUrl(baseUrl, 'resource', code, token),
+    };
+  }
+
+  async getExportPayload(
+    code: string,
+    token: string,
+  ): Promise<ResourceExportPayload> {
+    this.tokenService.verify(token, 'resource', code);
+
+    const resource = await this.prisma.resource.findUnique({
+      where: { code },
+    });
+    if (!resource) throw new NotFoundException('Resource not found');
+
+    return {
+      version: TRANSFER_PAYLOAD_VERSION,
+      exportedAt: new Date().toISOString(),
+      entity: 'resource',
+      resource: {
+        code: resource.code,
+        name: resource.name,
+        description: resource.description,
+        isCommonResource: resource.isCommonResource,
+      },
+    };
+  }
+
+  async importPreview(
+    payload: TransferPayload,
+  ): Promise<ImportPreviewResponse> {
+    assertTransferPayload(payload, 'resource');
+    const incoming = (payload as ResourceExportPayload).resource;
+
+    const current = await this.prisma.resource.findUnique({
+      where: { code: incoming.code },
+    });
+
+    // code/name are both unique — detect a name clash on a different record
+    const conflicts: string[] = [];
+    const nameOwner = await this.prisma.resource.findUnique({
+      where: { name: incoming.name },
+      select: { code: true },
+    });
+    if (nameOwner && nameOwner.code !== incoming.code) {
+      conflicts.push(
+        `name "${incoming.name}" is already used by resource "${nameOwner.code}"`,
+      );
+    }
+
+    return {
+      current: current
+        ? {
+            resource: {
+              code: current.code,
+              name: current.name,
+              description: current.description,
+              isCommonResource: current.isCommonResource,
+            },
+          }
+        : null,
+      incoming: { resource: incoming },
+      missingRefs: [],
+      conflicts,
+    };
+  }
+
+  async importConfirm(
+    payload: TransferPayload,
+    operator: string,
+  ): Promise<{ success: true; key: string }> {
+    assertTransferPayload(payload, 'resource');
+    const incoming = (payload as ResourceExportPayload).resource;
+
+    this.logger.info(
+      `[permTransfer] resource import_confirm - code: ${incoming.code}, operator: ${operator}`,
+    );
+    await this.prisma.$transaction(async (tx) => {
+      await tx.resource.upsert({
+        where: { code: incoming.code },
+        create: { ...incoming, creator: operator },
+        update: incoming,
+      });
+      await tx.audit.create({
+        data: {
+          creator: operator,
+          authorName: operator,
+          action: 'IMPORT_RESOURCE',
+          resource: 'resource',
+          resourceId: incoming.code,
+          data: JSON.stringify({
+            code: incoming.code,
+            name: incoming.name,
+            isCommonResource: incoming.isCommonResource,
+          }),
+        },
+      });
+    });
+    return { success: true, key: incoming.code };
+  }
+}

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

@@ -0,0 +1,248 @@
+import {
+  BadRequestException,
+  Inject,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+import { Prisma } from '@prisma/client';
+import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
+import { PrismaService } from 'nestjs-prisma';
+import * as path from 'path';
+import { Logger } from 'winston';
+import {
+  assertTransferPayload,
+  ImportPreviewResponse,
+  MissingRef,
+  RoleExportPayload,
+  RoleResourceTransferItem,
+  TRANSFER_PAYLOAD_VERSION,
+  TransferPayload,
+} from './perm-transfer.dto';
+import { TransferTokenService } from './transfer-token.service';
+
+@Injectable()
+export class RoleTransferService {
+  constructor(
+    private prisma: PrismaService,
+    private readonly tokenService: TransferTokenService,
+    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+  ) {
+    this.logger = this.logger.child({ file: path.basename(__filename) });
+  }
+
+  async generateExportToken(
+    name: string,
+    baseUrl: string,
+  ): Promise<{ url: string }> {
+    const role = await this.prisma.role.findUnique({
+      where: { name },
+      select: { name: true },
+    });
+    if (!role) throw new NotFoundException('Role not found');
+
+    const token = this.tokenService.sign('role', name);
+    return { url: this.tokenService.buildUrl(baseUrl, 'role', name, token) };
+  }
+
+  private async assemble(
+    name: string,
+    client: Prisma.TransactionClient | PrismaService = this.prisma,
+  ): Promise<{
+    role: { name: string; description: string | null };
+    rolePages: string[];
+    roleResources: RoleResourceTransferItem[];
+  } | null> {
+    const role = await client.role.findUnique({
+      where: { name },
+      include: {
+        rolePages: { include: { page: { select: { code: true } } } },
+        roleResources: { include: { resource: { select: { code: true } } } },
+      },
+    });
+    if (!role) return null;
+
+    return {
+      role: { name: role.name, description: role.description },
+      rolePages: role.rolePages.map((rp) => rp.page.code).sort(),
+      roleResources: role.roleResources
+        .map((rr) => ({
+          resourceCode: rr.resource.code,
+          actions: rr.actions,
+        }))
+        .sort((a, b) => a.resourceCode.localeCompare(b.resourceCode)),
+    };
+  }
+
+  async getExportPayload(
+    name: string,
+    token: string,
+  ): Promise<RoleExportPayload> {
+    this.tokenService.verify(token, 'role', name);
+
+    const data = await this.assemble(name);
+    if (!data) throw new NotFoundException('Role not found');
+
+    return {
+      version: TRANSFER_PAYLOAD_VERSION,
+      exportedAt: new Date().toISOString(),
+      entity: 'role',
+      ...data,
+    };
+  }
+
+  private async findMissingRefs(
+    rolePages: string[],
+    roleResources: RoleResourceTransferItem[],
+  ): Promise<MissingRef[]> {
+    const pageCodes = [...new Set(rolePages)];
+    const resourceCodes = [
+      ...new Set(roleResources.map((r) => r.resourceCode)),
+    ];
+    const [pages, resources] = await Promise.all([
+      pageCodes.length
+        ? this.prisma.page.findMany({
+            where: { code: { in: pageCodes } },
+            select: { code: true },
+          })
+        : [],
+      resourceCodes.length
+        ? this.prisma.resource.findMany({
+            where: { code: { in: resourceCodes } },
+            select: { code: true },
+          })
+        : [],
+    ]);
+    const existingPages = new Set(pages.map((p) => p.code));
+    const existingResources = new Set(resources.map((r) => r.code));
+
+    return [
+      ...pageCodes
+        .filter((c) => !existingPages.has(c))
+        .map((code): MissingRef => ({ type: 'page', code })),
+      ...resourceCodes
+        .filter((c) => !existingResources.has(c))
+        .map((code): MissingRef => ({ type: 'resource', code })),
+    ];
+  }
+
+  async importPreview(
+    payload: TransferPayload,
+  ): Promise<ImportPreviewResponse> {
+    assertTransferPayload(payload, 'role');
+    const { role, rolePages, roleResources } = payload as RoleExportPayload;
+
+    const current = await this.assemble(role.name);
+    const missingRefs = await this.findMissingRefs(rolePages, roleResources);
+
+    return {
+      current,
+      incoming: { role, rolePages, roleResources },
+      missingRefs,
+      conflicts: [],
+    };
+  }
+
+  async importConfirm(
+    payload: TransferPayload,
+    operator: string,
+  ): Promise<{ success: true; key: string }> {
+    assertTransferPayload(payload, 'role');
+    const { role, rolePages, roleResources } = payload as RoleExportPayload;
+
+    this.logger.info(
+      `[permTransfer] role import_confirm - name: ${role.name}, operator: ${operator}`,
+    );
+    await this.prisma.$transaction(async (tx) => {
+      const saved = await tx.role.upsert({
+        where: { name: role.name },
+        create: {
+          name: role.name,
+          description: role.description,
+          creator: operator,
+        },
+        update: { description: role.description },
+        select: { id: true },
+      });
+
+      // resolve refs inside the transaction; missing → throw → rollback
+      const pageCodes = [...new Set(rolePages)];
+      const resourceCodes = [
+        ...new Set(roleResources.map((r) => r.resourceCode)),
+      ];
+      const [pages, resources] = await Promise.all([
+        pageCodes.length
+          ? tx.page.findMany({
+              where: { code: { in: pageCodes } },
+              select: { id: true, code: true },
+            })
+          : [],
+        resourceCodes.length
+          ? tx.resource.findMany({
+              where: { code: { in: resourceCodes } },
+              select: { id: true, code: true },
+            })
+          : [],
+      ]);
+      const pageIdByCode = new Map<string, number>(
+        pages.map((p) => [p.code, p.id] as [string, number]),
+      );
+      const resourceIdByCode = new Map<string, number>(
+        resources.map((r) => [r.code, r.id] as [string, number]),
+      );
+      const missingPage = pageCodes.find((c) => !pageIdByCode.has(c));
+      if (missingPage) {
+        throw new BadRequestException(
+          `Referenced page does not exist: ${missingPage} (import it first)`,
+        );
+      }
+      const missingResource = resourceCodes.find(
+        (c) => !resourceIdByCode.has(c),
+      );
+      if (missingResource) {
+        throw new BadRequestException(
+          `Referenced resource does not exist: ${missingResource} (import it first)`,
+        );
+      }
+
+      // full overwrite: wipe associations, then rebuild from the payload
+      await tx.rolePages.deleteMany({ where: { roleId: saved.id } });
+      await tx.roleResource.deleteMany({ where: { roleId: saved.id } });
+      if (pageCodes.length > 0) {
+        await tx.rolePages.createMany({
+          data: pageCodes.map((code) => ({
+            roleId: saved.id,
+            pageId: pageIdByCode.get(code)!,
+            creator: operator,
+          })),
+        });
+      }
+      if (roleResources.length > 0) {
+        await tx.roleResource.createMany({
+          data: roleResources.map((rr) => ({
+            roleId: saved.id,
+            resourceId: resourceIdByCode.get(rr.resourceCode)!,
+            actions: rr.actions as Prisma.InputJsonValue,
+            creator: operator,
+          })),
+        });
+      }
+
+      await tx.audit.create({
+        data: {
+          creator: operator,
+          authorName: operator,
+          action: 'IMPORT_ROLE',
+          resource: 'role',
+          resourceId: role.name,
+          data: JSON.stringify({
+            name: role.name,
+            rolePages,
+            roleResources: roleResources.map((rr) => rr.resourceCode),
+          }),
+        },
+      });
+    });
+
+    return { success: true, key: role.name };
+  }
+}

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

@@ -0,0 +1,65 @@
+import {
+  Injectable,
+  InternalServerErrorException,
+  UnauthorizedException,
+} from '@nestjs/common';
+import * as jwt from 'jsonwebtoken';
+import { TransferEntityKind } from './perm-transfer.dto';
+
+const EXPORT_TOKEN_EXPIRY = 30 * 60; // 30 minutes in seconds
+
+interface ExportTokenPayload {
+  entity: TransferEntityKind;
+  key: string;
+}
+
+function exportTokenSecret(): string {
+  const secret = process.env.TAIHU_ODC_APP_TOKEN?.trim();
+  if (!secret)
+    throw new InternalServerErrorException(
+      'Export token secret is not configured',
+    );
+  return secret;
+}
+
+/**
+ * Signs/verifies the short-lived JWT that authorizes pulling an export
+ * payload from a source environment. Mirrors the workflow export token
+ * mechanism (workflow-export.service.ts).
+ */
+@Injectable()
+export class TransferTokenService {
+  sign(entity: TransferEntityKind, key: string): string {
+    return jwt.sign(
+      { entity, key } as ExportTokenPayload,
+      exportTokenSecret(),
+      {
+        expiresIn: EXPORT_TOKEN_EXPIRY,
+      },
+    );
+  }
+
+  /** @throws UnauthorizedException when invalid/expired or entity/key mismatch */
+  verify(token: string, entity: TransferEntityKind, key: string): void {
+    let decoded: ExportTokenPayload;
+    try {
+      decoded = jwt.verify(token, exportTokenSecret()) as ExportTokenPayload;
+    } catch {
+      throw new UnauthorizedException('Export token is invalid or expired');
+    }
+    if (decoded.entity !== entity || decoded.key !== key) {
+      throw new UnauthorizedException('Token does not match this export');
+    }
+  }
+
+  buildUrl(
+    baseUrl: string,
+    entity: TransferEntityKind,
+    key: string,
+    token: string,
+  ): string {
+    return `${baseUrl}/${entity}/export/${encodeURIComponent(
+      key,
+    )}?token=${token}`;
+  }
+}

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

@@ -0,0 +1,146 @@
+import { Inject, Injectable, NotFoundException } from '@nestjs/common';
+import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
+import { PrismaService } from 'nestjs-prisma';
+import * as path from 'path';
+import { Logger } from 'winston';
+import {
+  assertTransferPayload,
+  ImportPreviewResponse,
+  TRANSFER_PAYLOAD_VERSION,
+  TransferPayload,
+  UserExportPayload,
+  UserTransferData,
+} from './perm-transfer.dto';
+import { TransferTokenService } from './transfer-token.service';
+
+/** Stored as a JSON string in t_admin_user_role.roles; tolerate dirty data. */
+function parseRoles(raw: string): unknown {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+
+function stringifyRoles(roles: unknown): string {
+  return typeof roles === 'string' ? roles : JSON.stringify(roles ?? []);
+}
+
+@Injectable()
+export class UserTransferService {
+  constructor(
+    private prisma: PrismaService,
+    private readonly tokenService: TransferTokenService,
+    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+  ) {
+    this.logger = this.logger.child({ file: path.basename(__filename) });
+  }
+
+  async generateExportToken(
+    userid: string,
+    baseUrl: string,
+  ): Promise<{ url: string }> {
+    const user = await this.prisma.user.findUnique({
+      where: { userid },
+      select: { userid: true },
+    });
+    if (!user) throw new NotFoundException('User not found');
+
+    const token = this.tokenService.sign('user', userid);
+    return { url: this.tokenService.buildUrl(baseUrl, 'user', userid, token) };
+  }
+
+  async getExportPayload(
+    userid: string,
+    token: string,
+  ): Promise<UserExportPayload> {
+    this.tokenService.verify(token, 'user', userid);
+
+    const user = await this.prisma.user.findUnique({ where: { userid } });
+    if (!user) throw new NotFoundException('User not found');
+
+    return {
+      version: TRANSFER_PAYLOAD_VERSION,
+      exportedAt: new Date().toISOString(),
+      entity: 'user',
+      user: {
+        userid: user.userid,
+        username: user.username,
+        roles: parseRoles(user.roles),
+        description: user.description,
+        isActive: user.isActive,
+      },
+    };
+  }
+
+  private toComparable(user: UserTransferData) {
+    return { user };
+  }
+
+  async importPreview(
+    payload: TransferPayload,
+  ): Promise<ImportPreviewResponse> {
+    assertTransferPayload(payload, 'user');
+    const incoming = (payload as UserExportPayload).user;
+
+    const current = await this.prisma.user.findUnique({
+      where: { userid: incoming.userid },
+    });
+
+    return {
+      current: current
+        ? this.toComparable({
+            userid: current.userid,
+            username: current.username,
+            roles: parseRoles(current.roles),
+            description: current.description,
+            isActive: current.isActive,
+          })
+        : null,
+      incoming: this.toComparable(incoming),
+      missingRefs: [],
+      conflicts: [],
+    };
+  }
+
+  async importConfirm(
+    payload: TransferPayload,
+    operator: string,
+  ): Promise<{ success: true; key: string }> {
+    assertTransferPayload(payload, 'user');
+    const incoming = (payload as UserExportPayload).user;
+
+    this.logger.info(
+      `[permTransfer] user import_confirm - userid: ${incoming.userid}, operator: ${operator}`,
+    );
+    const data = {
+      username: incoming.username,
+      roles: stringifyRoles(incoming.roles),
+      description: incoming.description,
+      isActive: incoming.isActive,
+    };
+    await this.prisma.$transaction(async (tx) => {
+      await tx.user.upsert({
+        where: { userid: incoming.userid },
+        create: { userid: incoming.userid, ...data, creator: operator },
+        update: data,
+      });
+      await tx.audit.create({
+        data: {
+          creator: operator,
+          authorName: operator,
+          action: 'IMPORT_USER',
+          resource: 'user',
+          resourceId: incoming.userid,
+          data: JSON.stringify({
+            userid: incoming.userid,
+            username: incoming.username,
+            roles: incoming.roles,
+            isActive: incoming.isActive,
+          }),
+        },
+      });
+    });
+    return { success: true, key: incoming.userid };
+  }
+}