@gadmin2n/schematics 0.0.147 → 0.0.148

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

@@ -175,6 +175,17 @@ export class UserController {
     return res;
   }
 
+  @Delete('deletePerson/:id')
+  @UseRoles({
+    resource: 'user',
+    action: 'delete',
+    possession: 'any',
+  })
+  @ApiOkResponse({ type: EffectedCount })
+  async deletePerson(@Param('id', ParseIntPipe) id: number) {
+    return this.userService.deletePerson(id);
+  }
+
   @Post('upload')
   @UseRoles({
     resource: 'user',

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

@@ -1,6 +1,8 @@
 /// <reference types="jest" />
+import { ConflictException } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { Test, TestingModule } from '@nestjs/testing';
+import { Prisma } from '@prisma/client';
 import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
 
 // Mock nestjs-prisma 模块
@@ -26,6 +28,12 @@ const mockPrismaService = {
     groupBy: jest.fn(),
     aggregate: jest.fn(),
   },
+  workflow: {
+    findMany: jest.fn(),
+  },
+  approvalCandidate: {
+    count: jest.fn(),
+  },
 };
 
 // Mock Logger
@@ -103,6 +111,28 @@ describe('UserService', () => {
         'Database connection failed',
       );
     });
+
+    it('returns a useful conflict when userid already exists', async () => {
+      prisma.user.create.mockRejectedValue(
+        new Prisma.PrismaClientKnownRequestError('duplicate userid', {
+          code: 'P2002',
+          clientVersion: '6.19.3',
+          meta: { target: ['userid'] },
+        }),
+      );
+
+      await expect(
+        service.createOne({
+          data: { userid: 'existing-user', roles: '[]' },
+        } as any),
+      ).rejects.toMatchObject({
+        constructor: ConflictException,
+        response: {
+          code: 'USER_ALREADY_EXISTS',
+          message: '该人员已存在，无需重复添加',
+        },
+      });
+    });
   });
 
   describe('createMany', () => {
@@ -133,6 +163,73 @@ describe('UserService', () => {
     });
   });
 
+  describe('deletePerson', () => {
+    it('deletes an unreferenced person without roles', async () => {
+      prisma.user.findUnique.mockResolvedValue({
+        userid: 'person-a',
+        roles: '[]',
+        groupMemberships: [],
+      });
+      prisma.workflow.findMany.mockResolvedValue([]);
+      prisma.approvalCandidate.count.mockResolvedValue(0);
+      prisma.user.delete.mockResolvedValue({ id: 10 });
+
+      await expect(service.deletePerson(10)).resolves.toEqual({ count: 1 });
+      expect(prisma.user.delete).toHaveBeenCalledWith({ where: { id: 10 } });
+    });
+
+    it('rejects deleting a person that still has a role', async () => {
+      prisma.user.findUnique.mockResolvedValue({
+        userid: 'admin-a',
+        roles: '["SYSTEM_ADMIN"]',
+        groupMemberships: [],
+      });
+      prisma.workflow.findMany.mockResolvedValue([]);
+      prisma.approvalCandidate.count.mockResolvedValue(0);
+
+      await expect(service.deletePerson(10)).rejects.toMatchObject({
+        response: {
+          code: 'PERSON_IN_USE',
+          roles: ['SYSTEM_ADMIN'],
+        },
+      });
+      expect(prisma.user.delete).not.toHaveBeenCalled();
+    });
+
+    it('rejects deleting a person referenced by a Workflow', async () => {
+      prisma.user.findUnique.mockResolvedValue({
+        userid: 'approver-a',
+        roles: '[]',
+        groupMemberships: [],
+      });
+      prisma.workflow.findMany.mockResolvedValue([
+        {
+          id: BigInt(7),
+          name: '资产审批',
+          dsl: {
+            nodes: [
+              {
+                config: {
+                  subjects: [{ source: 'STATIC', refs: ['approver-a'] }],
+                },
+              },
+            ],
+          },
+          versions: [],
+        },
+      ]);
+      prisma.approvalCandidate.count.mockResolvedValue(0);
+
+      await expect(service.deletePerson(10)).rejects.toMatchObject({
+        response: {
+          code: 'PERSON_IN_USE',
+          workflows: [{ id: '7', name: '资产审批' }],
+        },
+      });
+      expect(prisma.user.delete).not.toHaveBeenCalled();
+    });
+  });
+
   describe('findMany', () => {
     it('should return entities with itemCount', async () => {
       const findArgs = {

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

@@ -1,4 +1,9 @@
-import { Inject, Injectable } from '@nestjs/common';
+import {
+  ConflictException,
+  Inject,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
 import { Prisma, User } from '@prisma/client';
 import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
 import { PrismaService } from 'nestjs-prisma';
@@ -20,7 +25,21 @@ export class UserService {
   }
 
   async createOne(userCreateArgs: Prisma.UserCreateArgs) {
-    return await this.prisma.user.create(userCreateArgs);
+    try {
+      return await this.prisma.user.create(userCreateArgs);
+    } catch (error) {
+      if (
+        error instanceof Prisma.PrismaClientKnownRequestError &&
+        error.code === 'P2002' &&
+        prismaErrorTargets(error).some((target) => target.includes('userid'))
+      ) {
+        throw new ConflictException({
+          code: 'USER_ALREADY_EXISTS',
+          message: '该人员已存在，无需重复添加',
+        });
+      }
+      throw error;
+    }
   }
 
   async createMany(data: Prisma.UserCreateManyArgs['data']) {
@@ -69,6 +88,94 @@ export class UserService {
     return { count: 1 };
   }
 
+  async deletePerson(id: number) {
+    const person = await this.prisma.user.findUnique({
+      where: { id },
+      select: {
+        userid: true,
+        roles: true,
+        groupMemberships: {
+          select: { group: { select: { code: true, name: true } } },
+        },
+      },
+    });
+    if (!person) throw new NotFoundException('人员不存在');
+
+    const [workflows, activeApprovalCount] = await Promise.all([
+      this.prisma.workflow.findMany({
+        select: {
+          id: true,
+          name: true,
+          dsl: true,
+          versions: { select: { dsl: true } },
+        },
+      }),
+      this.prisma.approvalCandidate.count({
+        where: {
+          principalType: 'USER',
+          principalRef: person.userid,
+          invalidatedAt: null,
+          request: { status: { in: ['PENDING', 'BLOCKED'] } },
+        },
+      }),
+    ]);
+    const roles = assignedRoles(person.roles);
+    const referencedWorkflows = workflows
+      .filter(
+        (workflow) =>
+          workflowDslReferencesUser(workflow.dsl, person.userid) ||
+          workflow.versions.some((version) =>
+            workflowDslReferencesUser(version.dsl, person.userid),
+          ),
+      )
+      .map((workflow) => ({ id: String(workflow.id), name: workflow.name }));
+    const groups = person.groupMemberships.map(({ group }) => group);
+    const reasons = [
+      ...(roles.length ? [`已授予角色：${roles.join('、')}`] : []),
+      ...(groups.length
+        ? [`已加入人员组：${groups.map((group) => group.name).join('、')}`]
+        : []),
+      ...(referencedWorkflows.length
+        ? [
+            `被 Workflow 引用：${referencedWorkflows
+              .map((workflow) => workflow.name)
+              .join('、')}`,
+          ]
+        : []),
+      ...(activeApprovalCount
+        ? [`仍有 ${activeApprovalCount} 个待处理审批`]
+        : []),
+    ];
+
+    if (reasons.length) {
+      throw new ConflictException({
+        code: 'PERSON_IN_USE',
+        message: `无法删除该人员：${reasons.join('；')}`,
+        reasons,
+        roles,
+        groups,
+        workflows: referencedWorkflows,
+        activeApprovalCount,
+      });
+    }
+
+    try {
+      await this.prisma.user.delete({ where: { id } });
+      return { count: 1 };
+    } catch (error) {
+      if (
+        error instanceof Prisma.PrismaClientKnownRequestError &&
+        error.code === 'P2003'
+      ) {
+        throw new ConflictException({
+          code: 'PERSON_IN_USE',
+          message: '该人员刚被其他数据引用，请刷新后重试',
+        });
+      }
+      throw error;
+    }
+  }
+
   async count(userCountArgs?: Prisma.UserCountArgs) {
     return await this.prisma.user.count(userCountArgs);
   }
@@ -102,3 +209,44 @@ export class UserService {
     return key.substring(0, 8) + '****';
   }
 }
+
+function prismaErrorTargets(
+  error: Prisma.PrismaClientKnownRequestError,
+): string[] {
+  const target = error.meta?.target;
+  if (Array.isArray(target)) return target.map(String);
+  return target == null ? [] : [String(target)];
+}
+
+function assignedRoles(value: string): string[] {
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed)
+      ? parsed.map(String).filter((role) => role.trim())
+      : value.trim()
+      ? [value]
+      : [];
+  } catch {
+    return value.trim() ? [value] : [];
+  }
+}
+
+function workflowDslReferencesUser(
+  value: Prisma.JsonValue | null,
+  userid: string,
+): boolean {
+  if (Array.isArray(value))
+    return value.some((item) => workflowDslReferencesUser(item, userid));
+  if (!value || typeof value !== 'object') return false;
+
+  const record = value as Record<string, Prisma.JsonValue>;
+  const refs = Array.isArray(record.refs) ? record.refs.map(String) : [];
+  if (
+    refs.includes(userid) &&
+    (record.source === 'STATIC' || record.provider === 'USER')
+  )
+    return true;
+  return Object.values(record).some((item) =>
+    workflowDslReferencesUser(item, userid),
+  );
+}

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

@@ -2,6 +2,7 @@ import { ACGuard } from '@gadmin2n/nest-common';
 import {
   Body,
   Controller,
+  Delete,
   Get,
   Param,
   Patch,
@@ -19,6 +20,7 @@ import {
 } from '../subjectProvider/actor-context.util';
 import {
   CreateUserGroupDto,
+  DeleteUserGroupDto,
   ReplaceUserGroupMembersDto,
   SetUserGroupActiveDto,
   UpdateUserGroupDto,
@@ -35,7 +37,7 @@ export class UserGroupController {
   @Get()
   @UseRoles({ resource: 'userGroup:read', action: 'read', possession: 'any' })
   search(@Query() query: UserGroupSearchDto) {
-    return this.service.search(query.q ?? '');
+    return this.service.search(query.q ?? '', query.includeInactive ?? false);
   }
 
   @Get(':code/preview')
@@ -116,4 +118,14 @@ export class UserGroupController {
       actorContextFromRequest(request),
     );
   }
+
+  @Delete(':code')
+  @UseRoles({
+    resource: 'userGroup:create',
+    action: 'delete',
+    possession: 'any',
+  })
+  remove(@Param('code') code: string, @Query() query: DeleteUserGroupDto) {
+    return this.service.deleteGroup(code, query.expectedRevision);
+  }
 }

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/userGroup/user-group.dto.ts

@@ -1,4 +1,4 @@
-import { Type } from 'class-transformer';
+import { Transform, Type } from 'class-transformer';
 import {
   ArrayUnique,
   IsArray,
@@ -84,8 +84,20 @@ export class SetUserGroupActiveDto {
   isActive!: boolean;
 }
 
+export class DeleteUserGroupDto {
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  expectedRevision!: number;
+}
+
 export class UserGroupSearchDto {
   @IsOptional()
   @IsString()
   q?: string;
+
+  @IsOptional()
+  @Transform(({ value }) => value === true || value === 'true')
+  @IsBoolean()
+  includeInactive?: boolean;
 }

package/dist/lib/application/files/gadmin2-game-angle-demo/server/src/modules/userGroup/user-group.errors.ts

@@ -4,6 +4,7 @@ export type UserGroupErrorCode =
   | 'USER_GROUP_CYCLE'
   | 'USER_GROUP_DEPTH_EXCEEDED'
   | 'USER_GROUP_MEMBER_INVALID'
+  | 'USER_GROUP_IN_USE'
   | 'USER_GROUP_REVISION_CONFLICT'
   | 'USER_GROUP_NOT_FOUND';
 

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

@@ -1,3 +1,4 @@
+import { Prisma } from '@prisma/client';
 import { UserGroupService } from './user-group.service';
 
 const group = {
@@ -20,6 +21,7 @@ function createHarness() {
       findMany: jest.fn(),
       create: jest.fn(),
       updateMany: jest.fn().mockResolvedValue({ count: 1 }),
+      delete: jest.fn().mockResolvedValue(group),
     },
     user: { findMany: jest.fn() },
     userGroupUser: {
@@ -32,6 +34,8 @@ function createHarness() {
       deleteMany: jest.fn().mockResolvedValue({ count: 0 }),
       createMany: jest.fn().mockResolvedValue({ count: 1 }),
     },
+    workflow: { findMany: jest.fn().mockResolvedValue([]) },
+    approvalRequestSubject: { count: jest.fn().mockResolvedValue(0) },
   };
   const prisma = {
     ...tx,
@@ -44,6 +48,19 @@ function createHarness() {
 }
 
 describe('UserGroupService', () => {
+  it('can include inactive groups for the management page', async () => {
+    const { service, tx } = createHarness();
+    tx.userGroup.findMany.mockResolvedValue([]);
+
+    await service.search('finance', true);
+
+    expect(tx.userGroup.findMany).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.not.objectContaining({ isActive: true }),
+      }),
+    );
+  });
+
   it('returns direct users and child groups for editing', async () => {
     const { service, tx } = createHarness();
     tx.userGroup.findUnique
@@ -148,6 +165,31 @@ describe('UserGroupService', () => {
     });
   });
 
+  it('only accepts active non-API users as direct members', async () => {
+    const { service, tx } = createHarness();
+    tx.user.findMany.mockResolvedValue([{ userid: 'alice' }]);
+    tx.userGroup.findMany.mockResolvedValueOnce([]).mockResolvedValueOnce([]);
+
+    await service.replaceMembers(
+      'finance',
+      {
+        expectedRevision: 4,
+        userIds: ['alice'],
+        childGroupCodes: [],
+      },
+      actor,
+    );
+
+    expect(tx.user.findMany).toHaveBeenCalledWith({
+      where: {
+        userid: { in: ['alice'] },
+        isActive: true,
+        isApiKey: false,
+      },
+      select: { userid: true },
+    });
+  });
+
   it('returns 409 when expectedRevision is stale', async () => {
     const { service } = createHarness();
     await expect(
@@ -158,4 +200,87 @@ describe('UserGroupService', () => {
       ),
     ).rejects.toMatchObject({ status: 409 });
   });
+
+  it('deletes an unreferenced group and its owned memberships', async () => {
+    const { service, tx } = createHarness();
+    tx.userGroupChild.findMany.mockResolvedValue([]);
+
+    await expect(service.deleteGroup('finance', 4)).resolves.toEqual({
+      count: 1,
+    });
+    expect(tx.userGroupUser.deleteMany).toHaveBeenCalledWith({
+      where: { groupId: group.id },
+    });
+    expect(tx.userGroupChild.deleteMany).toHaveBeenCalledWith({
+      where: { parentGroupId: group.id },
+    });
+    expect(tx.userGroup.delete).toHaveBeenCalledWith({
+      where: { id: group.id },
+    });
+  });
+
+  it('rejects deleting a group referenced by another group', async () => {
+    const { service, tx } = createHarness();
+    tx.userGroupChild.findMany.mockResolvedValue([
+      { parentGroup: { code: 'all-finance', name: 'All Finance' } },
+    ]);
+
+    await expect(service.deleteGroup('finance', 4)).rejects.toMatchObject({
+      status: 409,
+      response: {
+        code: 'USER_GROUP_IN_USE',
+        message: expect.stringContaining('All Finance'),
+      },
+    });
+    expect(tx.userGroup.delete).not.toHaveBeenCalled();
+  });
+
+  it('rejects deleting a group referenced by a Workflow', async () => {
+    const { service, tx } = createHarness();
+    tx.userGroupChild.findMany.mockResolvedValue([]);
+    tx.workflow.findMany.mockResolvedValue([
+      {
+        id: BigInt(9),
+        name: 'Finance Approval',
+        dsl: {
+          nodes: [
+            {
+              config: {
+                subjects: [{ provider: 'USER_GROUP', refs: ['finance'] }],
+              },
+            },
+          ],
+        },
+        versions: [],
+      },
+    ]);
+
+    await expect(service.deleteGroup('finance', 4)).rejects.toMatchObject({
+      status: 409,
+      response: {
+        code: 'USER_GROUP_IN_USE',
+        message: expect.stringContaining('Finance Approval'),
+      },
+    });
+    expect(tx.userGroup.delete).not.toHaveBeenCalled();
+  });
+
+  it('returns 409 when a concurrent reference makes the database reject deletion', async () => {
+    const { service, tx } = createHarness();
+    tx.userGroupChild.findMany.mockResolvedValue([]);
+    tx.userGroup.delete.mockRejectedValue(
+      new Prisma.PrismaClientKnownRequestError('foreign key conflict', {
+        code: 'P2003',
+        clientVersion: '6.19.3',
+      }),
+    );
+
+    await expect(service.deleteGroup('finance', 4)).rejects.toMatchObject({
+      status: 409,
+      response: {
+        code: 'USER_GROUP_IN_USE',
+        message: expect.stringContaining('刷新后重试'),
+      },
+    });
+  });
 });