You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

907 lines
35KB

  1. /**
  2. * 从OA调用传来的指令,打开本地新建文件
  3. * @param {*} fileUrl 文件url路径
  4. */
  5. function NewFile(params) {
  6. //获取WPS Application 对象
  7. var wpsApp = wps.WpsApplication();
  8. wps.PluginStorage.setItem(constStrEnum.IsInCurrOADocOpen, true); //设置OA打开文档的临时状态
  9. //判断一下isOfficialDocument是否通过公文写作打开
  10. var doc;
  11. if (params.isOfficialDocument) {
  12. wps.Application.GetApplicationEx().NewOfficialDocument(); //新增使用公文写作打开的公文
  13. doc = wpsApp.ActiveDocument;
  14. } else {
  15. doc = wpsApp.Documents.Add(); //新增OA端文档
  16. }
  17. wps.PluginStorage.setItem(constStrEnum.IsInCurrOADocOpen, false);
  18. //检查系统临时文件目录是否能访问
  19. if (wps.Env && wps.Env.GetTempPath) {
  20. if (params.newFileName) {
  21. //按OA传入的文件名称保存
  22. doc.SaveAs2($FileName = wps.Env.GetTempPath() + "/" + params.newFileName, undefined, undefined, undefined, false);
  23. } else {
  24. //OA传入空文件名称,则保存成系统时间文件
  25. if (params.isOfficialDocument) {
  26. doc.SaveAs2($FileName = wps.Env.GetTempPath() + "/OA_" + currentTime(), 0, undefined, undefined, false);
  27. } else {
  28. doc.SaveAs2($FileName = wps.Env.GetTempPath() + "/OA_" + currentTime(), undefined, undefined, undefined, false);
  29. }
  30. }
  31. } else {
  32. alert("文档保存临时目录出错!不能保存新建文档!请联系系统开发商。");
  33. }
  34. var l_NofityURL = GetParamsValue(params, constStrEnum.notifyUrl);
  35. if (l_NofityURL) {
  36. NotifyToServer(l_NofityURL.replace("{?}", "1"));
  37. }
  38. //Office文件打开后,设置该文件属性:从服务端来的OA文件
  39. pSetOADocumentFlag(doc, params);
  40. //设置当前文档为 本地磁盘落地模式
  41. DoSetOADocLandMode(doc, EnumDocLandMode.DLM_LocalDoc);
  42. //强制执行一次Activate事件
  43. OnWindowActivate();
  44. wps.WpsApplication().WindowState=1;
  45. wps.WpsApplication().Activate(); //把WPS对象置前
  46. return doc; //返回新创建的Document对象
  47. }
  48. /**
  49. * 打开服务器上的文件
  50. * @param {*} fileUrl 文件url路径
  51. */
  52. function OpenFile(params) {
  53. sessionStorage.setItem('cehsi', JSON.stringify(params));
  54. var l_strFileUrl = params.filePath; //来自OA网页端的OA文件下载路径
  55. var doc;
  56. var l_IsOnlineDoc = false; //默认打开的是不落地文档
  57. if (l_strFileUrl) {
  58. //下载文档之前,判断是否已下载该文件
  59. if (pCheckIsExistOpenOADoc(l_strFileUrl) == true) {
  60. //如果找到相同OA地址文档,则给予提示
  61. wps.WpsApplication().WindowState=1;
  62. wps.WpsApplication().Activate(); //把WPS对象置前
  63. //根据OA助手对是否允许再次打开相同文件的判断处理
  64. var l_AllowOADocReOpen = false;
  65. l_AllowOADocReOpen = wps.PluginStorage.getItem(constStrEnum.AllowOADocReOpen);
  66. if (l_AllowOADocReOpen == false) {
  67. alert("已打开相同的OA文件,请关闭之前的文件,再次打开。");
  68. wps.WpsApplication().Activate();
  69. return null;
  70. } else {
  71. //处理重复打开相同OA 文件的方法
  72. var nDocCount = wps.WpsApplication().Documents.Count;
  73. pReOpenOADoc(l_strFileUrl);
  74. //重复打开的文档采用不落地的方式打开
  75. // 不落地方式打开文档判断落地比较多,V1版本先暂时关闭
  76. l_IsOnlineDoc = true;
  77. var nDocCount_New = wps.WpsApplication().Documents.Count;
  78. if (nDocCount_New > nDocCount) {
  79. doc = wps.WpsApplication().ActiveDocument;
  80. }
  81. }
  82. } else {
  83. //如果当前没有打开文档,则另存为本地文件,再打开
  84. if (l_strFileUrl.startWith("http")) { // 网络文档
  85. DownloadFile(l_strFileUrl,params.fileName, function(path) {
  86. if (path == "") {
  87. alert("从服务端下载路径:" + l_strFileUrl + "\n" + "获取文件下载失败!");
  88. return null;
  89. }
  90. doc = pDoOpenOADocProcess(params, path);
  91. pOpenFile(doc, params, l_IsOnlineDoc);
  92. });
  93. return;
  94. } else { //本地文档
  95. doc = pDoOpenOADocProcess(params, l_strFileUrl);
  96. if (doc)
  97. doc.SaveAs2($FileName = wps.Env.GetTempPath() + "/" + doc.Name, undefined, undefined, undefined, false);
  98. }
  99. }
  100. } else {
  101. //fileURL 如果为空,则按新建OA本地文件处理
  102. NewFile(params);
  103. }
  104. //如果打开pdf等其他非Office文档,则doc对象为空
  105. if (!doc) {
  106. return null;
  107. }
  108. pOpenFile(doc, params, l_IsOnlineDoc);
  109. }
  110. /**
  111. * 作用:文档打开后执行的动作集合
  112. * @param {*} doc 文档对象
  113. * @param {*} params 前端传递的参数集合
  114. * @param {*} isOnlineDoc 在线打开/落地打开
  115. */
  116. function pOpenFile(doc, params, isOnlineDoc) {
  117. var l_IsOnlineDoc = isOnlineDoc
  118. //Office文件打开后,设置该文件属性:从服务端来的OA文件
  119. pSetOADocumentFlag(doc, params)
  120. //设置当前文档为 本地磁盘落地模式
  121. if (l_IsOnlineDoc == true) {
  122. DoSetOADocLandMode(doc, EnumDocLandMode.DLM_OnlineDoc);
  123. } else {
  124. DoSetOADocLandMode(doc, EnumDocLandMode.DLM_LocalDoc);
  125. }
  126. if (GetParamsValue(params, constStrEnum.templateDataUrl)) {
  127. GetServerTemplateData(doc, params[constStrEnum.templateDataUrl]);
  128. }
  129. if (GetParamsValue(params, constStrEnum.insertFileUrl)) {
  130. InsertRedHeadDoc(doc);
  131. }
  132. var l_NofityURL = GetParamsValue(params, constStrEnum.notifyUrl);
  133. if (l_NofityURL) {
  134. l_NofityURL = l_NofityURL.replace("{?}", "1"); //约定:参数为1则代码打开状态
  135. NotifyToServer(l_NofityURL);
  136. }
  137. //重新设置工具条按钮的显示状态
  138. pDoResetRibbonGroups();
  139. // 触发切换窗口事件
  140. OnWindowActivate();
  141. // 把WPS对象置前
  142. wps.WpsApplication().WindowState=1;
  143. wps.WpsApplication().Activate();
  144. return doc;
  145. }
  146. /**
  147. * 套用模板插入文字/图片/文档
  148. * * params参数结构
  149. * params:{
  150. * 'docId': docId, //文档ID
  151. * 'templateURL':'',获取模板接口
  152. * 'fileName':'',获取文档接口
  153. * 'uploadPath':'',文档保存上传接口
  154. * }
  155. * 这个功能要求服务端传来的模板JSON数据字符串,支持三种类型定义:
  156. * text 类型:直接插入对应的书签位置
  157. * link 类型: 把对应的URL的文件插入到指定的书签位置
  158. * pic 类型: 把对应的URL的图片文件插入到指定的书签位置
  159. * @param {*} params
  160. */
  161. function GetServerTemplateData(template, pTemplateDataUrl) {
  162. //获取文档内容
  163. $.ajax({
  164. url: pTemplateDataUrl,
  165. async: false,
  166. method: "get",
  167. dataType: 'json',
  168. success: function(res) {
  169. var data = res;
  170. let Bookmarks = template.Bookmarks;
  171. data.forEach(function(it) {
  172. var bookmark = Bookmarks.Item(it.name);
  173. let bookStart = bookmark.Range.Start;
  174. let bookEnd = bookmark.Range.End;
  175. let start = template.Range().End
  176. //方案1,直接替换,手动添加书签
  177. // if (bookmark) {
  178. // if (!it.type || it.type === "text") {
  179. // bookmark.Range.Text = it.text;
  180. // } else if (it.type === "link") {
  181. // bookmark.Range.InsertFile(it.text);
  182. // } else if (it.type === "pic") {
  183. // bookmark.Range.InlineShapes.AddPicture(it.text);
  184. // }
  185. // }
  186. // let end = template.Range().End
  187. // let range=bookmark.Range;
  188. // if (!Bookmarks.Exists(bookmark.Name))
  189. // Bookmarks.Add(bookmark.Name, range.SetRange(bookStart, bookEnd + (end - start)))
  190. //方案2,不完全替换
  191. if(bookmark){
  192. if (!it.type || it.type === "text") {
  193. bookmark.Range.InsertBefore(it.text);
  194. } else if (it.type === "link") {
  195. bookmark.Range.InsertFile(it.text);
  196. } else if (it.type === "pic") {
  197. bookmark.Range.InlineShapes.AddPicture(it.text);
  198. }
  199. }
  200. var selection=wps.WpsApplication().ActiveWindow.Selection;
  201. if (bookmark.Range.Text) {
  202. selection.Start = bookmark.Range.End - (bookEnd - bookStart);
  203. selection.End = bookmark.Range.End;
  204. selection.Cut();
  205. } else {
  206. selection.Start = bookmark.Range.End;
  207. selection.End = bookmark.Range.End+it.text.length;
  208. ActiveDocument.Bookmarks.Add(bookmark.Name, selection.Range);
  209. }
  210. })
  211. }
  212. });
  213. }
  214. /**
  215. * 打开服务端的文档(不落地)
  216. * @param {*} fileUrl 文件url路径
  217. */
  218. function OpenOnLineFile(OAParams) {
  219. //OA参数如果为空的话退出
  220. if (!OAParams) return;
  221. //获取在线文档URL
  222. var l_OAFileUrl = OAParams.fileName;
  223. var l_doc;
  224. if (l_OAFileUrl) {
  225. //下载文档不落地(16版WPS的925后支持)
  226. wps.WpsApplication().Documents.OpenFromUrl(l_OAFileUrl, "OnOpenOnLineDocSuccess", "OnOpenOnLineDocDownFail");
  227. l_doc = wps.WpsApplication().ActiveDocument;
  228. }
  229. //执行文档打开后的方法
  230. pOpenFile(l_doc, OAParams, true);
  231. return l_doc;
  232. }
  233. /**
  234. * 打开在线文档成功后触发事件
  235. * @param {*} resp
  236. */
  237. function OnOpenOnLineDocSuccess(resp) {
  238. }
  239. /**
  240. * 打开在线不落地文档出现失败时,给予错误提示
  241. */
  242. function OnOpenOnLineDocDownFail(res) {
  243. var err={}
  244. try{
  245. res=JSON.parse(res)
  246. err.Body=Base64.decode(res.Body)
  247. err.Headers=Base64.decode(JSON.stringify(res.Headers))
  248. console.log(err)
  249. }catch(err){
  250. }
  251. alert("打开在线不落地文档失败!请尝试重新打开。");
  252. return;
  253. }
  254. /**
  255. * 参数:
  256. * doc : 当前OA文档的Document对象
  257. * DocLandMode : 落地模式设置
  258. */
  259. function DoSetOADocLandMode(doc, DocLandMode) {
  260. if (!doc) return;
  261. var l_Param = wps.PluginStorage.getItem(doc.DocID);
  262. var l_objParam = JSON.parse(l_Param);
  263. //增加属性,或设置
  264. l_objParam.OADocLandMode = DocLandMode; //设置OA文档的落地标志
  265. var l_p = JSON.stringify(l_objParam);
  266. //将OA文档落地模式标志存入系统变量对象保存
  267. wps.PluginStorage.setItem(doc.DocID, l_p);
  268. }
  269. /**
  270. * 作用:设置Ribbon工具条的按钮显示状态
  271. * @param {*} paramsGroups
  272. */
  273. function pDoResetRibbonGroups(paramsGroups) {
  274. }
  275. /**
  276. * 作用:打开文档处理的各种过程,包含:打开带密码的文档,保护方式打开文档,修订方式打开文档等种种情况
  277. * params Object OA Web端传来的请求JSON字符串,具体参数说明看下面数据
  278. * TempLocalFile : 字符串 先把文档从OA系统下载并保存在Temp临时目录,这个参数指已经下载下来的本地文档地址
  279. * ----------------------以下是OA参数的一些具体规范名称
  280. * docId String 文档ID
  281. * uploadPath String 保存文档接口
  282. * fileName String 获取服务器文档接口(不传即为新建空文档)
  283. * suffix String ".pdf|.uot",可传多个,用“|”分割,保存时会按照所传的值转成对应的格式文档并上传
  284. * userName String 用于更改显示修改人的用户名
  285. * strBookmarkDataPath string 书签列表 (可不传,可以在OA助手config.js中配置)
  286. * templatePath string 模板列表 (可不传,可以在OA助手config.js中配置)
  287. * buttonGroups string 自定义按钮组 (可不传,不传显示所有按钮)
  288. * revisionCtrl String 痕迹控制 ,不传正常打开
  289. * bOpenRevision String true(打开)false(关闭)修订
  290. * bShowRevision String true(显示)/false(关闭)痕迹
  291. * openType String 文档打开方式 ,不传正常打开
  292. * protectType String 文档保护类型,-1:不启用保护模式,0:只允许对现有内容进行修订,1:只允许添加批注,2:只允许修改窗体域,3:只读
  293. * password String密码
  294. */
  295. function pDoOpenOADocProcess(params, TempLocalFile) {
  296. var l_ProtectType = -1; //默认文档保护类型 -1 为不启用保护
  297. var l_ProtectPassword = ""; //默认文档密码为空
  298. var l_strDocPassword = ""; //打开文档密码参数
  299. var l_bOpenRevision = false; //初始化关闭修订模式
  300. var l_bShowRevision = false; //初始化不显示修订气泡样式
  301. for (var key = "" in params) {
  302. switch (key.toUpperCase()) //
  303. {
  304. case "userName".toUpperCase(): //修改当前文档用户名
  305. wps.WpsApplication().UserName = params[key];
  306. break;
  307. case "openType".toUpperCase():
  308. l_ProtectType = params[key].protectType; //获取OA传来的文档保护类型
  309. l_ProtectPassword = params[key].password; //获取OA传来的保护模式下的文档密码
  310. break;
  311. case "revisionCtrl".toUpperCase(): //限制修订状态
  312. l_bOpenRevision = params[key].bOpenRevision;
  313. l_bShowRevision = params[key].bShowRevision;
  314. break;
  315. case "buttonGroups".toUpperCase(): //按钮组合
  316. break;
  317. case "docPassword".toUpperCase(): //传入打开文件的密码
  318. l_strDocPassword = params[key].docPassword;
  319. break;
  320. }
  321. }
  322. var l_Doc;
  323. // Open方法的参数说明如下
  324. //Function Open(FileName, [ConfirmConversions], [ReadOnly], [AddToRecentFiles],
  325. // [PasswordDocument], [PasswordTemplate], [Revert], [WritePasswordDocument],
  326. // [WritePasswordTemplate], [Format], [Encoding], [Visible],
  327. // [OpenAndRepair], [DocumentDirection], [NoEncodingDialog], [XMLTransform]) As Document
  328. l_Doc = wps.WpsApplication().Documents.Open(TempLocalFile, false, false, false, l_strDocPassword);
  329. //设置文档修订状态
  330. DoOADocOpenRevision(l_Doc, l_bOpenRevision, l_bShowRevision);
  331. //打开文档后,根据保护类型设置文档保护
  332. if (l_ProtectType > -1) // -1 :不设置文档保护
  333. SetOADocProtect(l_Doc, l_ProtectType, l_ProtectPassword);
  334. return l_Doc;
  335. }
  336. /**
  337. * protectType: '', 文档保护模式( -1:不启用保护模式,
  338. * 0:只允许对现有内容进行修订,
  339. * 1:只允许添加批注,
  340. * 2:只允许修改窗体域,
  341. * 3:只读)
  342. * @param {*} protectType
  343. * @param {*} doc
  344. */
  345. function SetOADocProtect(doc, protectType, ProtectPassword) {
  346. if (!doc) return; //校验文档是否存在
  347. if ([0, 1, 2, 3].indexOf(protectType) !== -1) {
  348. // 保护文档如果之前有被保护,再次保护会出问题,需要先解除保护
  349. doc.Unprotect();
  350. // ** 方法参数
  351. // ** Protect(Type As WdProtectionType, [NoReset], [Password], [UseIRM], [EnforceStyleLock])
  352. doc.Protect(protectType, false, ProtectPassword, false);
  353. }
  354. return;
  355. }
  356. /**
  357. * 打开/关闭修订
  358. * @param {*} doc :传入文档对象
  359. * @param {*} bOpenRevision : 布尔值,是否允许打开修订模式,true:打开/false:关闭
  360. * @param {*} bOpenRevision : 布尔值,是否显示修订痕迹状态
  361. * 返回值:无
  362. */
  363. function DoOADocOpenRevision(doc, bOpenRevision, bShowRevision) {
  364. if (!doc) return;
  365. doc.TrackRevisions = bOpenRevision; //如果标记对指定文档的修改,则该属性值为True
  366. var l_v = doc.ActiveWindow.View;
  367. l_v.ShowRevisionsAndComments = bShowRevision; //如果为True,则 WPS 显示使用“修订”功能对文档所作的修订和批注
  368. l_v.RevisionsBalloonShowConnectingLines = bShowRevision; //如果为 True,则 WPS 显示从文本到修订和批注气球之间的连接线
  369. wps.WpsApplication().CommandBars.ExecuteMso("KsoEx_RevisionCommentModify_Disable"); //去掉修改痕迹信息框中的接受修订和拒绝修订勾叉,使其不可用
  370. if (bShowRevision) {
  371. doc.ActiveWindow.ActivePane.View.RevisionsMode = 2; //2为不支持气泡显示。
  372. }
  373. //如果关闭修订,关闭显示痕迹并将按钮至灰
  374. wps.ribbonUI.InvalidateControl("btnOpenRevision");
  375. wps.ribbonUI.InvalidateControl("btnShowRevision");
  376. return;
  377. }
  378. /**
  379. * 描述:如何处理再次打开相同的OA文件
  380. * 返回值:打开的Document对象
  381. */
  382. function pReOpenOADoc(OADocURL) {
  383. if (wps.confirm("当前环境已打开该文件,是否重新再打开一份?")) {
  384. //如果用户选择再次打开,则用在线方式打开
  385. wps.WpsApplication().Documents.OpenFromUrl(OADocURL, "", "");
  386. }
  387. }
  388. /**
  389. * 功能说明:判断是否已存在来自OA的已打开的文档
  390. * @param {字符串} FileURL
  391. */
  392. function pCheckIsExistOpenOADoc(FileURL) {
  393. var l_DocCount = wps.WpsApplication().Documents.Count;
  394. if (l_DocCount <= 0) return false;
  395. //轮询检查当前已打开的WPS文档中,是否存在OA相同的文件
  396. if (l_DocCount >= 1) {
  397. for (var l_index = 1; l_index <= l_DocCount; l_index++) {
  398. var l_objDoc = wps.WpsApplication().Documents.Item(l_index);
  399. var l_strParam = wps.PluginStorage.getItem(l_objDoc.DocID);
  400. if (l_strParam == null)
  401. continue;
  402. var l_objParam = JSON.parse(l_strParam)
  403. if (l_objParam.fileName == FileURL) {
  404. return true;
  405. }
  406. }
  407. return false;
  408. }
  409. }
  410. //Office文件打开后,设置该文件属性:从服务端来的OA文件
  411. function pSetOADocumentFlag(doc, params) {
  412. if (!doc) {
  413. return; //
  414. }
  415. var l_Param = params;
  416. l_Param.isOA = EnumOAFlag.DocFromOA; //设置OA打开文档的标志
  417. l_Param.SourcePath = doc.FullName; //保存OA的原始文件路径,用于保存时分析,是否进行了另存为操作
  418. //console.log(l_Param.SourcePath);
  419. if (doc) {
  420. var l_p = JSON.stringify(l_Param);
  421. //将OA文档标志存入系统变量对象保存
  422. wps.PluginStorage.setItem(doc.DocID, l_p);
  423. }
  424. }
  425. /**
  426. * 作用:
  427. * @param {*} suffix :文档后缀明:.pdf 或 .uot 或 .uof
  428. * @param {*} doc
  429. * @param {*} uploadPath
  430. * @param {} FieldName : 上传到服务器端的字段名称,可由OA传入的参数设置
  431. *
  432. * 返回值:是否执行了上传操作,布尔值
  433. */
  434. function handleFileAndUpload(suffix, doc, uploadPath, FieldName) {
  435. var l_strChangeFileName = ""; // 转换格式后的文件名称
  436. var l_strPath = ""; // 转换格式后的文件路径
  437. var l_FieldName = FieldName;
  438. if (!doc) {
  439. return false;
  440. }
  441. if (!l_FieldName) {
  442. l_FieldName = "file"; //默认情况下,设置为 file 字段名称
  443. }
  444. var l_DocSourcePath = doc.FullName; //保留当前文档明,在SaveAs使用后再保存回原来的文件明
  445. //Sub ExportAsFixedFormat(OutputFileName As String, ExportFormat As WdExportFormat,
  446. // [OpenAfterExport As Boolean = False],
  447. // [OptimizeFor As WdExportOptimizeFor = wdExportOptimizeForPrint],
  448. // [Range As WdExportRange = wdExportAllDocument], [From As Long = 1],
  449. // [To As Long = 1], [Item As WdExportItem = wdExportDocumentContent],
  450. // [IncludeDocProps As Boolean = False], [KeepIRM As Boolean = True],
  451. // [CreateBookmarks As WdExportCreateBookmarks = wdExportCreateNoBookmarks],
  452. // [DocStructureTags As Boolean = True], [BitmapMissingFonts As Boolean = True],
  453. // [UseISO19005_1 As Boolean = False], [FixedFormatExtClassPtr])
  454. // Const wdExportFormatPDF = 17 (&H11)
  455. // Const wdExportFormatXPS = 18 (&H12)
  456. //
  457. //根据传入的 后缀文件名称进行不同的转换文档操作
  458. switch (suffix.toLocaleLowerCase()) {
  459. case '.pdf':
  460. l_strPath = pGetValidDocTempPath(doc) + ".pdf"; //获取有效输出路径
  461. wps.FileSystem.Remove(l_strPath); //先删除之前可能存在的临时文件
  462. doc.ExportAsFixedFormat(l_strPath, wps.Enum&&wps.Enum.wdFormatPDF||17, true); //文档另存为PDF格式
  463. l_strChangeFileName = doc.Name.split(".")[0] + ".pdf";
  464. UploadFile(l_strChangeFileName, l_strPath, uploadPath, l_FieldName, OnChangeSuffixUploadSuccess, OnChangeSuffixUploadFail);
  465. break;
  466. case '.uof':
  467. l_strPath = pGetValidDocTempPath(doc) + suffix;
  468. wps.FileSystem.Remove(l_strPath); //先删除之前可能存在的临时文件
  469. doc.ExportAsFixedFormat(l_strPath, wps.Enum&&wps.Enum.wdFormatOpenDocumentText||23, true); //转换文件格式
  470. doc.SaveAs2(l_strPath);
  471. l_strChangeFileName = doc.Name.split(".")[0] + suffix;
  472. UploadFile(l_strChangeFileName, l_strPath, uploadPath, l_FieldName, OnChangeSuffixUploadSuccess, OnChangeSuffixUploadFail);
  473. doc.SaveAs2(l_DocSourcePath); //保存回原来的文档内容
  474. break;
  475. case '.uot':
  476. l_strPath = pGetValidDocTempPath(doc) + suffix;
  477. wps.FileSystem.Remove(l_strPath); //先删除之前可能存在的临时文件
  478. doc.ExportAsFixedFormat(l_strPath, wps.Enum&&wps.Enum.wdFormatOpenDocumentText||23, true);
  479. doc.SaveAs2(l_strPath);
  480. l_strChangeFileName = doc.Name.split(".")[0] + suffix;
  481. UploadFile(l_strChangeFileName, l_strPath, uploadPath, l_FieldName, OnChangeSuffixUploadSuccess, OnChangeSuffixUploadFail);
  482. doc.SaveAs2(l_DocSourcePath); //保存回原来的文档内容
  483. break;
  484. case '.ofd':
  485. l_strPath = pGetValidDocTempPath(doc) + suffix;
  486. wps.FileSystem.Remove(l_strPath); //先删除之前可能存在的临时文件
  487. doc.ExportAsFixedFormat(l_strPath, wps.Enum&&wps.Enum.wdFormatOpenDocumentText||23, true);
  488. doc.SaveAs2(l_strPath,102);
  489. l_strChangeFileName = doc.Name.split(".")[0] + suffix;
  490. UploadFile(l_strChangeFileName, l_strPath, uploadPath, l_FieldName, OnChangeSuffixUploadSuccess, OnChangeSuffixUploadFail);
  491. doc.SaveAs2(l_DocSourcePath); //保存回原来的文档内容
  492. break;
  493. default:
  494. l_strPath = pGetValidDocTempPath(doc) + suffix;
  495. wps.FileSystem.Remove(l_strPath); //先删除之前可能存在的临时文件
  496. doc.SaveAs2(l_strPath);
  497. l_strChangeFileName = doc.Name.split(".")[0] + suffix;
  498. UploadFile(l_strChangeFileName, l_strPath, uploadPath, l_FieldName, OnChangeSuffixUploadSuccess, OnChangeSuffixUploadFail);
  499. doc.SaveAs2(l_DocSourcePath); //保存回原来的文档内容
  500. break;
  501. }
  502. wps.FileSystem.Remove(l_strPath); //上载完成后,删除临时文件
  503. return true;
  504. }
  505. /**
  506. * 作用:获取一个有效的临时文档路径,用于保存转换格式后的文档
  507. * @param {*} doc
  508. */
  509. function pGetValidDocTempPath(doc) {
  510. if (!doc) {
  511. return;
  512. }
  513. if (doc.Path == "") { //对于不落地文档,文档路径为空
  514. return wps.Env.GetTempPath()+"/"+doc.Name.split(".")[0];
  515. } else {
  516. return doc.FullName.split(".")[0]
  517. }
  518. }
  519. /**
  520. * 作用:转格式保存上传成功后,触发这个事件的回调
  521. * @param {} response
  522. */
  523. function OnChangeSuffixUploadSuccess(response) {
  524. l_result = handleResultBody(response);
  525. alert("文件转格式保存成功!");
  526. }
  527. /**
  528. * 作用:转格式保存失败,触发失败事件回调
  529. * @param {*} response
  530. */
  531. function OnChangeSuffixUploadFail(response) {
  532. var l_result = "";
  533. l_result = handleResultBody(response);
  534. alert("保存失败" + "\n" + +"系统返回数据:" + +JSON.stringify(l_result));
  535. }
  536. /**
  537. * 解析返回response的参数
  538. * @param {*} resp
  539. * @return {*} body
  540. */
  541. function handleResultBody(resp) {
  542. var l_result = "";
  543. if (resp.Body) {
  544. //解析返回response的参数
  545. }
  546. return l_result;
  547. }
  548. /**
  549. * 把OA文件的当前编辑内容,自动提交到OA后台
  550. */
  551. function pAutoUploadToServer(p_Doc) {
  552. if (!p_Doc) {
  553. return;
  554. }
  555. /**
  556. * 参数定义:OAAsist.UploadFile(name, path, url, field, "OnSuccess", "OnFail")
  557. * 上传一个文件到远程服务器。
  558. * name:为上传后的文件名称;
  559. * path:是文件绝对路径;
  560. * url:为上传地址;
  561. * field:为请求中name的值;
  562. * 最后两个参数为回调函数名称;
  563. */
  564. var l_uploadPath = GetDocParamsValue(p_Doc, constStrEnum.uploadPath); // 文件上载路径
  565. if (l_uploadPath == "") {
  566. //wps.alert("系统未传入文件上载路径,不能执行上传操作!");
  567. return;
  568. }
  569. var l_FieldName = GetDocParamsValue(p_Doc, constStrEnum.uploadFieldName); //上载到后台的字段名称
  570. if (l_FieldName == "") {
  571. l_FieldName = wps.PluginStorage.getItem(constStrEnum.DefaultUploadFieldName); // 默认为‘file’
  572. }
  573. var l_UploadName = GetDocParamsValue(p_Doc, constStrEnum.uploadFileName); //设置OA传入的文件名称参数
  574. if (l_UploadName == "") {
  575. l_UploadName = p_Doc.Name; //默认文件名称就是当前文件编辑名称
  576. }
  577. var l_DocPath = p_Doc.FullName; // 文件所在路径
  578. if (pIsOnlineOADoc(p_Doc) == false) {
  579. console.log("落地文档自动保存");
  580. //对于本地磁盘文件上传OA,先用Save方法保存后,在上传
  581. //设置用户保存按钮标志,避免出现禁止OA文件保存的干扰信息
  582. wps.PluginStorage.setItem(constStrEnum.OADocUserSave, EnumDocSaveFlag.OADocSave);
  583. p_Doc.Save(); //执行一次保存方法
  584. //设置用户保存按钮标志
  585. wps.PluginStorage.setItem(constStrEnum.OADocUserSave, EnumDocSaveFlag.NoneOADocSave);
  586. //落地文档,调用UploadFile方法上传到OA后台
  587. try {
  588. //调用OA助手的上传方法
  589. UploadFile(l_UploadName, l_DocPath, l_uploadPath, l_FieldName, OnAutoUploadSuccess, OnAutoUploadFail);
  590. } catch (err) {
  591. alert("上传文件失败!请检查系统上传参数及网络环境!");
  592. }
  593. } else {
  594. console.log("不落地文档自动保存");
  595. // 不落地的文档,调用 Document 对象的不落地上传方法
  596. wps.PluginStorage.setItem(constStrEnum.OADocUserSave, EnumDocSaveFlag.OADocSave);
  597. try {
  598. //调用不落地上传方法
  599. p_Doc.SaveAsUrl(l_UploadName, l_uploadPath, l_FieldName, "OnAutoUploadSuccess", "OnAutoUploadFail");
  600. } catch (err) {}
  601. wps.PluginStorage.setItem(constStrEnum.OADocUserSave, EnumDocSaveFlag.NoneOADocSave);
  602. }
  603. }
  604. /**
  605. * 作用:自动上传到OA后台成功后出发事件
  606. */
  607. function OnAutoUploadSuccess(resp) {
  608. return;
  609. }
  610. /**
  611. * 作用:自动上传到OA后台成功后出发事件
  612. */
  613. function OnAutoUploadFail(resp) {
  614. return;
  615. }
  616. /**
  617. * 按照定时器的时间,自动执行所有文档的自动保存事件
  618. */
  619. function OnDocSaveByAutoTimer() {
  620. var l_Doc;
  621. var l_Count = 0
  622. var l_docCounts = wps.WpsApplication().Documents.Count;
  623. for (l_Count = 0; l_Count < l_docCounts; l_Count++) {
  624. l_Doc = wps.WpsApplication().Documents.Item(l_Count);
  625. if (l_Doc) {
  626. if (pCheckIfOADoc(l_Doc) == true) { // 是否为OA文件
  627. if (pISOADocReadOnly(l_Doc) == false) { // 是否为只读文档
  628. //执行自动上传到OA服务器端的操作
  629. pAutoUploadToServer(l_Doc);
  630. //保存该文档对应的访问过程记录信息
  631. }
  632. }
  633. }
  634. }
  635. }
  636. /**
  637. * 实现一个定时器
  638. */
  639. function OpenTimerRun(funcCallBack) {
  640. var l_mCount = 0; //设置一个计时器,按每分钟执行一次; 10分钟后重复执行
  641. var l_timeID = 0; //用于保存计时器ID值
  642. // 对间隔时间做处理
  643. var l_AutoSaveToServerTime = wps.PluginStorage.getItem(constStrEnum.AutoSaveToServerTime);
  644. if (l_AutoSaveToServerTime == 0) { // 设置为0则不启动定时器
  645. l_timeID = wps.PluginStorage.getItem(constStrEnum.TempTimerID);
  646. clearInterval(l_timeID);
  647. return;
  648. } else if (l_AutoSaveToServerTime < 3) {
  649. l_AutoSaveToServerTime = 3;
  650. }
  651. l_timeID = setInterval(function() {
  652. l_mCount = l_mCount + 1;
  653. if (l_mCount > l_AutoSaveToServerTime) { //l_AutoSaveToServerTime 值由系统配置时设定,见pInitParameters()函数
  654. l_mCount = 0;
  655. funcCallBack(); //每隔l_AutoSaveToServerTime 分钟(例如10分钟)执行一次回调函数
  656. }
  657. }, 60000); //60000 每隔1分钟,执行一次操作(1000*60)
  658. wps.PluginStorage.setItem(constStrEnum.TempTimerID, l_timeID); //保存计时器ID值
  659. }
  660. /**
  661. * 从OA-web端点击套红头
  662. * params : 需要存在以下参数
  663. * 'insertFileUrl':'',获取红头模板接口
  664. * 'bkInsertFile':'' ,正文书签
  665. */
  666. function InsertRedHead(params) {
  667. var wpsApp = wps.WpsApplication();
  668. var activeDoc = wpsApp.ActiveDocument;
  669. if (!activeDoc) {
  670. alert('文档不存在,请先新建一个文档!');
  671. return;
  672. }
  673. var bookmark = GetParamsValue(params, constStrEnum.bkInsertFile);
  674. var strFile = GetParamsValue(params, constStrEnum.insertFileUrl);
  675. if (strFile == "") {
  676. alert("未获取到传入的红头模板URL路径,不能正常套红");
  677. return;
  678. }
  679. if (bookmark == "") {
  680. alert("获取到传入的正文书签,不能正常套红");
  681. return;
  682. }
  683. pInsertRInedHead(activeDoc, strFile, bookmark);
  684. }
  685. /**
  686. * 套红头
  687. * doc :套红头的文档
  688. * strFile :获取红头模板接口
  689. * bookmark :,正文书签
  690. */
  691. function pInsertRInedHead(doc, strFile, bookmark) {
  692. var bookMarks = doc.Bookmarks;
  693. if (bookMarks.Item("quanwen")) { // 当前文档存在"quanwen"书签时候表示已经套过红头
  694. alert("当前文档已套过红头,请勿重复操作!");
  695. return;
  696. }
  697. var wpsApp = wps.WpsApplication();
  698. var activeDoc = wpsApp.ActiveDocument;
  699. var selection = wpsApp.ActiveWindow.Selection;
  700. // 准备以非批注的模式插入红头文件(剪切/粘贴等操作会留有痕迹,故先关闭修订)
  701. activeDoc.TrackRevisions = false;
  702. selection.WholeStory(); //选取全文
  703. bookMarks.Add("quanwen", selection.Range)
  704. selection.Cut();
  705. selection.InsertFile(strFile);
  706. if (bookMarks.Exists(bookmark)) {
  707. var bookmark1 = bookMarks.Item(bookmark);
  708. bookmark1.Range.Select(); //获取指定书签位置
  709. var s = activeDoc.ActiveWindow.Selection;
  710. s.Paste();
  711. } else {
  712. alert("套红头失败,您选择的红头模板没有对应书签:" + bookmark);
  713. }
  714. // 轮询插入书签
  715. var elements = GetDocParamsValue(doc, constStrEnum.redFileElement);
  716. if (elements != "") {
  717. for (var key in elements) {
  718. console.log(key + "----" + elements[key])
  719. if (bookMarks.Exists(key)) {
  720. // 直接插入
  721. var eleBookmark = bookMarks.Item(key);
  722. eleBookmark.Range.Text = elements[key];
  723. }
  724. }
  725. }
  726. // 恢复修订模式(根据传入参数决定)
  727. var l_revisionCtrl = GetDocParamsValue(activeDoc, constStrEnum.revisionCtrl);
  728. activeDoc.TrackRevisions = l_revisionCtrl == "" ? false : l_revisionCtrl.bOpenRevision;
  729. //取消WPS关闭时的提示信息
  730. wps.WpsApplication().DisplayAlerts = wps.Enum&&wps.Enum.wdAlertsNone||0;
  731. }
  732. /**
  733. * 从OA-web端点击套红头
  734. * doc : 需要存在以下属性
  735. * 'insertFileUrl':'',获取红头模板接口
  736. * 'bkInsertFile':'' ,正文书签
  737. */
  738. function InsertRedHeadDoc(doc) { //插入红头
  739. if (!doc) {
  740. alert('文档不存在!');
  741. return;
  742. }
  743. var bookmark = GetDocParamsValue(doc, constStrEnum.bkInsertFile);
  744. var strFile = GetDocParamsValue(doc, constStrEnum.insertFileUrl);
  745. if (strFile == "") {
  746. alert("未获取到系统传入的红头模板URL路径,不能正常套红");
  747. return;
  748. }
  749. if (bookmark == "") {
  750. alert("套红头失败,您选择的红头模板没有正文书签!");
  751. return;
  752. }
  753. pInsertRInedHead(doc, strFile, bookmark)
  754. }
  755. /**
  756. * 打开本地文档,并插入文档
  757. */
  758. function OpenLocalFile() {
  759. var l_FileName = "";
  760. //msoFileDialogFilePicker = 3
  761. var l_FileDialog = wps.WpsApplication().FileDialog(3);
  762. if (l_FileDialog.Show()) {
  763. l_FileName = l_FileDialog.SelectedItems;
  764. if (l_FileName.Count > 0) {
  765. wps.WpsApplication().Selection.InsertFile(l_FileName.Item(1));
  766. }
  767. }
  768. }
  769. /**
  770. * 作用:OA的正文备份按钮操作功能,把OA文件备份一份到指定的OA后台copyUrl路径中
  771. */
  772. function OnUploadOABackupClicked() {
  773. var doc = wps.WpsApplication().ActiveDocument;
  774. if (!doc) {
  775. alert("当前没有打开任何文档");
  776. return;
  777. }
  778. var l_copyUrl = GetDocParamsValue(doc, constStrEnum.copyUrl);
  779. var l_uploadFieldName = GetDocParamsValue(doc, constStrEnum.uploadFieldName);
  780. if (!l_copyUrl) {
  781. alert("系统未传入备份URL路径,不能执行备份!");
  782. return;
  783. }
  784. if (!l_uploadFieldName) {
  785. l_uploadFieldName = "file";
  786. }
  787. // 默认保存为新文档,走上传文档的接口
  788. UploadFile(doc.Name, doc.FullName, l_copyUrl, l_uploadFieldName, OnBackupSuccess, OnBackupFail);
  789. }
  790. /**
  791. * 备份成功后的回调
  792. */
  793. function OnBackupSuccess() {
  794. wps.alert("备份上传成功");
  795. }
  796. /**
  797. * 备份失败后的回调
  798. */
  799. function OnBackupFail() {
  800. wps.alert("备份失败");
  801. }