package jnpf.bizcommon.onlyoffice.service.impl;
|
|
import cn.dev33.satoken.stp.StpUtil;
|
import cn.hutool.core.util.IdUtil;
|
import cn.hutool.crypto.digest.DigestUtil;
|
import cn.hutool.http.HttpResponse;
|
import cn.hutool.http.HttpUtil;
|
import cn.hutool.jwt.JWTUtil;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import jnpf.base.UserInfo;
|
import jnpf.bizcommon.onlyoffice.entity.OnlyOfficeCallbackParam;
|
import jnpf.bizcommon.onlyoffice.entity.OnlyOfficeConfigParam;
|
import jnpf.bizcommon.onlyoffice.entity.OnlyOfficeProperties;
|
import jnpf.bizcommon.onlyoffice.entity.OnlyOfficeSessionEntity;
|
import jnpf.bizcommon.onlyoffice.mapper.OnlyOfficeSessionMapper;
|
import jnpf.bizcommon.onlyoffice.service.OnlyOfficeService;
|
import jnpf.constant.PermissionConst;
|
import jnpf.exception.DataException;
|
import jnpf.file.FileApi;
|
import jnpf.file.FileUploadApi;
|
import jnpf.util.UserProvider;
|
import lombok.RequiredArgsConstructor;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.ObjectUtils;
|
import org.springframework.web.multipart.MultipartFile;
|
|
import java.io.ByteArrayInputStream;
|
import java.io.File;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.net.URI;
|
import java.nio.charset.StandardCharsets;
|
import java.nio.file.Files;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.HashSet;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
|
/**
|
* 编辑器 config 的签发。
|
*
|
* <p>本类只负责「打开文档」这一段。三段链路的凭据各不相同：打开走用户登录 token，
|
* DS 回源走 securityKey 票据，DS 回调走本类签发的同一把 JWT 密钥。
|
*/
|
@Slf4j
|
@Service
|
@RequiredArgsConstructor
|
public class OnlyOfficeServiceImpl implements OnlyOfficeService {
|
|
private final OnlyOfficeProperties properties;
|
private final OnlyOfficeSessionMapper sessionMapper;
|
private final OnlyOfficePluginResolver pluginResolver;
|
private final OnlyOfficeFillTicketIssuer fillTicketIssuer;
|
private final FileApi fileApi;
|
private final FileUploadApi fileUploadApi;
|
|
/** 扩展名 → DS documentType；未列出的一律拒绝，避免把不支持的格式喂给编辑器 */
|
private static final Map<String, String> DOCUMENT_TYPES = new HashMap<>();
|
|
static {
|
putAll("word", "doc", "docx", "docm", "dot", "dotx", "odt", "ott", "rtf", "txt", "html", "htm");
|
putAll("cell", "xls", "xlsx", "xlsm", "xlt", "xltx", "ods", "ots", "csv");
|
putAll("slide", "ppt", "pptx", "pptm", "pot", "potx", "pps", "ppsx", "odp", "otp");
|
putAll("pdf", "pdf");
|
}
|
|
private static void putAll(String documentType, String... extensions) {
|
for (String extension : extensions) {
|
DOCUMENT_TYPES.put(extension, documentType);
|
}
|
}
|
|
/** 可编辑的格式；其余（如 pdf、txt 之外的只读格式）一律降级为只读 */
|
private static final Set<String> EDITABLE_EXTENSIONS = new HashSet<>(Arrays.asList(
|
"docx", "xlsx", "pptx", "docm", "xlsm", "pptm", "odt", "ods", "odp", "rtf", "txt", "csv"));
|
|
private static final String MODE_VIEW = "view";
|
private static final String MODE_EDIT = "edit";
|
private static final String ELN_TEMPLATE_ANNOTATE_SCENE = "eln.template.annotate";
|
|
@Override
|
public Map<String, Object> buildEditorConfig(OnlyOfficeConfigParam param) {
|
if (ObjectUtils.isEmpty(param.getFileId()) || ObjectUtils.isEmpty(param.getFileName())) {
|
throw new DataException("fileId 与 fileName 不能为空");
|
}
|
requireJwtSecret();
|
|
String extension = extensionOf(param.getFileName());
|
String documentType = DOCUMENT_TYPES.get(extension);
|
if (documentType == null) {
|
throw new DataException("OnlyOffice 不支持的文件格式：" + extension);
|
}
|
|
List<OnlyOfficePluginResolver.ResolvedPlugin> resolvedPlugins = pluginResolver.resolve(param);
|
UserInfo user = UserProvider.getUser();
|
OnlyOfficeSessionEntity session = loadOrCreateSession(param, documentType);
|
String mode = resolveMode(param, extension, session, user);
|
if (MODE_EDIT.equals(mode)) {
|
acquireLock(session, user.getUserId());
|
}
|
|
return assembleConfig(param, session, documentType, extension, mode, user, resolvedPlugins);
|
}
|
|
@Override
|
public Map<String, Object> getSaveStatus(String fileId) {
|
if (ObjectUtils.isEmpty(fileId)) {
|
throw new DataException("fileId 不能为空");
|
}
|
OnlyOfficeSessionEntity session = sessionMapper.selectOne(Wrappers.<OnlyOfficeSessionEntity>lambdaQuery()
|
.eq(OnlyOfficeSessionEntity::getFileId, fileId)
|
.last("limit 1"));
|
Map<String, Object> status = new LinkedHashMap<>();
|
status.put("version", session == null || session.getVersionNo() == null ? 0 : session.getVersionNo());
|
status.put("lastSaveTime", session == null || session.getLastSaveTime() == null
|
? null : session.getLastSaveTime().getTime());
|
return status;
|
}
|
|
// ── 保存回调 ────────────────────────────────────────────────────────────
|
|
@Override
|
public void handleCallback(OnlyOfficeCallbackParam param, String authorization) {
|
verifyCallbackToken(param, authorization);
|
|
if (ObjectUtils.isEmpty(param.getKey()) || param.getStatus() == null) {
|
throw new DataException("回调缺少 key 或 status");
|
}
|
OnlyOfficeSessionEntity session = sessionMapper.selectOne(Wrappers.<OnlyOfficeSessionEntity>lambdaQuery()
|
.eq(OnlyOfficeSessionEntity::getDocKey, param.getKey())
|
.last("limit 1"));
|
if (session == null) {
|
// 会话被清理或 key 对不上。抛错让 Controller 记日志，但仍返回 error:0——
|
// 返回非 0 会让 DS 无限重试一个永远不会成功的回调。
|
throw new DataException("找不到 doc_key 对应的编辑会话：" + param.getKey());
|
}
|
|
switch (param.getStatus()) {
|
case OnlyOfficeCallbackParam.Status.EDITING:
|
refreshLockHeartbeat(session);
|
break;
|
case OnlyOfficeCallbackParam.Status.READY_FOR_SAVING:
|
saveBack(session, param, true);
|
break;
|
case OnlyOfficeCallbackParam.Status.FORCE_SAVING:
|
// 强制保存：落盘但不结束会话，故不轮换 key、不释放锁
|
saveBack(session, param, false);
|
break;
|
case OnlyOfficeCallbackParam.Status.CLOSED_NO_CHANGES:
|
releaseLock(session, OnlyOfficeSessionEntity.SessionStatus.IDLE);
|
break;
|
case OnlyOfficeCallbackParam.Status.SAVE_ERROR:
|
case OnlyOfficeCallbackParam.Status.FORCE_SAVE_ERROR:
|
log.error("OnlyOffice 保存出错，file={} key={} status={}",
|
session.getFileId(), param.getKey(), param.getStatus());
|
releaseLock(session, OnlyOfficeSessionEntity.SessionStatus.SAVE_FAILED);
|
break;
|
default:
|
log.warn("未知的 OnlyOffice 回调 status={}，key={}", param.getStatus(), param.getKey());
|
}
|
}
|
|
/**
|
* 验签。回调路径在网关白名单内、匿名可达，这是唯一的安全边界，
|
* 验不过一律抛错，不得降级放过。
|
*/
|
private void verifyCallbackToken(OnlyOfficeCallbackParam param, String authorization) {
|
String token = null;
|
if (!ObjectUtils.isEmpty(authorization)) {
|
token = authorization.startsWith("Bearer ") ? authorization.substring(7).trim() : authorization.trim();
|
}
|
if (ObjectUtils.isEmpty(token)) {
|
// 少数部署把 token 放在 body 而非 Authorization 头
|
token = param.getToken();
|
}
|
if (ObjectUtils.isEmpty(token)) {
|
throw new DataException("回调缺少 JWT，拒绝处理");
|
}
|
if (!JWTUtil.verify(token, requireJwtSecret().getBytes(StandardCharsets.UTF_8))) {
|
throw new DataException("回调 JWT 验签失败，拒绝处理");
|
}
|
}
|
|
/**
|
* 把 DS 产出的新版文档写回文件存储。
|
*
|
* <p>原地覆盖同一个 fileId——这样表单里存的附件字段 JSON 完全不用改写，
|
* 代价只是前端侧的 fileSize 会过期（靠 onSave 回调刷新）。
|
*
|
* @param rotateKey 是否轮换 doc_key 并释放锁。status 2（全员退出）为 true，
|
* status 6（强制保存，仍在编辑）为 false
|
*/
|
private void saveBack(OnlyOfficeSessionEntity session, OnlyOfficeCallbackParam param, boolean rotateKey) {
|
if (ObjectUtils.isEmpty(param.getUrl())) {
|
throw new DataException("回调 status=" + param.getStatus() + " 但缺少下载 url");
|
}
|
String downloadUrl = rewriteToInternalHost(param.getUrl());
|
try (HttpResponse response = HttpUtil.createGet(downloadUrl).timeout(60_000).executeAsync()) {
|
if (!response.isOk()) {
|
throw new DataException("从 DS 下载编辑后文档失败，HTTP " + response.getStatus());
|
}
|
MultipartFile file = new InMemoryMultipartFile(session.getFileId(), response.bodyBytes());
|
String folderPath = fileApi.getPath(session.getFileType());
|
if (ObjectUtils.isEmpty(folderPath)) {
|
throw new DataException("文件服务无法解析文档存储目录");
|
}
|
if (!folderPath.endsWith("/") && !folderPath.endsWith("\\")) {
|
folderPath += "/";
|
}
|
if (!fileUploadApi.replaceFile(file, folderPath, session.getFileId())) {
|
throw new DataException("文件服务写回文档失败");
|
}
|
} catch (DataException e) {
|
throw e;
|
} catch (Exception e) {
|
throw new DataException("写回文档失败：" + e.getMessage());
|
}
|
|
int nextVersion = session.getVersionNo() == null ? 1 : session.getVersionNo() + 1;
|
session.setLastSaveTime(new Date());
|
session.setLastEditorIds(param.getUsers() == null ? null : String.join(",", param.getUsers()));
|
if (rotateKey) {
|
// 内容变了必须换 key，否则下次打开 DS 会命中自身缓存返回旧内容
|
session.setVersionNo(nextVersion);
|
session.setDocKey(buildDocKey(session.getFileId(), nextVersion));
|
session.setLockUserId(null);
|
session.setLockHeartbeat(null);
|
session.setSessionStatus(OnlyOfficeSessionEntity.SessionStatus.IDLE);
|
}
|
sessionMapper.updateById(session);
|
log.info("OnlyOffice 保存回写完成，file={} version={} rotateKey={}",
|
session.getFileId(), session.getVersionNo(), rotateKey);
|
}
|
|
private static final class InMemoryMultipartFile implements MultipartFile {
|
|
private final String fileName;
|
private final byte[] content;
|
|
private InMemoryMultipartFile(String fileName, byte[] content) {
|
this.fileName = fileName;
|
this.content = content;
|
}
|
|
@Override
|
public String getName() {
|
return "multipartFile";
|
}
|
|
@Override
|
public String getOriginalFilename() {
|
return fileName;
|
}
|
|
@Override
|
public String getContentType() {
|
return "application/octet-stream";
|
}
|
|
@Override
|
public boolean isEmpty() {
|
return content.length == 0;
|
}
|
|
@Override
|
public long getSize() {
|
return content.length;
|
}
|
|
@Override
|
public byte[] getBytes() {
|
return content;
|
}
|
|
@Override
|
public InputStream getInputStream() {
|
return new ByteArrayInputStream(content);
|
}
|
|
@Override
|
public void transferTo(File destination) throws IOException {
|
Files.write(destination.toPath(), content);
|
}
|
}
|
|
/**
|
* DS 给的下载 url 用的是它自己视角的主机名，后端不一定能直连。
|
* 配了 ds-internal-url 就只保留 path+query 换到后端可达的主机上。
|
*/
|
private String rewriteToInternalHost(String url) {
|
String base = properties.getDsInternalUrl();
|
if (ObjectUtils.isEmpty(base)) {
|
return url;
|
}
|
try {
|
URI origin = URI.create(url);
|
String pathAndQuery = origin.getRawPath()
|
+ (origin.getRawQuery() == null ? "" : "?" + origin.getRawQuery());
|
String rewritten = base.endsWith("/") ? base.substring(0, base.length() - 1) + pathAndQuery
|
: base + pathAndQuery;
|
if (!rewritten.equals(url)) {
|
log.debug("DS 下载地址重写：{} → {}", url, rewritten);
|
}
|
return rewritten;
|
} catch (IllegalArgumentException e) {
|
log.warn("DS 下载地址无法解析，原样使用：{}", url);
|
return url;
|
}
|
}
|
|
private void refreshLockHeartbeat(OnlyOfficeSessionEntity session) {
|
session.setLockHeartbeat(new Date());
|
session.setSessionStatus(OnlyOfficeSessionEntity.SessionStatus.EDITING);
|
sessionMapper.updateById(session);
|
}
|
|
private void releaseLock(OnlyOfficeSessionEntity session, int status) {
|
session.setLockUserId(null);
|
session.setLockHeartbeat(null);
|
session.setSessionStatus(status);
|
sessionMapper.updateById(session);
|
}
|
|
// ── 会话与编辑锁 ─────────────────────────────────────────────────────────
|
|
/**
|
* 取当前文件的会话；没有则建一条 version_no=1 的新会话。
|
* docKey 由 fileId + versionNo 派生，保证同一版本重复打开拿到相同 key（否则 DS 不认为是同一文档）。
|
*/
|
private OnlyOfficeSessionEntity loadOrCreateSession(OnlyOfficeConfigParam param, String documentType) {
|
OnlyOfficeSessionEntity session = sessionMapper.selectOne(Wrappers.<OnlyOfficeSessionEntity>lambdaQuery()
|
.eq(OnlyOfficeSessionEntity::getFileId, param.getFileId())
|
.eq(OnlyOfficeSessionEntity::getFileType, param.getFileType())
|
.last("limit 1"));
|
if (session != null) {
|
// 业务上下文可能在后续调用里才补全（如先从附件列表打开、后从业务页面打开）
|
if (!ObjectUtils.isEmpty(param.getBizModule())) {
|
session.setBizModule(param.getBizModule());
|
}
|
if (!ObjectUtils.isEmpty(param.getBizDataId())) {
|
session.setBizDataId(param.getBizDataId());
|
}
|
session.setFileName(param.getFileName());
|
session.setDocumentType(documentType);
|
sessionMapper.updateById(session);
|
return session;
|
}
|
|
session = new OnlyOfficeSessionEntity();
|
session.setId(IdUtil.getSnowflakeNextIdStr());
|
session.setFileId(param.getFileId());
|
session.setFileType(param.getFileType());
|
session.setFileName(param.getFileName());
|
session.setDocumentType(documentType);
|
session.setBizModule(param.getBizModule());
|
session.setBizDataId(param.getBizDataId());
|
session.setVersionNo(1);
|
session.setSessionStatus(OnlyOfficeSessionEntity.SessionStatus.IDLE);
|
session.setDocKey(buildDocKey(param.getFileId(), 1));
|
session.setDeleteMark(null);
|
sessionMapper.insert(session);
|
return session;
|
}
|
|
/**
|
* 决定最终模式。前端传的只是期望值，以下四种情况一律降级为只读：
|
* 格式本身不可编辑、当前用户无编辑权、他人正持有编辑锁、DS 上一次保存失败
|
* （避免在错误状态上继续写）。
|
*/
|
private String resolveMode(OnlyOfficeConfigParam param, String extension, OnlyOfficeSessionEntity session, UserInfo user) {
|
if (ObjectUtils.isEmpty(param.getBizScene())) {
|
return MODE_VIEW;
|
}
|
if (MODE_VIEW.equals(param.getMode())) {
|
return MODE_VIEW;
|
}
|
if (!EDITABLE_EXTENSIONS.contains(extension)) {
|
return MODE_VIEW;
|
}
|
if (!hasEditPermission(param.getBizModule(), user)) {
|
return MODE_VIEW;
|
}
|
if (Integer.valueOf(OnlyOfficeSessionEntity.SessionStatus.SAVE_FAILED).equals(session.getSessionStatus())) {
|
log.warn("文档 {} 上次保存失败，本次降级只读", session.getFileId());
|
return MODE_VIEW;
|
}
|
if (isLockedByOthers(session, user.getUserId())) {
|
log.info("文档 {} 正被 {} 编辑，{} 降级只读", session.getFileId(), session.getLockUserId(), user.getUserId());
|
return MODE_VIEW;
|
}
|
return MODE_EDIT;
|
}
|
|
/**
|
* 菜单/按钮级编辑权判定。权限码在登录时已灌进 Sa-Token 会话，此处纯本地判断、无远程调用。
|
*
|
* <p>判不了的时候取哪一边由 {@code edit-permission.strict} 决定：默认放行（保持里程碑 3
|
* 之前的行为，那时最简调用并不传 bizModule），登记齐全后应当打开严格模式——否则
|
* 「漏登记」会表现为悄悄放行编辑，而不是能被人发现的报错。
|
*/
|
private boolean hasEditPermission(String bizModule, UserInfo user) {
|
// 超管直通，与 lims 既有判定同一口径（LimsJianceTaskServiceImpl#fetchAuditorOrganizes）
|
if (Boolean.TRUE.equals(user.getIsAdministrator())) {
|
return true;
|
}
|
|
OnlyOfficeProperties.EditPermission rule = properties.getEditPermission();
|
OnlyOfficeProperties.ModuleMapping mapping = ObjectUtils.isEmpty(bizModule)
|
? null
|
: rule.getModules().stream()
|
.filter(item -> bizModule.equals(item.getBizModule()))
|
.findFirst()
|
.orElse(null);
|
|
if (mapping == null || ObjectUtils.isEmpty(mapping.getModuleId())) {
|
if (rule.isStrict()) {
|
log.info("bizModule={} 未登记到 onlyoffice.edit-permission.modules，严格模式下降级只读", bizModule);
|
return false;
|
}
|
log.warn("bizModule={} 未登记编辑权限映射，当前为宽松模式故放行编辑；登记齐全后请开启 edit-permission.strict", bizModule);
|
return true;
|
}
|
|
String moduleId = mapping.getModuleId();
|
// 菜单级：连功能本身都没授权就没有继续判断的必要
|
if (!StpUtil.hasPermission(moduleId)) {
|
log.info("用户 {} 无功能 {} 的菜单权限，文档降级只读", user.getUserId(), moduleId);
|
return false;
|
}
|
// 按钮级：仅当该表单启用了按钮权限时才有意义，否则没人会有这个权限码（见 ModuleMapping 注释）
|
if (mapping.isRequireBtnEdit() && !StpUtil.hasPermission(moduleId + "::" + PermissionConst.BTN_EDIT)) {
|
log.info("用户 {} 无功能 {} 的编辑按钮权限，文档降级只读", user.getUserId(), moduleId);
|
return false;
|
}
|
return true;
|
}
|
|
/**
|
* 锁是否被他人持有。锁正常由 status 2/4 回调释放；浏览器崩溃等异常场景下
|
* 靠心跳超时兜底，否则文档会永久锁死。
|
*/
|
private boolean isLockedByOthers(OnlyOfficeSessionEntity session, String currentUserId) {
|
String holder = session.getLockUserId();
|
if (ObjectUtils.isEmpty(holder) || holder.equals(currentUserId)) {
|
return false;
|
}
|
Date heartbeat = session.getLockHeartbeat();
|
if (heartbeat == null) {
|
return false;
|
}
|
long timeoutMillis = properties.getLockTimeoutMinutes() * 60L * 1000L;
|
return System.currentTimeMillis() - heartbeat.getTime() < timeoutMillis;
|
}
|
|
private void acquireLock(OnlyOfficeSessionEntity session, String userId) {
|
session.setLockUserId(userId);
|
session.setLockHeartbeat(new Date());
|
session.setSessionStatus(OnlyOfficeSessionEntity.SessionStatus.EDITING);
|
sessionMapper.updateById(session);
|
}
|
|
// ── config 组装 ─────────────────────────────────────────────────────────
|
|
private Map<String, Object> assembleConfig(OnlyOfficeConfigParam param, OnlyOfficeSessionEntity session,
|
String documentType, String extension, String mode, UserInfo user,
|
List<OnlyOfficePluginResolver.ResolvedPlugin> resolvedPlugins) {
|
boolean editable = MODE_EDIT.equals(mode);
|
boolean hideComments = !editable || ELN_TEMPLATE_ANNOTATE_SCENE.equals(param.getBizScene());
|
|
Map<String, Object> permissions = new LinkedHashMap<>();
|
permissions.put("edit", editable);
|
// 只读模式关闭协作菜单；ELN 标注场景也隐藏批注，避免批注层与模板字段标注混在一起。
|
// 仅设 permissions.comment=false 关不干净，必须配上 customization.comments=false。
|
// DS 把「能写批注」和「能看批注面板」拆成了两个标志，且后者压根不看 permissions
|
// （web-apps/apps/documenteditor/main/app/controller/Main.js:1725-1727）：
|
// canComments = permissions.comment && mode!=='view' && customization.comments!==false
|
// canViewComments = canComments || customization.comments!==false ← 这里没有 permissions
|
// 而左栏那个批注按钮的显隐取的是 canViewComments（controller/LeftMenu.js:206）。
|
// 所以只关 permissions.comment 的效果是「按钮还在、点开只能看不能写」。2026-08-08 实踩。
|
if (hideComments) {
|
permissions.put("comment", false);
|
// 模板标注会用内容控件替换选区；禁用修订，避免原字符被记录为删除、新控件被记录为新增。
|
permissions.put("review", false);
|
}
|
permissions.put("chat", false);
|
// 下载与打印默认关闭：去掉「文件 → 下载为」「文件 → 打印」以及顶栏右侧那两个图标。
|
//
|
// ⚠️ 这两项只是**收掉界面入口**，不等于文件拿不到：/api/file/Image/** 在网关白名单内、
|
// 只靠 securityKey 票据鉴权，知道 URL 的人照样能把原文件拉走。真正的下载管控必须落在
|
// 文件服务那一层，别把这里的开关当安全边界。
|
// 将来要按人区分，用 §6.1 那套 bizModule→moduleId 登记表判 moduleId::btn_download /
|
// btn_batchPrint 即可（PermissionConst 里已有这两个码），机制现成不用新造。
|
permissions.put("download", properties.isAllowDownload());
|
permissions.put("print", properties.isAllowPrint());
|
// 收掉「保护」：同时去掉顶栏的「保护」页签与「文件」左菜单里的「保护」按钮。
|
// 归 permissions.protect 管而不是 customization——customization.layout.toolbar.protect
|
// 属白标参数，社区版镜像不认。DS ≥ 7.5 支持本项（当前 9.4.0.1）。
|
//
|
// 关掉的理由是它与本集成的模型冲突：加密/只读保护写进的是**文档自身**，
|
// 而我们编辑完是原地覆盖回同一个 fileId，一旦被加密，下次打开 DS 要密码、
|
// 后端也无从解，等于把附件锁死。谁能编辑由 §6.1 的权限判定 + 编辑锁决定。
|
permissions.put("protect", false);
|
|
Map<String, Object> document = new LinkedHashMap<>();
|
document.put("fileType", extension);
|
document.put("key", session.getDocKey());
|
document.put("title", param.getFileName());
|
document.put("url", buildFileFetchUrl(param, user));
|
document.put("permissions", permissions);
|
|
Map<String, Object> owner = new LinkedHashMap<>();
|
owner.put("id", user.getUserId());
|
owner.put("name", user.getUserName());
|
|
Map<String, Object> customization = buildCustomization(editable, !resolvedPlugins.isEmpty(), hideComments);
|
|
// 协同不在本期范围，但 DS 没有关闭协同的开关（coEditing 只有 fast/strict）。
|
// strict + change:false 让行为至少可预期：改动要保存后才互相可见，且禁掉界面切换入口
|
// （用户在界面改过模式会写进 localStorage 并覆盖此处传值）。真正的隔离靠编辑锁。
|
Map<String, Object> coEditing = new LinkedHashMap<>();
|
coEditing.put("mode", "strict");
|
coEditing.put("change", false);
|
|
Map<String, Object> editorConfig = new LinkedHashMap<>();
|
editorConfig.put("callbackUrl", properties.getCallbackBaseUrl() + "/api/biz/onlyoffice/callback");
|
editorConfig.put("lang", "zh");
|
editorConfig.put("mode", mode);
|
editorConfig.put("user", owner);
|
editorConfig.put("coEditing", coEditing);
|
editorConfig.put("customization", customization);
|
if (!resolvedPlugins.isEmpty()) {
|
Map<String, Object> plugins = new LinkedHashMap<>();
|
List<String> pluginsData = new ArrayList<>();
|
List<String> autostart = new ArrayList<>();
|
Map<String, Object> options = new LinkedHashMap<>();
|
for (OnlyOfficePluginResolver.ResolvedPlugin resolvedPlugin : resolvedPlugins) {
|
pluginsData.add(resolvedPlugin.getManifestUrl());
|
if (resolvedPlugin.isAutostart()) {
|
autostart.add(resolvedPlugin.getGuid());
|
}
|
Map<String, Object> context = resolvedPlugin.runtimeContext(param.getFileId(), param.getBizDataId());
|
if (OnlyOfficeFillTicketIssuer.PLUGIN_CODE.equals(resolvedPlugin.getPluginCode())) {
|
context.put("canFill", editable);
|
context.put("scope", OnlyOfficeFillTicketIssuer.SCOPE);
|
context.put("ticket", fillTicketIssuer.issue(param, user, resolvedPlugin.getGuid()));
|
} else if (ELN_TEMPLATE_ANNOTATE_SCENE.equals(param.getBizScene())) {
|
context.put("canAnnotate", editable);
|
}
|
options.put(resolvedPlugin.getGuid(), context);
|
}
|
plugins.put("pluginsData", pluginsData);
|
plugins.put("options", options);
|
if (!autostart.isEmpty()) {
|
plugins.put("autostart", autostart);
|
}
|
List<String> disabledPluginGuids = resolvedPlugins.get(0).getDisabledPluginGuids();
|
if (!disabledPluginGuids.isEmpty()) {
|
plugins.put("disable", disabledPluginGuids);
|
}
|
editorConfig.put("plugins", plugins);
|
}
|
|
Map<String, Object> config = new LinkedHashMap<>();
|
config.put("document", document);
|
config.put("documentType", documentType);
|
config.put("editorConfig", editorConfig);
|
|
// token 的 payload 就是上面这份 config 本身；DS 收到后用同一密钥验签，
|
// 防止浏览器篡改 permissions / callbackUrl。必须最后放，不能把自己算进去。
|
config.put("token", JWTUtil.createToken(config, requireJwtSecret().getBytes(StandardCharsets.UTF_8)));
|
return config;
|
}
|
|
/**
|
* 编辑器界面裁剪。**必须在后端拼进 config**：customization 在 JWT 签名范围内，
|
* 前端往 config 里塞字段会让 DS 验签失败（前端只能追加 events，函数不参与序列化）。
|
*
|
* <p>两类考虑分开看：
|
* <ul>
|
* <li><b>安全</b>：{@code macros}/{@code plugins}。附件是用户上传的外来文档，
|
* 可能带宏；插件（含 AI 入口）会把文档内容发往第三方，都不该默认开着。</li>
|
* <li><b>界面噪音</b>：帮助、反馈、顶栏文件名（弹窗标题已经有了）、右侧面板。
|
* 这些纯属观感，改动无风险。</li>
|
* </ul>
|
*
|
* <p>⚠️ logo / about / layout 那一类属**白标定制**，社区版镜像大概率不生效，故此处不设——
|
* 需要的话得先实测再加，别写了以为生效。
|
*
|
* @param editable 是否可编辑；forcesave/autosave 只在编辑态有意义，顶栏展开与否也随它变
|
*/
|
private Map<String, Object> buildCustomization(boolean editable, boolean pluginsEnabled, boolean hideComments) {
|
Map<String, Object> customization = new LinkedHashMap<>();
|
|
// ── 安全 ──
|
// 外来 docx 可能带宏：不自动运行，且不给用户开的入口
|
customization.put("macros", false);
|
customization.put("macrosMode", "disable");
|
// 仅后端白名单场景开启指定插件；空场景仍关闭全部插件入口。
|
customization.put("plugins", pluginsEnabled);
|
|
// ── 界面收敛 ──
|
// 默认关闭拼写检查；用户在界面修改后，localStorage 仍会覆盖这个初始值。
|
Map<String, Object> features = new LinkedHashMap<>();
|
features.put("spellcheck", false);
|
customization.put("features", features);
|
if (hideComments) {
|
// 批注面板的另一半开关，与 permissions.comment=false 必须成对出现。
|
customization.put("comments", false);
|
Map<String, Object> review = new LinkedHashMap<>();
|
review.put("trackChanges", false);
|
review.put("showReviewChanges", false);
|
customization.put("review", review);
|
}
|
customization.put("help", false);
|
customization.put("feedback", false);
|
// 左下角那个「提出功能建议」归 suggestFeature 管，不是 feedback（实测得知）
|
customization.put("suggestFeature", false);
|
// 顶栏不再重复显示文件名——我们的弹窗标题已经有了
|
customization.put("toolbarHideFileName", true);
|
customization.put("hideRightMenu", true);
|
// 顶栏形态按模式分：编辑态展开成完整功能区（工具找得到），只读态收成单行紧凑版
|
// （没有可用的编辑按钮，展开只是白占垂直空间）。这与 DS 自己的默认取向一致，
|
// 但仍显式写出——默认值随版本变过，别指望省略。
|
//
|
// ⚠️ 本项会被浏览器 localStorage 覆盖：用户手动折叠过顶栏，之后打开就一直是折叠的，
|
// 后端传什么都不算数。验证时请换无痕窗口，别以为配置没生效。
|
customization.put("compactToolbar", !editable);
|
|
customization.put("autosave", false);
|
if (editable) {
|
// forcesave：点保存即触发 status 6 回调，不必等全员退出才落盘
|
customization.put("forcesave", true);
|
}
|
return customization;
|
}
|
|
/**
|
* DS 回源拉文档的地址。走 /api/file/Image/**——该路径在 GatewayWhite 硬编码白名单内，
|
* DS 没有登录态也能取，鉴权靠 URL 上的 securityKey 票据。
|
*
|
* <p>🔴 {@code &t=t} 不能省，且它与"时间戳"无关。{@code FileServiceImpl#flushFile} 里
|
* {@code redirect = StringUtil.isEmpty(t)}：**带 securityKey 但不带 t 时，该端点不吐文件流，
|
* 而是 302 跳到 ApiDomain 上的预览地址**。DS 会跟着跳，最终拿到
|
* {@code {"code":400,"msg":"System abnormality"}} 并把这段 JSON 存成 origin.docx，
|
* 表现为编辑器一直转圈（HTTP 200 让 DS 以为下载成功了）。前端的
|
* {@code getAuthMediaUrl(url, isRedirect=false)} 也是靠追加 {@code &t=t} 拿原始流的，此处同源。
|
* 2026-08-08 实踩。
|
*/
|
private String buildFileFetchUrl(OnlyOfficeConfigParam param, UserInfo user) {
|
return properties.getFileFetchBaseUrl()
|
+ "/api/file/Image/" + param.getFileType() + "/" + param.getFileId()
|
+ "?s=" + user.getSecurityKey() + "&t=t";
|
}
|
|
// ── 工具 ────────────────────────────────────────────────────────────────
|
|
/**
|
* 取签名密钥，顺带挡住「占位符没被解析」这种静默失败。
|
*
|
* <p>配置写的是 {@code ${ONLYOFFICE_JWT_SECRET}}，而 **Spring Boot 的 Binder 对解析不了的
|
* 占位符是原样放行**（不抛异常）。所以变量没透传进容器时，这里拿到的是字面量
|
* {@code "${ONLYOFFICE_JWT_SECRET}"}——非空、能过空值校验、能签出 token，但 DS 验签必然
|
* 失败，表现为编辑器里「文档安全令牌的格式不正确」，且后端毫无异常可查。
|
* 2026-08-08 实踩过一次（compose 只把该变量喂给了 cx-onlyoffice，漏了 cx-biz-common）。
|
*/
|
private String requireJwtSecret() {
|
String secret = properties.getJwtSecret();
|
if (ObjectUtils.isEmpty(secret)) {
|
throw new DataException("OnlyOffice 未配置 jwt-secret，无法签发/校验令牌");
|
}
|
if (secret.startsWith("${")) {
|
throw new DataException("OnlyOffice 的 jwt-secret 仍是未解析的占位符（" + secret
|
+ "），说明运行环境没有注入 ONLYOFFICE_JWT_SECRET——容器栈检查 docker-compose.yml"
|
+ " 的 cx-biz-common environment，宿主栈检查 .env 是否被 start-all.sh 加载");
|
}
|
return secret;
|
}
|
|
/**
|
* doc_key：DS 用它判断「是不是同一份文档的同一个版本」。
|
* md5 取 32 位十六进制，天然满足 DS 对字符集 [0-9a-zA-Z_-] 与长度 ≤128 的要求。
|
*/
|
private String buildDocKey(String fileId, int versionNo) {
|
return DigestUtil.md5Hex(fileId + "_" + versionNo);
|
}
|
|
private String extensionOf(String fileName) {
|
int dot = fileName.lastIndexOf('.');
|
if (dot < 0 || dot == fileName.length() - 1) {
|
throw new DataException("无法识别文件扩展名：" + fileName);
|
}
|
return fileName.substring(dot + 1).toLowerCase();
|
}
|
}
|
