@allbluecn/web-app 0.5.0 → 0.6.0

package/src/server/serverFns/story/story-assoc.ts

@@ -20,6 +20,70 @@ import { getRequest } from "@tanstack/react-start/server";
 import { z } from "zod";
 import { prisma } from "@allbluecn/database";
 import { requireAuth } from "@/server/auth-helpers";
+import { ACTIVITY_SELECT, toActivityItem } from "./types";
+import { buildKbScopeWhere } from "./kb-scope";
+import {
+  GENERAL_GROUPS,
+  EXTERNAL_ID_PREFIX,
+  parseExternalDocId,
+  externalDocId,
+  type GeneralGroup,
+} from "./kb-general";
+
+// ---------- 通用知识库（法律法规/行业合规/词典词条/网站收藏/周报月报） ----------
+
+const GENERAL_GROUP_TABLES = {
+  legal: "legalRegulation",
+  compliance: "industryCompliance",
+  dictionary: "dictionaryTerm",
+  bookmark: "websiteBookmark",
+} as const satisfies Record<Exclude<GeneralGroup, "summary">, string>;
+
+const GENERAL_ROW_SELECT = { id: true, title: true } as const;
+
+async function searchGeneralGroupDocs(
+  group: GeneralGroup,
+  userId: string,
+  query: string,
+): Promise<SearchDocRow[]> {
+  const table = GENERAL_GROUP_TABLES[group as Exclude<GeneralGroup, "summary">];
+  if (!table) return []; // summary（周报月报）暂无实体表，无可关联内容
+
+  const favoriteIds = await prisma.articleFavorite
+    .findMany({
+      where: { entityType: group, userId },
+      select: { entityId: true },
+    })
+    .then((r) => r.map((f) => f.entityId));
+
+  const rows = await (
+    prisma[table] as unknown as {
+      findMany: (args: Record<string, unknown>) => Promise<Array<{ id: string; title: string }>>;
+    }
+  ).findMany({
+    where: {
+      isDeleted: false,
+      ...(query ? { title: { contains: query, mode: "insensitive" as const } } : {}),
+      OR: [
+        { userId },
+        ...(favoriteIds.length > 0 ? [{ id: { in: favoriteIds } }] : []),
+      ],
+    },
+    select: GENERAL_ROW_SELECT,
+    orderBy: { updatedAt: "desc" as const },
+    take: 100,
+  });
+
+  return rows.map((row) => ({
+    id: externalDocId(group, row.id),
+    title: row.title,
+    kbId: `${EXTERNAL_ID_PREFIX}${group}`,
+    kbName: group,
+    kbIcon: "book",
+    docIcon: null,
+    parentId: null,
+  }));
+}
 
 export const linkPrdFn = createServerFn({ method: "POST" })
   .validator(z.object({ storyId: z.string(), prdId: z.string() }))
@@ -49,12 +113,29 @@ export const unlinkPrdFn = createServerFn({ method: "POST" })
   .handler(async ({ data }) => {
     const request = getRequest();
     const session = await requireAuth(request);
+    const userId = session.user!.id!;
 
-    const link = await prisma.storyPrdLink.delete({
+    const prd = await prisma.pRD.findUnique({ where: { id: data.prdId }, select: { name: true } });
+
+    await prisma.storyPrdLink.delete({
       where: { storyId_prdId: { storyId: data.storyId, prdId: data.prdId } },
     });
 
-    return link;
+    let activity = null;
+    if (prd) {
+      const created = await prisma.storyActivity.create({
+        data: {
+          storyId: data.storyId,
+          userId,
+          action: "prd_unlinked",
+          newValue: prd.name,
+        },
+        select: ACTIVITY_SELECT,
+      });
+      activity = toActivityItem(created);
+    }
+
+    return { storyId: data.storyId, prdId: data.prdId, activity };
   });
 
 export const getLinkedPrdsFn = createServerFn({ method: "GET" })
@@ -103,27 +184,247 @@ export const searchPrdsFn = createServerFn({ method: "GET" })
     }));
   });
 
-export const linkDocFn = createServerFn({ method: "POST" })
-  .validator(z.object({ storyId: z.string(), docId: z.string() }))
+const DOC_SELECT = {
+  id: true,
+  title: true,
+  parentId: true,
+  icon: true,
+  type: true,
+  kb: { select: { id: true, name: true, icon: true } },
+} as const;
+
+/** 搜索/列表行 = DocBrief + 树形父引用（KnowledgeSelectDialog 树形渲染用） */
+export type SearchDocRow = {
+  id: string;
+  title: string;
+  kbId: string;
+  kbName: string;
+  kbIcon: string;
+  docIcon: string | null;
+  parentId: string | null;
+};
+
+function toDocBrief(doc: {
+  id: string;
+  title: string;
+  parentId: string | null;
+  icon: string | null;
+  kb: { id: string; name: string; icon: string };
+}): SearchDocRow {
+  return {
+    id: doc.id,
+    title: doc.title,
+    kbId: doc.kb.id,
+    kbName: doc.kb.name,
+    kbIcon: doc.kb.icon,
+    docIcon: doc.icon,
+    parentId: doc.parentId,
+  };
+}
+
+/** 查需求 → 组装 scope 输入（内部复用） */
+async function resolveStoryScope(storyId: string, userId: string) {
+  const story = await prisma.story.findUnique({
+    where: { id: storyId },
+    select: { project: { select: { id: true, displayId: true } } },
+  });
+  if (!story) throw new Error("需求不存在");
+  return buildKbScopeWhere({
+    projectId: story.project.id,
+    projectDisplayId: story.project.displayId,
+    userId,
+  });
+}
+
+export const listStoryAvailableKbsFn = createServerFn({ method: "GET" })
+  .validator(z.object({ storyId: z.string() }))
   .handler(async ({ data }) => {
     const request = getRequest();
     const session = await requireAuth(request);
-
-    const existing = await prisma.storyDocLink.findUnique({
-      where: { storyId_docId: { storyId: data.storyId, docId: data.docId } },
+    const scope = await resolveStoryScope(data.storyId, session.user!.id!);
+    const kbs = await prisma.knowledgeBase.findMany({
+      where: { AND: [scope, { isDeleted: false }] },
+      select: { id: true, name: true, icon: true, visibility: true },
+      orderBy: { name: "asc" },
     });
-    if (existing) {
-      throw new Error("已关联此文档");
+    return kbs;
+  });
+
+export const searchKbDocsFn = createServerFn({ method: "GET" })
+  .validator(
+    z.object({
+      storyId: z.string(),
+      kbId: z.string().optional(),
+      generalGroup: z.enum(GENERAL_GROUPS).optional(),
+      query: z.string().default(""),
+      cursor: z.string().optional(),
+    }),
+  )
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    const session = await requireAuth(request);
+    const scope = await resolveStoryScope(data.storyId, session.user!.id!);
+
+    if (data.generalGroup) {
+      // 态③：通用知识库分组 → 平铺列表（周报月报暂无实体内容）
+      const items = await searchGeneralGroupDocs(data.generalGroup, session.user!.id!, data.query);
+      return { items, nextCursor: null };
     }
 
-    const link = await prisma.storyDocLink.create({
-      data: {
-        storyId: data.storyId,
-        docId: data.docId,
+    if (data.kbId) {
+      // 态①：指定 KB（须在可用范围内）→ 全量树
+      const kb = await prisma.knowledgeBase.findFirst({
+        where: { AND: [scope, { id: data.kbId, isDeleted: false }] },
+        select: { id: true },
+      });
+      if (!kb) throw new Error("知识库不在可用范围内");
+      const docs = await prisma.knowledgeDocument.findMany({
+        where: {
+          kbId: data.kbId,
+          isDeleted: false,
+          ...(data.query ? { title: { contains: data.query, mode: "insensitive" as const } } : {}),
+        },
+        select: DOC_SELECT,
+        orderBy: [{ sortOrder: "asc" }, { createdAt: "asc" }],
+        take: 500,
+      });
+      return { items: docs.map(toDocBrief), nextCursor: null };
+    }
+
+    // 态②：全部可用 KB → 平铺分页
+    const rows = await prisma.knowledgeDocument.findMany({
+      where: {
+        isDeleted: false,
+        kb: { isDeleted: false, AND: [scope] },
+        ...(data.query ? { title: { contains: data.query, mode: "insensitive" as const } } : {}),
       },
+      select: { ...DOC_SELECT, createdAt: true },
+      orderBy: { createdAt: "desc" },
+      take: 21,
+      ...(data.cursor ? { cursor: { id: data.cursor }, skip: 1 } : {}),
     });
+    const hasMore = rows.length > 20;
+    const items = (hasMore ? rows.slice(0, 20) : rows).map(toDocBrief);
+    return {
+      items,
+      nextCursor: hasMore ? rows[rows.length - 1].id : null,
+    };
+  });
 
-    return link;
+export const linkDocsFn = createServerFn({ method: "POST" })
+  .validator(z.object({ storyId: z.string(), docIds: z.array(z.string()).min(1) }))
+  .handler(async ({ data }) => {
+    const request = getRequest();
+    const session = await requireAuth(request);
+    const userId = session.user!.id!;
+    const scope = await resolveStoryScope(data.storyId, userId);
+
+    const failed: Array<{ docId: string; reason: "outOfScope" }> = [];
+
+    // 通用知识库条目（ext:<group>:<externalId>）
+    const extIds = data.docIds.filter((id) => id.startsWith(EXTERNAL_ID_PREFIX));
+    const realIds = data.docIds.filter((id) => !id.startsWith(EXTERNAL_ID_PREFIX));
+
+    const extParsed = extIds
+      .map((id) => ({ id, parsed: parseExternalDocId(id) }))
+      .filter((x): x is { id: string; parsed: { group: GeneralGroup; externalId: string } } => x.parsed !== null);
+    for (const x of extIds) {
+      if (!extParsed.some((p) => p.id === x)) failed.push({ docId: x, reason: "outOfScope" });
+    }
+
+    // 校验外部条目真实存在（按分组表批量查询）
+    const existingExt = new Set(
+      await prisma.storyExternalLink
+        .findMany({ where: { storyId: data.storyId }, select: { group: true, externalId: true } })
+        .then((rows) => rows.map((r) => externalDocId(r.group as GeneralGroup, r.externalId))),
+    );
+    const extToLink: Array<{ group: GeneralGroup; externalId: string }> = [];
+    for (const { id, parsed } of extParsed) {
+      if (existingExt.has(id)) continue; // skipped
+      const table = GENERAL_GROUP_TABLES[parsed.group as Exclude<GeneralGroup, "summary">];
+      if (!table) {
+        failed.push({ docId: id, reason: "outOfScope" });
+        continue;
+      }
+      const found = await (
+        prisma[table] as unknown as {
+          findFirst: (args: Record<string, unknown>) => Promise<{ id: string } | null>;
+        }
+      ).findFirst({ where: { id: parsed.externalId, isDeleted: false }, select: { id: true } });
+      if (found) extToLink.push(parsed);
+      else failed.push({ docId: id, reason: "outOfScope" });
+    }
+    if (extToLink.length > 0) {
+      await prisma.storyExternalLink.createMany({
+        data: extToLink.map(({ group, externalId }) => ({ storyId: data.storyId, group, externalId })),
+        skipDuplicates: true,
+      });
+    }
+    const extSkipped = extParsed
+      .map((p) => p.id)
+      .filter((id) => !extToLink.some((x) => externalDocId(x.group, x.externalId) === id));
+
+    // 知识库文档（原有逻辑）
+    const docs = await prisma.knowledgeDocument.findMany({
+      where: { id: { in: realIds }, isDeleted: false },
+      select: { id: true, kbId: true },
+    });
+    const validKbs = await prisma.knowledgeBase.findMany({
+      where: { AND: [scope, { isDeleted: false }] },
+      select: { id: true },
+    });
+    const validKbIds = new Set(validKbs.map((k) => k.id));
+
+    for (const d of docs) {
+      if (!validKbIds.has(d.kbId)) failed.push({ docId: d.id, reason: "outOfScope" });
+    }
+    // 请求中不存在的真实文档 id 视为越界
+    const foundIds = new Set(docs.map((d) => d.id));
+    for (const id of realIds) {
+      if (!foundIds.has(id)) failed.push({ docId: id, reason: "outOfScope" });
+    }
+    const candidateIds = docs.filter((d) => validKbIds.has(d.kbId)).map((d) => d.id);
+
+    const existing = await prisma.storyDocLink.findMany({
+      where: { storyId: data.storyId, docId: { in: candidateIds } },
+      select: { docId: true },
+    });
+    const existingIds = new Set(existing.map((l) => l.docId));
+    const toLink = candidateIds.filter((id) => !existingIds.has(id));
+    const skipped = [
+      ...candidateIds.filter((id) => existingIds.has(id)),
+      ...extSkipped,
+    ];
+
+    if (toLink.length > 0) {
+      await prisma.storyDocLink.createMany({
+        data: toLink.map((docId) => ({ storyId: data.storyId, docId })),
+        skipDuplicates: true,
+      });
+    }
+
+    // 活动记录：成功关联知识库文档时记一条（newValue 为文档数量）
+    const linkedCount = toLink.length + extToLink.length;
+    let activity: ReturnType<typeof toActivityItem> | null = null;
+    if (linkedCount > 0) {
+      const created = await prisma.storyActivity.create({
+        data: {
+          storyId: data.storyId,
+          userId,
+          action: "kb_linked",
+          newValue: String(linkedCount),
+        },
+        select: ACTIVITY_SELECT,
+      });
+      activity = toActivityItem(created);
+    }
+
+    return {
+      linked: [...toLink, ...extToLink.map(({ group, externalId }) => externalDocId(group, externalId))],
+      skipped,
+      failed,
+      activity,
+    };
   });
 
 export const unlinkDocFn = createServerFn({ method: "POST" })
@@ -131,12 +432,32 @@ export const unlinkDocFn = createServerFn({ method: "POST" })
   .handler(async ({ data }) => {
     const request = getRequest();
     const session = await requireAuth(request);
+    const userId = session.user!.id!;
 
-    const link = await prisma.storyDocLink.delete({
+    const parsed = parseExternalDocId(data.docId);
+    if (parsed) {
+      await prisma.storyExternalLink.deleteMany({
+        where: { storyId: data.storyId, group: parsed.group, externalId: parsed.externalId },
+      });
+      const created = await prisma.storyActivity.create({
+        data: { storyId: data.storyId, userId, action: "kb_unlinked", newValue: `${parsed.group}:${parsed.externalId}` },
+        select: ACTIVITY_SELECT,
+      });
+      return { ok: true, activity: toActivityItem(created) };
+    }
+    const doc = await prisma.knowledgeDocument.findUnique({ where: { id: data.docId }, select: { title: true } });
+    await prisma.storyDocLink.delete({
       where: { storyId_docId: { storyId: data.storyId, docId: data.docId } },
     });
-
-    return link;
+    let activity: ReturnType<typeof toActivityItem> | null = null;
+    if (doc) {
+      const created = await prisma.storyActivity.create({
+        data: { storyId: data.storyId, userId, action: "kb_unlinked", newValue: doc.title },
+        select: ACTIVITY_SELECT,
+      });
+      activity = toActivityItem(created);
+    }
+    return { ok: true, activity };
   });
 
 export const getLinkedDocsFn = createServerFn({ method: "GET" })
@@ -144,43 +465,43 @@ export const getLinkedDocsFn = createServerFn({ method: "GET" })
   .handler(async ({ data }) => {
     const request = getRequest();
     const session = await requireAuth(request);
-
     const links = await prisma.storyDocLink.findMany({
       where: { storyId: data.storyId },
-      include: {
-        doc: {
-          select: {
-            id: true,
-            title: true,
-          },
-        },
-      },
+      include: { doc: { select: DOC_SELECT } },
     });
+    const docRows = links.map((link) => toDocBrief(link.doc));
 
-    return links.map((link) => ({
-      id: link.doc.id,
-      title: link.doc.title,
-    }));
-  });
-
-export const searchDocsFn = createServerFn({ method: "GET" })
-  .validator(z.object({ query: z.string() }))
-  .handler(async ({ data }) => {
-    const request = getRequest();
-    const session = await requireAuth(request);
-
-    const docs = await prisma.knowledgeDocument.findMany({
-      where: {
-        title: {
-          contains: data.query,
-          mode: "insensitive",
-        },
-      },
-      take: 10,
+    const extLinks = await prisma.storyExternalLink.findMany({
+      where: { storyId: data.storyId },
+      select: { group: true, externalId: true },
     });
-
-    return docs.map((doc) => ({
-      id: doc.id,
-      title: doc.title,
-    }));
+    const byGroup = new Map<GeneralGroup, string[]>();
+    for (const l of extLinks) {
+      const group = l.group as GeneralGroup;
+      const arr = byGroup.get(group) ?? [];
+      arr.push(l.externalId);
+      byGroup.set(group, arr);
+    }
+    const extRows: SearchDocRow[] = [];
+    for (const [group, ids] of byGroup) {
+      const table = GENERAL_GROUP_TABLES[group as Exclude<GeneralGroup, "summary">];
+      if (!table) continue;
+      const rows = await (
+        prisma[table] as unknown as {
+          findMany: (args: Record<string, unknown>) => Promise<Array<{ id: string; title: string }>>;
+        }
+      ).findMany({ where: { id: { in: ids } }, select: GENERAL_ROW_SELECT });
+      for (const row of rows) {
+        extRows.push({
+          id: externalDocId(group, row.id),
+          title: row.title,
+          kbId: `${EXTERNAL_ID_PREFIX}${group}`,
+          kbName: group,
+          kbIcon: "book",
+          docIcon: null,
+          parentId: null,
+        });
+      }
+    }
+    return [...docRows, ...extRows];
   });

package/src/server/serverFns/story/story-attachments.ts

@@ -20,48 +20,36 @@ import { getRequest } from "@tanstack/react-start/server";
 import { z } from "zod";
 import { prisma } from "@allbluecn/database";
 import { requireAuth } from "@/server/auth-helpers";
-
-export const uploadAttachmentFn = createServerFn({ method: "POST" })
-  .handler(async () => {
-    const request = getRequest();
-    const session = await requireAuth(request);
-    const formData = await request.formData();
-
-    const storyId = formData.get("storyId") as string;
-    const file = formData.get("file") as File;
-
-    if (!storyId || !file) {
-      throw new Error("缺少 storyId 或 file");
-    }
-
-    const storageUrl = `/mock-storage/${Date.now()}-${file.name}`;
-    const fileSize = BigInt(file.size);
-    const mimeType = file.type;
-
-    const attachment = await prisma.storyAttachment.create({
-      data: {
-        storyId,
-        fileName: file.name,
-        fileSize,
-        mimeType,
-        storageUrl,
-      },
-    });
-
-    return attachment;
-  });
+import { ACTIVITY_SELECT, toActivityItem } from "./types";
 
 export const removeAttachmentFn = createServerFn({ method: "POST" })
   .validator(z.object({ attachmentId: z.string() }))
   .handler(async ({ data }) => {
     const request = getRequest();
     const session = await requireAuth(request);
+    const userId = session.user!.id!;
 
-    const attachment = await prisma.storyAttachment.delete({
+    const attachment = await prisma.storyAttachment.findUnique({ where: { id: data.attachmentId } });
+    await prisma.storyAttachment.delete({
       where: { id: data.attachmentId },
     });
 
-    return attachment;
+    // 结果含 BigInt fileSize 不可序列化，只返回活动记录（Seroval 安全的纯对象）
+    let activity = null;
+    if (attachment) {
+      const created = await prisma.storyActivity.create({
+        data: {
+          storyId: attachment.storyId,
+          userId,
+          action: "attachment_removed",
+          newValue: attachment.fileName,
+        },
+        select: ACTIVITY_SELECT,
+      });
+      activity = toActivityItem(created);
+    }
+
+    return { ok: true, activity };
   });
 
 export const getAttachmentsFn = createServerFn({ method: "GET" })
@@ -73,6 +61,14 @@ export const getAttachmentsFn = createServerFn({ method: "GET" })
     const attachments = await prisma.storyAttachment.findMany({
       where: { storyId: data.storyId },
       orderBy: { createdAt: "desc" },
+      select: {
+        id: true,
+        fileName: true,
+        fileSize: true,
+        mimeType: true,
+        description: true,
+        fileHash: true,
+      },
     });
 
     return attachments.map((att) => ({
@@ -80,18 +76,9 @@ export const getAttachmentsFn = createServerFn({ method: "GET" })
       fileName: att.fileName,
       fileSize: Number(att.fileSize),
       mimeType: att.mimeType,
-      storageUrl: att.storageUrl,
+      description: att.description,
+      fileHash: att.fileHash,
+      // 读取入口统一为内容路由（历史 mock 行无文件体，预览会 404）
+      storageUrl: `/api/attachments/${att.id}/content`,
     }));
   });
-
-export const mockCloudStorageFn = createServerFn({ method: "POST" })
-  .validator(z.object({ file: z.any() }))
-  .handler(async ({ data }) => {
-    const { file } = data;
-    const mockUrl = `/mock-storage/${Date.now()}-${file.name}`;
-
-    return {
-      url: mockUrl,
-      provider: "mock",
-    };
-  });

package/src/{components/project/project-icon.tsx → server/serverFns/story/story-crud/label-palette.ts}

@@ -15,24 +15,21 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-import { PROJECT_ICONS } from "@/components/shared/icon-packs/project";
-import { cn } from "@/lib/utils";
+export const LABEL_PALETTE = [
+  "#ef4444",
+  "#f97316",
+  "#f59e0b",
+  "#10b981",
+  "#06b6d4",
+  "#3b82f6",
+  "#8b5cf6",
+  "#ec4899",
+] as const;
 
-const ICON_MAP = new Map(
-  PROJECT_ICONS.map((i) => [i.value, i.icon]),
-);
-
-interface ProjectIconDisplayProps {
-  name?: string;
-  size?: number;
-  className?: string;
-}
-
-export function ProjectIconDisplay({
-  name,
-  size = 24,
-  className,
-}: ProjectIconDisplayProps) {
-  const Icon = ICON_MAP.get(name ?? "") ?? PROJECT_ICONS[0].icon;
-  return <Icon size={size} className={cn("text-current", className)} />;
+export function pickLabelColor(name: string): string {
+  let hash = 0;
+  for (const ch of name) {
+    hash = (hash * 31 + (ch.codePointAt(0) ?? 0)) | 0;
+  }
+  return LABEL_PALETTE[Math.abs(hash) % LABEL_PALETTE.length];
 }