@gadmin2n/schematics 0.0.147 → 0.0.149

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('刷新后重试'),
+      },
+    });
+  });
 });

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

@@ -138,11 +138,102 @@ export class UserGroupService {
     });
   }
 
-  search(query: string) {
+  async deleteGroup(code: string, expectedRevision: number) {
+    try {
+      return await this.prisma.$transaction(async (tx) => {
+        const group = await this.findGroup(tx, code);
+        this.assertRevision(group.revision, expectedRevision);
+
+        const [parents, workflows, activeApprovalCount] = await Promise.all([
+          tx.userGroupChild.findMany({
+            where: { childGroupId: group.id },
+            select: {
+              parentGroup: { select: { code: true, name: true } },
+            },
+          }),
+          tx.workflow.findMany({
+            select: {
+              id: true,
+              name: true,
+              dsl: true,
+              versions: { select: { dsl: true } },
+            },
+          }),
+          tx.approvalRequestSubject.count({
+            where: {
+              provider: 'USER_GROUP',
+              ref: group.code,
+              request: { status: { in: ['PENDING', 'BLOCKED'] } },
+            },
+          }),
+        ]);
+        const parentGroups = parents.map(({ parentGroup }) => parentGroup);
+        const referencedWorkflows = workflows
+          .filter(
+            (workflow) =>
+              workflowDslReferencesGroup(workflow.dsl, group.code) ||
+              workflow.versions.some((version) =>
+                workflowDslReferencesGroup(version.dsl, group.code),
+              ),
+          )
+          .map((workflow) => ({
+            id: String(workflow.id),
+            name: workflow.name,
+          }));
+        const reasons = [
+          ...(parentGroups.length
+            ? [
+                `被人员组引用：${parentGroups
+                  .map((parent) => parent.name)
+                  .join('、')}`,
+              ]
+            : []),
+          ...(referencedWorkflows.length
+            ? [
+                `被 Workflow 引用：${referencedWorkflows
+                  .map((workflow) => workflow.name)
+                  .join('、')}`,
+              ]
+            : []),
+          ...(activeApprovalCount
+            ? [`仍有 ${activeApprovalCount} 个进行中的审批引用`]
+            : []),
+        ];
+        if (reasons.length) {
+          throw new UserGroupDomainError(
+            'USER_GROUP_IN_USE',
+            `无法删除该人员组：${reasons.join('；')}`,
+            409,
+          );
+        }
+
+        await Promise.all([
+          tx.userGroupUser.deleteMany({ where: { groupId: group.id } }),
+          tx.userGroupChild.deleteMany({ where: { parentGroupId: group.id } }),
+        ]);
+        await tx.userGroup.delete({ where: { id: group.id } });
+        return { count: 1 };
+      });
+    } catch (error) {
+      if (
+        error instanceof Prisma.PrismaClientKnownRequestError &&
+        error.code === 'P2003'
+      ) {
+        throw new UserGroupDomainError(
+          'USER_GROUP_IN_USE',
+          '该人员组刚被其他数据引用，请刷新后重试',
+          409,
+        );
+      }
+      throw error;
+    }
+  }
+
+  search(query: string, includeInactive = false) {
     const q = query.trim();
     return this.prisma.userGroup.findMany({
       where: {
-        isActive: true,
+        ...(!includeInactive && { isActive: true }),
         ...(q && {
           OR: [
             { code: { contains: q, mode: 'insensitive' } },
@@ -156,6 +247,8 @@ export class UserGroupService {
         name: true,
         description: true,
         revision: true,
+        isActive: true,
+        updatedAt: true,
       },
       take: 50,
     });
@@ -220,7 +313,7 @@ export class UserGroupService {
         where: { id: { in: ids }, isActive: true },
         select: {
           users: {
-            where: { user: { isActive: true } },
+            where: { user: { isActive: true, isApiKey: false } },
             select: {
               user: { select: { userid: true, username: true } },
             },
@@ -267,13 +360,13 @@ export class UserGroupService {
   private async requireActiveUsers(tx: Transaction, userIds: string[]) {
     if (userIds.length === 0) return [];
     const users = await tx.user.findMany({
-      where: { userid: { in: userIds }, isActive: true },
+      where: { userid: { in: userIds }, isActive: true, isApiKey: false },
       select: { userid: true },
     });
     if (users.length !== userIds.length) {
       throw new UserGroupDomainError(
         'USER_GROUP_MEMBER_INVALID',
-        'Every direct user must exist and be active',
+        'Every direct user must exist, be active, and not be an API key user',
       );
     }
     return users;
@@ -388,3 +481,23 @@ export class UserGroupService {
     );
   }
 }
+
+function workflowDslReferencesGroup(
+  value: Prisma.JsonValue | null,
+  groupCode: string,
+): boolean {
+  if (Array.isArray(value))
+    return value.some((item) => workflowDslReferencesGroup(item, groupCode));
+  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(`group:${groupCode}`) ||
+    (record.provider === 'USER_GROUP' && refs.includes(groupCode))
+  )
+    return true;
+  return Object.values(record).some((item) =>
+    workflowDslReferencesGroup(item, groupCode),
+  );
+}

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

@@ -69,6 +69,7 @@ describe('Workflow cancellation', () => {
       runtime.cancelExecution({
         tx: tx as any,
         instanceId: BigInt(11),
+        requestedBy: 'business-user',
         reason: 'business cancellation',
       }),
     ).resolves.toEqual({ instanceId: '11', status: 'CANCELLED' });
@@ -79,6 +80,8 @@ describe('Workflow cancellation', () => {
       data: expect.objectContaining({
         status: 'CANCELLED',
         cancellationStatus: 'PENDING',
+        cancellationRequestedAt: expect.any(Date),
+        cancellationRequestedBy: 'business-user',
         cancellationReason: 'business cancellation',
       }),
     });
@@ -112,6 +115,7 @@ describe('Workflow cancellation', () => {
     await runtime.cancelExecution({
       tx: tx as any,
       instanceId: execution!.instanceId,
+      requestedBy: 'applicant-user',
       reason: 'applicant cancellation',
     });
 
@@ -150,7 +154,11 @@ describe('Workflow cancellation', () => {
     const { runtime, temporal, tx } = setup({ status: 'COMPLETED' });
 
     await expect(
-      runtime.cancelExecution({ tx: tx as any, instanceId: BigInt(11) }),
+      runtime.cancelExecution({
+        tx: tx as any,
+        instanceId: BigInt(11),
+        requestedBy: 'admin-user',
+      }),
     ).rejects.toBeInstanceOf(ConflictException);
     expect(tx.workflowInstance.update).not.toHaveBeenCalled();
     expect(tx.approvalRequest.updateMany).not.toHaveBeenCalled();
@@ -164,7 +172,11 @@ describe('Workflow cancellation', () => {
     });
 
     await expect(
-      runtime.cancelExecution({ tx: tx as any, instanceId: BigInt(11) }),
+      runtime.cancelExecution({
+        tx: tx as any,
+        instanceId: BigInt(11),
+        requestedBy: 'admin-user',
+      }),
     ).rejects.toMatchObject({
       response: {
         code: 'WORKFLOW_CANCELLATION_BLOCKED',
@@ -180,7 +192,11 @@ describe('Workflow cancellation', () => {
     });
 
     await expect(
-      runtime.cancelExecution({ tx: tx as any, instanceId: BigInt(11) }),
+      runtime.cancelExecution({
+        tx: tx as any,
+        instanceId: BigInt(11),
+        requestedBy: 'second-user',
+      }),
     ).resolves.toEqual({ instanceId: '11', status: 'CANCELLED' });
     expect(tx.workflowInstance.update).not.toHaveBeenCalled();
     expect(temporal.cancelWorkflow).not.toHaveBeenCalled();
@@ -193,6 +209,7 @@ describe('Workflow cancellation', () => {
         runtime.cancelExecution({
           tx: transactionClient,
           instanceId: BigInt(11),
+          requestedBy: `${reason} user`,
           reason,
         }),
       );

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

@@ -279,7 +279,7 @@ describe('WorkflowCompilerService', () => {
               type: 'approval',
               label: '部门负责人审批',
               config: {
-                subjects: [{ source: 'STATIC', provider: 'USER', refs: [' '] }],
+                subjects: [{ source: 'STATIC', refs: [' '] }],
               },
             },
           ],
@@ -426,7 +426,7 @@ describe('WorkflowCompilerService', () => {
       code: 'FINANCE_APPROVAL',
       nodeTypeId: BigInt(7),
       isEnabled: true,
-      config: { subjects: [{ provider: 'USER', refs: ['alice'] }] },
+      config: { subjects: [{ source: 'STATIC', refs: ['alice'] }] },
     };
     const prisma = {
       workflowNodeType: {
@@ -483,7 +483,7 @@ describe('WorkflowCompilerService', () => {
     });
     instance.config.subjects[0].refs[0] = 'bob';
     expect(compiled.nodes[0].config).toEqual({
-      subjects: [{ provider: 'USER', refs: ['alice'] }],
+      subjects: [{ source: 'STATIC', refs: ['alice'] }],
     });
   });
 
@@ -529,9 +529,7 @@ describe('WorkflowCompilerService', () => {
             config: instance.config,
             configOverride: {
               timeoutSeconds: 3600,
-              subjects: [
-                { source: 'STATIC', provider: 'USER', refs: ['alice'] },
-              ],
+              subjects: [{ source: 'STATIC', refs: ['alice'] }],
             },
             instanceRef: {
               instanceId: '12',
@@ -546,7 +544,7 @@ describe('WorkflowCompilerService', () => {
 
     const expectedOverride = {
       timeoutSeconds: 3600,
-      subjects: [{ source: 'STATIC', provider: 'USER', refs: ['alice'] }],
+      subjects: [{ source: 'STATIC', refs: ['alice'] }],
     };
     expect(compiled.nodes[0].config).toEqual(expectedOverride);
     expect(compiled.nodes[0].source?.configHash).toBe(
@@ -571,7 +569,7 @@ describe('WorkflowCompilerService', () => {
         },
         details: [],
       },
-      subjects: [{ source: 'STATIC', provider: 'USER', refs: ['alice'] }],
+      subjects: [{ source: 'STATIC', refs: ['alice'] }],
       approvalRule: { mode: 'ANY' },
       rejectionRule: { mode: 'ANY' },
       timeout: { durationSeconds: 0, action: 'REJECTED' },
@@ -655,7 +653,6 @@ describe('WorkflowCompilerService', () => {
               subjects: [
                 {
                   source: 'DYNAMIC',
-                  provider: 'USER',
                   inputKey: 'direct_manager',
                   label: '查询直属领导',
                   lookup: { request: { connectionRef: 'erp' } },