create-dp-koa 1.0.0

package/template/src/plugins/weboffice/http/routes.ts

@@ -0,0 +1,179 @@
+import type Router from "koa-router";
+import { Provider } from "dp-ioc2";
+import { WebofficeCallbackService } from "../services/webofficeCallback.service";
+import { parseWebOfficeContext } from "../core/context";
+import { OK, WebOfficeError, ErrInvalidArguments } from "../core/errors";
+import { logger } from "@src/framework/utils/logger";
+import path from "path";
+import fs from "fs";
+
+const OK_CODE = OK;
+
+function replySuccess(ctx: any, data: unknown): void {
+  ctx.status = 200;
+  ctx.body = { code: OK_CODE, data };
+}
+
+function replyError(ctx: any, err: unknown): void {
+  if (err instanceof WebOfficeError) {
+    ctx.status = err.statusCode;
+    ctx.body = { code: err.code, message: err.message };
+  } else {
+    logger.error("WebOffice callback error", err as Error);
+    ctx.status = 500;
+    ctx.body = { code: 50001, message: "internal error" };
+  }
+}
+
+function registerUnderPrefix(router: Router, basePath: string): void {
+  const prefix = basePath.replace(/\/$/, "");
+  const service = Provider(WebofficeCallbackService) as WebofficeCallbackService;
+  const base = prefix ? path.join(prefix, "v3/3rd").replace(/\\/g, "/") : "/v3/3rd";
+
+  router.post(`${base}/files`, async (ctx) => {
+    try {
+      const woCtx = parseWebOfficeContext(ctx);
+      const body = (ctx.request.body as any) || {};
+      const name = body.name || "未命名文档";
+      const projectId = body.project_id != null ? Number(body.project_id) : undefined;
+      const data = await service.createDocument(woCtx, name, projectId);
+      replySuccess(ctx, data);
+    } catch (e) {
+      replyError(ctx, e);
+    }
+  });
+
+  router.get(`${base}/files/:file_id`, async (ctx) => {
+    try {
+      const woCtx = parseWebOfficeContext(ctx);
+      const fileId = ctx.params.file_id;
+      const data = await service.getFile(woCtx, fileId);
+      replySuccess(ctx, data);
+    } catch (e) {
+      replyError(ctx, e);
+    }
+  });
+
+  router.get(`${base}/files/:file_id/download`, async (ctx) => {
+    try {
+      const woCtx = parseWebOfficeContext(ctx);
+      const fileId = ctx.params.file_id;
+      const data = await service.getFileDownload(woCtx, fileId);
+      replySuccess(ctx, data);
+    } catch (e) {
+      replyError(ctx, e);
+    }
+  });
+
+  router.get(`${base}/files/:file_id/permission`, async (ctx) => {
+    try {
+      const woCtx = parseWebOfficeContext(ctx);
+      const fileId = ctx.params.file_id;
+      const data = await service.getFilePermission(woCtx, fileId);
+      replySuccess(ctx, data);
+    } catch (e) {
+      replyError(ctx, e);
+    }
+  });
+
+  router.get(`${base}/users`, async (ctx) => {
+    try {
+      const woCtx = parseWebOfficeContext(ctx);
+      const userIds = Array.isArray(ctx.query.user_ids)
+        ? (ctx.query.user_ids as string[])
+        : ctx.query.user_ids
+          ? String(ctx.query.user_ids).split(",").filter(Boolean)
+          : [];
+      const data = await service.getUsers(woCtx, userIds);
+      replySuccess(ctx, data);
+    } catch (e) {
+      replyError(ctx, e);
+    }
+  });
+
+  router.get(`${base}/files/:file_id/watermark`, async (ctx) => {
+    try {
+      const woCtx = parseWebOfficeContext(ctx);
+      const fileId = ctx.params.file_id;
+      const data = await service.getFileWatermark(woCtx, fileId);
+      replySuccess(ctx, data);
+    } catch (e) {
+      replyError(ctx, e);
+    }
+  });
+
+  router.post(`${base}/files/:file_id/upload`, async (ctx) => {
+    try {
+      const woCtx = parseWebOfficeContext(ctx);
+      const fileId = ctx.params.file_id;
+      const files = (ctx.request as any).files;
+      const body = (ctx.request as any).body || {};
+      if (!files?.file) {
+        replyError(ctx, ErrInvalidArguments.withMessage("file required"));
+        return;
+      }
+      const file = Array.isArray(files.file) ? files.file[0] : files.file;
+      const filePath = file.filepath ?? file.path;
+      if (!filePath || !fs.existsSync(filePath)) {
+        replyError(ctx, ErrInvalidArguments.withMessage("file path invalid"));
+        return;
+      }
+      const args = {
+        name: body.name ?? file.originalFilename ?? "file",
+        size: Number(body.size) || 0,
+        sha1: body.sha1 ?? "",
+        isManual: body.is_manual === "true" || body.is_manual === true,
+        filePath,
+      };
+      const data = await service.updateFile(woCtx, fileId, args);
+      replySuccess(ctx, data);
+    } catch (e) {
+      replyError(ctx, e);
+    }
+  });
+
+  router.get(`${base}/files/:file_id/versions`, async (ctx) => {
+    try {
+      const woCtx = parseWebOfficeContext(ctx);
+      const fileId = ctx.params.file_id;
+      const offset = Math.max(0, Number(ctx.query.offset) || 0);
+      const limit = Math.min(100, Math.max(1, Number(ctx.query.limit) || 20));
+      const data = await service.getFileVersions(woCtx, fileId, offset, limit);
+      replySuccess(ctx, data);
+    } catch (e) {
+      replyError(ctx, e);
+    }
+  });
+
+  router.get(`${base}/files/:file_id/versions/:version`, async (ctx) => {
+    try {
+      const woCtx = parseWebOfficeContext(ctx);
+      const fileId = ctx.params.file_id;
+      const version = Number(ctx.params.version) || 0;
+      const data = await service.getFileVersion(woCtx, fileId, version);
+      replySuccess(ctx, data);
+    } catch (e) {
+      replyError(ctx, e);
+    }
+  });
+
+  router.get(`${base}/files/:file_id/versions/:version/download`, async (ctx) => {
+    try {
+      const woCtx = parseWebOfficeContext(ctx);
+      const fileId = ctx.params.file_id;
+      const version = Number(ctx.params.version) || 0;
+      const data = await service.getFileVersionDownload(woCtx, fileId, version);
+      replySuccess(ctx, data);
+    } catch (e) {
+      replyError(ctx, e);
+    }
+  });
+}
+
+export function registerWebOfficeRoutes(router: Router): void {
+  const prefixFromEnv = (process.env.WEBOFFICE_CALLBACK_PREFIX || "/weboffice").replace(/\/$/, "");
+  registerUnderPrefix(router, prefixFromEnv);
+  if (prefixFromEnv !== "") registerUnderPrefix(router, "");
+  logger.info('WebOffice routes registered (prefix: %s and /v3/3rd)', prefixFromEnv);
+}
+

package/template/src/plugins/weboffice/index.ts

@@ -0,0 +1,23 @@
+import type Router from "koa-router";
+import type Koa from "koa";
+import type { PluginDescriptor } from "@src/framework/plugins/types";
+import { registerWebOfficeRoutes } from "./http/routes";
+import { WebofficeFileEntity, WebofficeFileVersionEntity } from "./entities";
+import { logger } from "@src/framework/utils/logger";
+
+export const plugin: PluginDescriptor = {
+  id: "weboffice",
+  displayName: "WPS WebOffice 示例插件",
+  enabled: (env) => env.WEBOFFICE_ENABLED !== "0",
+
+  onBeforeBootstrap(_app: Koa) {
+    logger.info('Plugin "weboffice" before bootstrap');
+  },
+
+  registerRoutes(router: Router) {
+    registerWebOfficeRoutes(router);
+  },
+
+  entities: [WebofficeFileEntity, WebofficeFileVersionEntity],
+};
+

package/template/src/plugins/weboffice/services/webofficeCallback.service.ts

@@ -0,0 +1,274 @@
+import { Injectable } from "dp-ioc2";
+import { BaseService } from "@src/service/base.service";
+import { WebofficeFileEntity } from "../entities/webofficeFile.entity";
+import { WebofficeFileVersionEntity } from "../entities/webofficeFileVersion.entity";
+import {
+  GetFileReply,
+  GetFileDownloadReply,
+  GetFilePermissionReply,
+  WebOfficeUser,
+  GetWatermarkReply,
+  WebOfficeContext,
+  UpdateFile1PhaseArgs,
+} from "../core/types";
+import {
+  ErrFileNotExists,
+  ErrFileVersionNotExists,
+  ErrInvalidArguments,
+  ErrInternalError,
+} from "../core/errors";
+import { normalizeWpsUserId } from "../core/utils";
+import { getFilePublicUrl, isCosConfigured, uploadToCos, webofficeCosKey } from "@src/libs/cos";
+import { logger } from "@src/framework/utils/logger";
+import fs from "fs";
+import { v4 as uuidv4 } from "uuid";
+
+@Injectable()
+export class WebofficeCallbackService extends BaseService {
+  private generateFileId(): string {
+    return uuidv4().replace(/-/g, "");
+  }
+
+  async createDocument(
+    ctx: WebOfficeContext,
+    name: string,
+    projectId?: number
+  ): Promise<{ file_id: string }> {
+    const fileRepo = this.getDataRepository(WebofficeFileEntity);
+    const versionRepo = this.getDataRepository(WebofficeFileVersionEntity);
+    const fileId = this.generateFileId();
+    const file = new WebofficeFileEntity();
+    file.fileId = fileId;
+    file.name = name || "未命名文档";
+    file.creatorId = ctx.token || "system";
+    file.modifierId = ctx.token || "system";
+    file.currentVersion = 1;
+    file.projectId = projectId ?? null;
+    await fileRepo.save(file);
+    const version = new WebofficeFileVersionEntity();
+    version.webofficeFileId = file.id;
+    version.version = 1;
+    version.size = 0;
+    version.digest = "";
+    version.cosKey = "";
+    version.creatorId = ctx.token || "system";
+    await versionRepo.save(version);
+    return { file_id: fileId };
+  }
+
+  private async getFileAndCurrentVersion(
+    fileId: string
+  ): Promise<{ file: WebofficeFileEntity; version: WebofficeFileVersionEntity } | null> {
+    const fileRepo = this.getDataRepository(WebofficeFileEntity);
+    const versionRepo = this.getDataRepository(WebofficeFileVersionEntity);
+    const file = await fileRepo.findOne({
+      where: { fileId },
+      relations: ["versions"],
+    });
+    if (!file) return null;
+    const version = await versionRepo.findOne({
+      where: { webofficeFileId: file.id, version: file.currentVersion },
+    });
+    if (!version) return null;
+    return { file, version };
+  }
+
+  private toGetFileReply(
+    file: WebofficeFileEntity,
+    version: WebofficeFileVersionEntity
+  ): GetFileReply {
+    return {
+      id: file.fileId,
+      name: file.name,
+      size: Number(version.size),
+      version: file.currentVersion,
+      create_time: Math.floor((file.createDate?.getTime() ?? 0) / 1000),
+      modify_time: Math.floor((file.updateDate?.getTime() ?? 0) / 1000),
+      creator_id: normalizeWpsUserId(file.creatorId),
+      modifier_id: normalizeWpsUserId(file.modifierId),
+    };
+  }
+
+  async getFile(_ctx: WebOfficeContext, fileId: string): Promise<GetFileReply> {
+    const pair = await this.getFileAndCurrentVersion(fileId);
+    if (!pair) throw ErrFileNotExists;
+    return this.toGetFileReply(pair.file, pair.version);
+  }
+
+  async getFileDownload(
+    _ctx: WebOfficeContext,
+    fileId: string
+  ): Promise<GetFileDownloadReply> {
+    const pair = await this.getFileAndCurrentVersion(fileId);
+    if (!pair) throw ErrFileNotExists;
+    if (!pair.version.cosKey?.trim())
+      throw ErrFileNotExists.withMessage("file content not uploaded yet");
+    const url = getFilePublicUrl(pair.version.cosKey);
+    if (!url) throw ErrInternalError.withMessage("FILES_HOST not configured");
+    return {
+      url,
+      digest: pair.version.digest || "",
+      digest_type: "sha1",
+      headers: {},
+    };
+  }
+
+  async getFilePermission(
+    ctx: WebOfficeContext,
+    fileId: string
+  ): Promise<GetFilePermissionReply> {
+    const pair = await this.getFileAndCurrentVersion(fileId);
+    if (!pair) throw ErrFileNotExists;
+    const userId = ctx.token || "anonymous";
+    const hasUser = !!ctx.token;
+    return {
+      user_id: normalizeWpsUserId(userId),
+      read: 1,
+      download: 1,
+      update: hasUser ? 1 : 0,
+      copy: 1,
+      print: 1,
+      saveas: 1,
+      comment: hasUser ? 1 : 0,
+      history: hasUser ? 1 : 0,
+      rename: 0,
+    };
+  }
+
+  /**
+   * 模板示例插件不依赖宿主业务用户表：对任意 user_id 返回占位用户信息。
+   * 若在真实业务中接入，请通过 plugin-api 或宿主 UserService 做映射。
+   */
+  async getUsers(_ctx: WebOfficeContext, userIds: string[]): Promise<WebOfficeUser[]> {
+    return (userIds || []).filter(Boolean).map((id) => {
+      const norm = normalizeWpsUserId(id);
+      return {
+        id: norm,
+        name: norm,
+        avatar_url: "",
+        logined: id !== "anonymous",
+      };
+    });
+  }
+
+  async getFileWatermark(
+    _ctx: WebOfficeContext,
+    _fileId: string
+  ): Promise<GetWatermarkReply> {
+    return {
+      type: 1,
+      value: "weboffice",
+      fill_style: "rgba(192,192,192,0.6)",
+      font: "bold 20px Serif",
+      rotate: 0.5,
+      horizontal: 50,
+      vertical: 50,
+    };
+  }
+
+  async updateFile(
+    ctx: WebOfficeContext,
+    fileId: string,
+    args: UpdateFile1PhaseArgs
+  ): Promise<GetFileReply> {
+    if (!isCosConfigured()) throw ErrInternalError.withMessage("COS not configured");
+    const fileRepo = this.getDataRepository(WebofficeFileEntity);
+    const versionRepo = this.getDataRepository(WebofficeFileVersionEntity);
+    const file = await fileRepo.findOne({ where: { fileId } });
+    if (!file) throw ErrFileNotExists;
+    const nextVersion = file.currentVersion + 1;
+    const cosKey = webofficeCosKey(fileId, nextVersion);
+    try {
+      await uploadToCos(args.filePath, cosKey);
+    } catch (e) {
+      logger.error("WebOffice COS upload failed", e as Error);
+      throw ErrInternalError.withMessage("Upload failed");
+    } finally {
+      try {
+        if (args.filePath && fs.existsSync(args.filePath)) {
+          fs.unlinkSync(args.filePath);
+        }
+      } catch (_) {}
+    }
+    const versionEntity = new WebofficeFileVersionEntity();
+    versionEntity.webofficeFileId = file.id;
+    versionEntity.version = nextVersion;
+    versionEntity.size = args.size;
+    versionEntity.digest = args.sha1 || "";
+    versionEntity.cosKey = cosKey;
+    versionEntity.creatorId = ctx.token || "system";
+    await versionRepo.save(versionEntity);
+    file.currentVersion = nextVersion;
+    file.modifierId = ctx.token || "system";
+    file.name = args.name || file.name;
+    file.updateDate = new Date();
+    await fileRepo.save(file);
+    const version = await versionRepo.findOne({
+      where: { webofficeFileId: file.id, version: nextVersion },
+    });
+    if (!version) throw ErrInternalError;
+    return this.toGetFileReply(file, version);
+  }
+
+  async renameFile(_ctx: WebOfficeContext, _fileId: string, _name: string): Promise<void> {
+    throw ErrInvalidArguments.withMessage("rename not implemented in template plugin");
+  }
+
+  async getFileVersions(
+    _ctx: WebOfficeContext,
+    fileId: string,
+    offset: number,
+    limit: number
+  ): Promise<GetFileReply[]> {
+    const pair = await this.getFileAndCurrentVersion(fileId);
+    if (!pair) throw ErrFileNotExists;
+    const versionRepo = this.getDataRepository(WebofficeFileVersionEntity);
+    const versions = await versionRepo.find({
+      where: { webofficeFileId: pair.file.id },
+      order: { version: "DESC" },
+      skip: offset,
+      take: limit,
+    });
+    return versions.map((v) => this.toGetFileReply(pair.file, v));
+  }
+
+  async getFileVersion(
+    _ctx: WebOfficeContext,
+    fileId: string,
+    version: number
+  ): Promise<GetFileReply> {
+    const fileRepo = this.getDataRepository(WebofficeFileEntity);
+    const versionRepo = this.getDataRepository(WebofficeFileVersionEntity);
+    const file = await fileRepo.findOne({ where: { fileId } });
+    if (!file) throw ErrFileNotExists;
+    const v = await versionRepo.findOne({
+      where: { webofficeFileId: file.id, version },
+    });
+    if (!v) throw ErrFileVersionNotExists;
+    return this.toGetFileReply(file, v);
+  }
+
+  async getFileVersionDownload(
+    _ctx: WebOfficeContext,
+    fileId: string,
+    version: number
+  ): Promise<GetFileDownloadReply> {
+    const fileRepo = this.getDataRepository(WebofficeFileEntity);
+    const versionRepo = this.getDataRepository(WebofficeFileVersionEntity);
+    const file = await fileRepo.findOne({ where: { fileId } });
+    if (!file) throw ErrFileNotExists;
+    const v = await versionRepo.findOne({
+      where: { webofficeFileId: file.id, version },
+    });
+    if (!v) throw ErrFileVersionNotExists;
+    const url = getFilePublicUrl(v.cosKey);
+    if (!url) throw ErrInternalError.withMessage("FILES_HOST not configured");
+    return {
+      url,
+      digest: v.digest || "",
+      digest_type: "sha1",
+      headers: {},
+    };
+  }
+}
+

package/template/src/repository/UserRepository.ts

@@ -0,0 +1,122 @@
+import { Repository } from 'typeorm';
+import { YtUserEntity } from '@src/entity/ytUser.entity';
+import { BaseRepository } from '@src/repository/base/BaseRepository';
+import { IBaseRepository } from '@src/repository/interfaces/IBaseRepository';
+
+/**
+ * 用户Repository接口
+ * 定义用户相关的数据访问操作
+ */
+export interface IUserRepository extends IBaseRepository<YtUserEntity> {
+    findByEmail(email: string): Promise<YtUserEntity | null>;
+    findByTelNumber(telNumber: string): Promise<YtUserEntity | null>;
+    findByUserType(userType: string): Promise<YtUserEntity[]>;
+    findByStatus(status: string): Promise<YtUserEntity[]>;
+    findActiveUsers(): Promise<YtUserEntity[]>;
+    updateLastLoginTime(id: number): Promise<void>;
+    updatePassword(id: number, hashedPassword: string): Promise<void>;
+    deactivateUser(id: number): Promise<void>;
+    activateUser(id: number): Promise<void>;
+}
+
+/**
+ * 用户Repository实现
+ */
+export class UserRepository extends BaseRepository<YtUserEntity> implements IUserRepository {
+    constructor(repository: Repository<YtUserEntity>) {
+        super(YtUserEntity, repository);
+    }
+
+    async findByEmail(email: string): Promise<YtUserEntity | null> {
+        try {
+            return await this.repository.findOne({
+                where: { email }
+            });
+        } catch (error) {
+            throw error;
+        }
+    }
+
+    async findByTelNumber(telNumber: string): Promise<YtUserEntity | null> {
+        try {
+            return await this.repository.findOne({
+                where: { telnumber: telNumber }
+            });
+        } catch (error) {
+            throw error;
+        }
+    }
+
+    async findByUserType(userType: string): Promise<YtUserEntity[]> {
+        try {
+            return await this.repository.find({
+                where: { userType: userType as any }
+            });
+        } catch (error) {
+            throw error;
+        }
+    }
+
+    async findByStatus(status: string): Promise<YtUserEntity[]> {
+        try {
+            return await this.repository.find({
+                where: { status: status as any }
+            });
+        } catch (error) {
+            throw error;
+        }
+    }
+
+    async findActiveUsers(): Promise<YtUserEntity[]> {
+        try {
+            return await this.repository.find({
+                where: { status: 'normal' as any }
+            });
+        } catch (error) {
+            throw error;
+        }
+    }
+
+    async updateLastLoginTime(id: number): Promise<void> {
+        try {
+            await this.repository.update(id, {
+                updateDate: new Date()
+            } as any);
+        } catch (error) {
+            throw error;
+        }
+    }
+
+    async updatePassword(id: number, hashedPassword: string): Promise<void> {
+        try {
+            await this.repository.update(id, {
+                password: hashedPassword,
+                updateDate: new Date()
+            } as any);
+        } catch (error) {
+            throw error;
+        }
+    }
+
+    async deactivateUser(id: number): Promise<void> {
+        try {
+            await this.repository.update(id, {
+                status: 'forbidden' as any,
+                updateDate: new Date()
+            } as any);
+        } catch (error) {
+            throw error;
+        }
+    }
+
+    async activateUser(id: number): Promise<void> {
+        try {
+            await this.repository.update(id, {
+                status: 'normal' as any,
+                updateDate: new Date()
+            } as any);
+        } catch (error) {
+            throw error;
+        }
+    }
+}