sunliang
/
DAYE_RDMS_CCFLOW
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '0ae4217b49'
${ noResults }
DAYE_RDMS_CCFLOW/CCFlow/.svn/pristine/cc/cca942d26bc1f35088be4c84e8b...

1085 lines
39 KiB
Plaintext
Raw Normal View History Unescape Escape

初始化代码
11 months ago
///打开来自OA端传递来的文档
function OpenDoc(OaParams) {
if (OaParams.fileName == "") {
NewFile(OaParams);
} else {
//OA传来下载文件的URL地址，调用openFile 方法打开
OpenFile(OaParams);
}
}
/* --------------------
处理方法
*/
/**
* 从OA调用传来的指令，打开本地新建文件
* @param {*} fileUrl 文件url路径
*/
function NewFile(params) {
//获取WPS Application 对象
var wpsApp = wps.WpsApplication();
wps.PluginStorage.setItem(constStrEnum.IsInCurrOADocOpen, true); //设置OA打开文档的临时状态
//判断一下isOfficialDocument是否通过公文写作打开
var doc;
if (params.isOfficialDocument) {
wps.Application.GetApplicationEx().NewOfficialDocument(); //新增使用公文写作打开的公文
doc = wpsApp.ActiveDocument;
} else {
doc = wpsApp.Documents.Add(); //新增OA端文档
}
wps.PluginStorage.setItem(constStrEnum.IsInCurrOADocOpen, false);
//检查系统临时文件目录是否能访问
if (wps.Env && wps.Env.GetTempPath) {
if (params.newFileName) {
//按OA传入的文件名称保存
doc.SaveAs2($FileName = wps.Env.GetTempPath() + "/" + params.newFileName, undefined, undefined, undefined, false);
} else {
//OA传入空文件名称，则保存成系统时间文件
if (params.isOfficialDocument) {
doc.SaveAs2($FileName = wps.Env.GetTempPath() + "/OA_" + currentTime(), 0, undefined, undefined, false);
} else {
doc.SaveAs2($FileName = wps.Env.GetTempPath() + "/OA_" + currentTime(), undefined, undefined, undefined, false);
}
}
} else {
alert("文档保存临时目录出错！不能保存新建文档！请联系系统开发商。");
}
var l_NofityURL = GetParamsValue(params, constStrEnum.notifyUrl);
if (l_NofityURL) {
NotifyToServer(l_NofityURL.replace("{?}", "1"));
}
//Office文件打开后，设置该文件属性：从服务端来的OA文件
pSetOADocumentFlag(doc, params);
//设置当前文档为 本地磁盘落地模式
DoSetOADocLandMode(doc, EnumDocLandMode.DLM_LocalDoc);
//强制执行一次Activate事件
OnWindowActivate();
wps.WpsApplication().WindowState=1;
wps.WpsApplication().Activate(); //把WPS对象置前
return doc; //返回新创建的Document对象
}
/**
* 打开服务器上的文件
* @param {*} fileUrl 文件url路径
*/
function OpenFile(params) {
var l_strFileUrl = params.fileName; //来自OA网页端的OA文件下载路径
var doc;
var l_IsOnlineDoc = false; //默认打开的是不落地文档
if (l_strFileUrl) {
//下载文档之前，判断是否已下载该文件
if (pCheckIsExistOpenOADoc(l_strFileUrl) == true) {
//如果找到相同OA地址文档，则给予提示
wps.WpsApplication().WindowState=1;
wps.WpsApplication().Activate(); //把WPS对象置前
//根据OA助手对是否允许再次打开相同文件的判断处理
var l_AllowOADocReOpen = false;
l_AllowOADocReOpen = wps.PluginStorage.getItem(constStrEnum.AllowOADocReOpen);
if (l_AllowOADocReOpen == false) {
alert("已打开相同的OA文件，请关闭之前的文件，再次打开。");
wps.WpsApplication().Activate();
return null;
} else {
//处理重复打开相同OA 文件的方法
var nDocCount = wps.WpsApplication().Documents.Count;
pReOpenOADoc(l_strFileUrl);
//重复打开的文档采用不落地的方式打开
// 不落地方式打开文档判断落地比较多，V1版本先暂时关闭
l_IsOnlineDoc = true;
var nDocCount_New = wps.WpsApplication().Documents.Count;
if (nDocCount_New > nDocCount) {
doc = wps.WpsApplication().ActiveDocument;
}
}
} else {
//如果当前没有打开文档，则另存为本地文件，再打开
if (l_strFileUrl.startWith("http")) { // 网络文档
DownloadFile(l_strFileUrl, function(path) {
if (path == "") {
alert("从服务端下载路径：" + l_strFileUrl + "\n" + "获取文件下载失败！");
return null;
}
doc = pDoOpenOADocProcess(params, path);
pOpenFile(doc, params, l_IsOnlineDoc);
});
return;
} else { //本地文档
doc = pDoOpenOADocProcess(params, l_strFileUrl);
if (doc)
doc.SaveAs2($FileName = wps.Env.GetTempPath() + "/" + doc.Name, undefined, undefined, undefined, false);
}
}
} else {
//fileURL 如果为空，则按新建OA本地文件处理
NewFile(params);
}
//如果打开pdf等其他非Office文档，则doc对象为空
if (!doc) {
return null;
}
pOpenFile(doc, params, l_IsOnlineDoc);
}
/**
* 作用：文档打开后执行的动作集合
* @param {*} doc 文档对象
* @param {*} params 前端传递的参数集合
* @param {*} isOnlineDoc 在线打开/落地打开
*/
function pOpenFile(doc, params, isOnlineDoc) {
var l_IsOnlineDoc = isOnlineDoc
//Office文件打开后，设置该文件属性：从服务端来的OA文件
pSetOADocumentFlag(doc, params)
//设置当前文档为 本地磁盘落地模式
if (l_IsOnlineDoc == true) {
DoSetOADocLandMode(doc, EnumDocLandMode.DLM_OnlineDoc);
} else {
DoSetOADocLandMode(doc, EnumDocLandMode.DLM_LocalDoc);
}
/* if (GetParamsValue(params, constStrEnum.templateDataUrl)) {
GetServerTemplateData(doc, params[constStrEnum.templateDataUrl]);
} */
if (GetParamsValue(params, constStrEnum.templateDataUrl)) {
//replaceText(doc, params[constStrEnum.templateDataUrl], params["childDatas"]);
GetServerTemplateDataJSON(doc, params[constStrEnum.templateDataUrl], params["childDatas"]);
}
if (GetParamsValue(params, constStrEnum.insertFileUrl)) {
InsertRedHeadDoc(doc);
}
var l_NofityURL = GetParamsValue(params, constStrEnum.notifyUrl);
if (l_NofityURL) {
l_NofityURL = l_NofityURL.replace("{?}", "1"); //约定：参数为1则代码打开状态
NotifyToServer(l_NofityURL);
}
//重新设置工具条按钮的显示状态
pDoResetRibbonGroups();
// 触发切换窗口事件
OnWindowActivate();
// 把WPS对象置前
wps.WpsApplication().WindowState=1;
wps.WpsApplication().Activate();
return doc;
}
/**
* 套用模板插入文字/图片/文档
* * params参数结构
* params:{
* 'docId': docId, //文档ID
* 'templateURL':'',获取模板接口
* 'fileName':'',获取文档接口
* 'uploadPath':'',文档保存上传接口
* }
* 这个功能要求服务端传来的模板JSON数据字符串，支持三种类型定义：
* text 类型：直接插入对应的书签位置
* link 类型： 把对应的URL的文件插入到指定的书签位置
* pic 类型： 把对应的URL的图片文件插入到指定的书签位置
* @param {*} params
*/
function GetServerTemplateData(template, pTemplateDataUrl) {
//获取文档内容
$.ajax({
url: pTemplateDataUrl,
async: false,
method: "get",
dataType: 'json',
success: function(res) {
var data = res;
let Bookmarks = template.Bookmarks;
data.forEach(function(it) {
var bookmark = Bookmarks.Item(it.name);
let bookStart = bookmark.Range.Start;
let bookEnd = bookmark.Range.End;
let start = template.Range().End
//方案1，直接替换，手动添加书签
// if (bookmark) {
// if (!it.type || it.type === "text") {
// bookmark.Range.Text = it.text;
// } else if (it.type === "link") {
// bookmark.Range.InsertFile(it.text);
// } else if (it.type === "pic") {
// bookmark.Range.InlineShapes.AddPicture(it.text);
// }
// }
// let end = template.Range().End
// let range=bookmark.Range;
// if (!Bookmarks.Exists(bookmark.Name))
// Bookmarks.Add(bookmark.Name, range.SetRange(bookStart, bookEnd + (end - start)))
//方案2，不完全替换
if(bookmark){
if (!it.type || it.type === "text") {
bookmark.Range.InsertBefore(it.text);
} else if (it.type === "link") {
bookmark.Range.InsertFile(it.text);
} else if (it.type === "pic") {
bookmark.Range.InlineShapes.AddPicture(it.text);
}
}
var selection=wps.WpsApplication().ActiveWindow.Selection;
if (bookmark.Range.Text) {
selection.Start = bookmark.Range.End - (bookEnd - bookStart);
selection.End = bookmark.Range.End;
selection.Cut();
} else {
selection.Start = bookmark.Range.End;
selection.End = bookmark.Range.End+it.text.length;
ActiveDocument.Bookmarks.Add(bookmark.Name, selection.Range);
}
})
}
});
}
function replaceText(template, dataJSON,childDatas) {
var selection=wps.WpsApplication().ActiveWindow.Selection;
dataJSON.forEach(function(it) {
if (!it.type || it.type === "text") {
selection.WholeStory(); //选取全文
var text = selection.Text;
var name = it.name;
var value = it.text;
var index = text.indexOf(name); // 字符出现的位置
//indexArry.push(index);
if(index !== -1) {
selection.Start = index;
selection.End = index+name.length;
//selection.Text.replace(name,value);
selection.InsertAfter(value);
selection.WholeStory(); //选取全文
text = selection.Text;
// index = text.indexOf(name); // 从字符串出现的位置的下一位置开始继续查找
}
}
})
//wps.WpsApplication().ActiveDocument.Range(0,100);
//wps.WpsApplication().ActiveDocument.Select();
}
function GetServerTemplateDataJSON(template, dataJSON,childDatas) {
var tables = Application.ActiveDocument.Tables;
for(let i = 1; i <= tables.Count; i++){
var myTable = tables.Item(1);
var data = dataJSON;
for(let i = 1; i <= myTable.Range.Cells.Count; i++){
var cell = myTable.Range.Cells.Item(i);
data.forEach(function(it) {
var name = it.name;
var value=it.text;
let myRange = cell.Range;
myRange.SetRange(myRange.Start , myRange.End-1);
if(myRange.Text==name){
myRange.Text = value;
}
})
}
}
//let myTable = Application.ActiveDocument.Tables.Item(1);
let Bookmarks = template.Bookmarks;
dataJSON.forEach(function(it) {
var bookmark = Bookmarks.Item(it.name);
var t=0;
while(true){
var named=it.name;
if(t!=0){
named=it.name+"_"+t;
}
t++;
if(Bookmarks.Exists(named) === true) {
bookmark = Bookmarks.Item(named);
let bookStart = bookmark.Range.Start;
let bookEnd = bookmark.Range.End;
let start = template.Range().End
if (!it.type || it.type === "text") {
bookmark.Range.Text = it.text;
} else if (it.type === "link") {
bookmark.Range.InsertFile(it.text);
} else if (it.type === "pic") {
bookmark.Range.InlineShapes.AddPicture(it.text);
}
let end = template.Range().End
let range=bookmark.Range;
if (!Bookmarks.Exists(bookmark.Name))
Bookmarks.Add(bookmark.Name, range.SetRange(bookStart, bookEnd + (end - start)))
}else{
break;
}
}
})
if(childDatas){
//多个从表
for(var j=0;j<childDatas.length;j++){
//console.log("ddd"+j)
createChildTable(childDatas[j],j);
}
}
}
/* 从表 */
function createChildTable(ChildData,NumTable){
var data = ChildData;
var tables = Application.ActiveDocument.Tables;
var tblNew = tables.Item(NumTable+2);
tblNew.Rows.Item(2).Range.Copy();
/* tblNew.Rows.Add(tblNew.Rows.Item(3));
var mRange = tblNew.Rows.Item(3).Range;
mRange.Paste(); */
for(j=0;j<data.length;j++){
var json = data[j];
let rowNew = tblNew.Rows.Add(tblNew.Rows.Item(j+3));
var mRange = tblNew.Rows.Item(j+3).Range;
mRange.Paste();
for(i = 1; i <= rowNew.Cells.Count; ++i)
{
let celTable = rowNew.Cells.Item(i);
if(i==1){
celTable.Range.Text= j+1;
}else{
let myRange = celTable.Range;
myRange.SetRange(myRange.Start , myRange.End-1);
var value = json[myRange.Text];
if(value){
myRange.Text= value;
}
}
}
}
tblNew.Rows.Item(2).Delete();
}
/**
* 打开服务端的文档（不落地）
* @param {*} fileUrl 文件url路径
*/
function OpenOnLineFile(OAParams) {
//OA参数如果为空的话退出
if (!OAParams) return;
//获取在线文档URL
var l_OAFileUrl = OAParams.fileName;
var l_doc;
if (l_OAFileUrl) {
//下载文档不落地（16版WPS的925后支持）
wps.WpsApplication().Documents.OpenFromUrl(l_OAFileUrl, "OnOpenOnLineDocSuccess", "OnOpenOnLineDocDownFail");
l_doc = wps.WpsApplication().ActiveDocument;
}
//执行文档打开后的方法
pOpenFile(l_doc, OAParams, true);
return l_doc;
}
/**
* 打开在线文档成功后触发事件
* @param {*} resp
*/
function OnOpenOnLineDocSuccess(resp) {
}
/**
* 打开在线不落地文档出现失败时，给予错误提示
*/
function OnOpenOnLineDocDownFail(res) {
var err={}
try{
res=JSON.parse(res)
err.Body=Base64.decode(res.Body)
err.Headers=Base64.decode(JSON.stringify(res.Headers))
console.log(err)
}catch(err){
}
alert("打开在线不落地文档失败！请尝试重新打开。");
return;
}
/**
* 参数：
* doc : 当前OA文档的Document对象
* DocLandMode ： 落地模式设置
*/
function DoSetOADocLandMode(doc, DocLandMode) {
if (!doc) return;
var l_Param = wps.PluginStorage.getItem(doc.DocID);
var l_objParam = JSON.parse(l_Param);
//增加属性，或设置
l_objParam.OADocLandMode = DocLandMode; //设置OA文档的落地标志
var l_p = JSON.stringify(l_objParam);
//将OA文档落地模式标志存入系统变量对象保存
wps.PluginStorage.setItem(doc.DocID, l_p);
}
/**
* 作用：设置Ribbon工具条的按钮显示状态
* @param {*} paramsGroups
*/
function pDoResetRibbonGroups(paramsGroups) {
}
/**
* 作用：打开文档处理的各种过程，包含：打开带密码的文档，保护方式打开文档，修订方式打开文档等种种情况
* params Object OA Web端传来的请求JSON字符串，具体参数说明看下面数据
* TempLocalFile : 字符串 先把文档从OA系统下载并保存在Temp临时目录，这个参数指已经下载下来的本地文档地址
* ----------------------以下是OA参数的一些具体规范名称
* docId String 文档ID
* uploadPath String 保存文档接口
* fileName String 获取服务器文档接口（不传即为新建空文档）
* suffix String ".pdf|.uot"，可传多个，用“|”分割，保存时会按照所传的值转成对应的格式文档并上传
* userName String 用于更改显示修改人的用户名
* strBookmarkDataPath string 书签列表 (可不传，可以在OA助手config.js中配置)
* templatePath string 模板列表 (可不传，可以在OA助手config.js中配置)
* buttonGroups string 自定义按钮组 （可不传，不传显示所有按钮）
* revisionCtrl String 痕迹控制 ，不传正常打开
* bOpenRevision String true(打开)false(关闭)修订
* bShowRevision String true(显示)/false(关闭)痕迹
* openType String 文档打开方式 ，不传正常打开
* protectType String 文档保护类型，-1：不启用保护模式，0：只允许对现有内容进行修订，1：只允许添加批注，2：只允许修改窗体域，3：只读
* password String密码
*/
function pDoOpenOADocProcess(params, TempLocalFile) {
var l_ProtectType = -1; //默认文档保护类型 -1 为不启用保护
var l_ProtectPassword = ""; //默认文档密码为空
var l_strDocPassword = ""; //打开文档密码参数
var l_bOpenRevision = false; //初始化关闭修订模式
var l_bShowRevision = false; //初始化不显示修订气泡样式
for (var key = "" in params) {
switch (key.toUpperCase()) //
{
case "userName".toUpperCase(): //修改当前文档用户名
wps.WpsApplication().UserName = params[key];
break;
case "openType".toUpperCase():
l_ProtectType = params[key].protectType; //获取OA传来的文档保护类型
l_ProtectPassword = params[key].password; //获取OA传来的保护模式下的文档密码
break;
case "revisionCtrl".toUpperCase(): //限制修订状态
l_bOpenRevision = params[key].bOpenRevision;
l_bShowRevision = params[key].bShowRevision;
break;
case "buttonGroups".toUpperCase(): //按钮组合
break;
case "docPassword".toUpperCase(): //传入打开文件的密码
l_strDocPassword = params[key].docPassword;
break;
}
}
var l_Doc;
// Open方法的参数说明如下
//Function Open(FileName, [ConfirmConversions], [ReadOnly], [AddToRecentFiles],
// [PasswordDocument], [PasswordTemplate], [Revert], [WritePasswordDocument],
// [WritePasswordTemplate], [Format], [Encoding], [Visible],
// [OpenAndRepair], [DocumentDirection], [NoEncodingDialog], [XMLTransform]) As Document
l_Doc = wps.WpsApplication().Documents.Open(TempLocalFile, false, false, false, l_strDocPassword);
//设置文档修订状态
DoOADocOpenRevision(l_Doc, l_bOpenRevision, l_bShowRevision);
//打开文档后，根据保护类型设置文档保护
if (l_ProtectType > -1) // -1 :不设置文档保护
SetOADocProtect(l_Doc, l_ProtectType, l_ProtectPassword);
return l_Doc;
}
/**
* protectType: '', 文档保护模式( -1：不启用保护模式，
* 0：只允许对现有内容进行修订，
* 1：只允许添加批注，
* 2：只允许修改窗体域，
* 3：只读)
* @param {*} protectType
* @param {*} doc
*/
function SetOADocProtect(doc, protectType, ProtectPassword) {
if (!doc) return; //校验文档是否存在
if ([0, 1, 2, 3].indexOf(protectType) !== -1) {
// 保护文档如果之前有被保护，再次保护会出问题，需要先解除保护
doc.Unprotect();
// ** 方法参数
// ** Protect(Type As WdProtectionType, [NoReset], [Password], [UseIRM], [EnforceStyleLock])
doc.Protect(protectType, false, ProtectPassword, false);
}
return;
}
/**
* 打开/关闭修订
* @param {*} doc :传入文档对象
* @param {*} bOpenRevision : 布尔值，是否允许打开修订模式，true:打开/false:关闭
* @param {*} bOpenRevision ： 布尔值，是否显示修订痕迹状态
* 返回值：无
*/
function DoOADocOpenRevision(doc, bOpenRevision, bShowRevision) {
if (!doc) return;
doc.TrackRevisions = bOpenRevision; //如果标记对指定文档的修改，则该属性值为True
var l_v = doc.ActiveWindow.View;
l_v.ShowRevisionsAndComments = bShowRevision; //如果为True，则 WPS 显示使用“修订”功能对文档所作的修订和批注
l_v.RevisionsBalloonShowConnectingLines = bShowRevision; //如果为 True，则 WPS 显示从文本到修订和批注气球之间的连接线
wps.WpsApplication().CommandBars.ExecuteMso("KsoEx_RevisionCommentModify_Disable"); //去掉修改痕迹信息框中的接受修订和拒绝修订勾叉，使其不可用
if (bShowRevision) {
doc.ActiveWindow.ActivePane.View.RevisionsMode = 2; //2为不支持气泡显示。
}
//如果关闭修订,关闭显示痕迹并将按钮至灰
wps.ribbonUI.InvalidateControl("btnOpenRevision");
wps.ribbonUI.InvalidateControl("btnShowRevision");
return;
}
/**
* 描述：如何处理再次打开相同的OA文件
* 返回值：打开的Document对象
*/
function pReOpenOADoc(OADocURL) {
if (wps.confirm("当前环境已打开该文件，是否重新再打开一份？")) {
//如果用户选择再次打开，则用在线方式打开
wps.WpsApplication().Documents.OpenFromUrl(OADocURL, "", "");
}
}
/**
* 功能说明：判断是否已存在来自OA的已打开的文档
* @param {字符串} FileURL
*/
function pCheckIsExistOpenOADoc(FileURL) {
var l_DocCount = wps.WpsApplication().Documents.Count;
if (l_DocCount <= 0) return false;
//轮询检查当前已打开的WPS文档中，是否存在OA相同的文件
if (l_DocCount >= 1) {
for (var l_index = 1; l_index <= l_DocCount; l_index++) {
var l_objDoc = wps.WpsApplication().Documents.Item(l_index);
var l_strParam = wps.PluginStorage.getItem(l_objDoc.DocID);
if (l_strParam == null)
continue;
var l_objParam = JSON.parse(l_strParam)
if (l_objParam.fileName == FileURL) {
return true;
}
}
return false;
}
}
//Office文件打开后，设置该文件属性：从服务端来的OA文件
function pSetOADocumentFlag(doc, params) {
if (!doc) {
return; //
}
var l_Param = params;
l_Param.isOA = EnumOAFlag.DocFromOA; //设置OA打开文档的标志
l_Param.SourcePath = doc.FullName; //保存OA的原始文件路径，用于保存时分析，是否进行了另存为操作
//console.log(l_Param.SourcePath);
if (doc) {
var l_p = JSON.stringify(l_Param);
//将OA文档标志存入系统变量对象保存
wps.PluginStorage.setItem(doc.DocID, l_p);
}
}
/**
* 作用：
* @param {*} suffix ：文档后缀明：.pdf 或 .uot 或 .uof
* @param {*} doc
* @param {*} uploadPath
* @param {} FieldName ： 上传到服务器端的字段名称，可由OA传入的参数设置
*
* 返回值：是否执行了上传操作，布尔值
*/
function handleFileAndUpload(suffix, doc, uploadPath, FieldName) {
var l_strChangeFileName = ""; // 转换格式后的文件名称
var l_strPath = ""; // 转换格式后的文件路径
var l_FieldName = FieldName;
if (!doc) {
return false;
}
if (!l_FieldName) {
l_FieldName = "file"; //默认情况下，设置为 file 字段名称
}
var l_DocSourcePath = doc.FullName; //保留当前文档明，在SaveAs使用后再保存回原来的文件明
//Sub ExportAsFixedFormat(OutputFileName As String, ExportFormat As WdExportFormat,
// [OpenAfterExport As Boolean = False],
// [OptimizeFor As WdExportOptimizeFor = wdExportOptimizeForPrint],
// [Range As WdExportRange = wdExportAllDocument], [From As Long = 1],
// [To As Long = 1], [Item As WdExportItem = wdExportDocumentContent],
// [IncludeDocProps As Boolean = False], [KeepIRM As Boolean = True],
// [CreateBookmarks As WdExportCreateBookmarks = wdExportCreateNoBookmarks],
// [DocStructureTags As Boolean = True], [BitmapMissingFonts As Boolean = True],
// [UseISO19005_1 As Boolean = False], [FixedFormatExtClassPtr])
// Const wdExportFormatPDF = 17 (&H11)
// Const wdExportFormatXPS = 18 (&H12)
//
//根据传入的 后缀文件名称进行不同的转换文档操作
switch (suffix.toLocaleLowerCase()) {
case '.pdf':
l_strPath = pGetValidDocTempPath(doc) + ".pdf"; //获取有效输出路径
wps.FileSystem.Remove(l_strPath); //先删除之前可能存在的临时文件
doc.ExportAsFixedFormat(l_strPath, wps.Enum&&wps.Enum.wdFormatPDF||17, true); //文档另存为PDF格式
l_strChangeFileName = doc.Name.split(".")[0] + ".pdf";
UploadFile(l_strChangeFileName, l_strPath, uploadPath, l_FieldName, OnChangeSuffixUploadSuccess, OnChangeSuffixUploadFail);
break;
case '.uof':
l_strPath = pGetValidDocTempPath(doc) + suffix;
wps.FileSystem.Remove(l_strPath); //先删除之前可能存在的临时文件
doc.ExportAsFixedFormat(l_strPath, wps.Enum&&wps.Enum.wdFormatOpenDocumentText||23, true); //转换文件格式
doc.SaveAs2(l_strPath);
l_strChangeFileName = doc.Name.split(".")[0] + suffix;
UploadFile(l_strChangeFileName, l_strPath, uploadPath, l_FieldName, OnChangeSuffixUploadSuccess, OnChangeSuffixUploadFail);
doc.SaveAs2(l_DocSourcePath); //保存回原来的文档内容
break;
case '.uot':
l_strPath = pGetValidDocTempPath(doc) + suffix;
wps.FileSystem.Remove(l_strPath); //先删除之前可能存在的临时文件
doc.ExportAsFixedFormat(l_strPath, wps.Enum&&wps.Enum.wdFormatOpenDocumentText||23, true);
doc.SaveAs2(l_strPath);
l_strChangeFileName = doc.Name.split(".")[0] + suffix;
UploadFile(l_strChangeFileName, l_strPath, uploadPath, l_FieldName, OnChangeSuffixUploadSuccess, OnChangeSuffixUploadFail);
doc.SaveAs2(l_DocSourcePath); //保存回原来的文档内容
break;
case '.ofd':
l_strPath = pGetValidDocTempPath(doc) + suffix;
wps.FileSystem.Remove(l_strPath); //先删除之前可能存在的临时文件
doc.ExportAsFixedFormat(l_strPath, wps.Enum&&wps.Enum.wdFormatOpenDocumentText||23, true);
doc.SaveAs2(l_strPath,102);
l_strChangeFileName = doc.Name.split(".")[0] + suffix;
UploadFile(l_strChangeFileName, l_strPath, uploadPath, l_FieldName, OnChangeSuffixUploadSuccess, OnChangeSuffixUploadFail);
doc.SaveAs2(l_DocSourcePath); //保存回原来的文档内容
break;
default:
l_strPath = pGetValidDocTempPath(doc) + suffix;
wps.FileSystem.Remove(l_strPath); //先删除之前可能存在的临时文件
doc.SaveAs2(l_strPath);
l_strChangeFileName = doc.Name.split(".")[0] + suffix;
UploadFile(l_strChangeFileName, l_strPath, uploadPath, l_FieldName, OnChangeSuffixUploadSuccess, OnChangeSuffixUploadFail);
doc.SaveAs2(l_DocSourcePath); //保存回原来的文档内容
break;
}
wps.FileSystem.Remove(l_strPath); //上载完成后，删除临时文件
return true;
}
/**
* 作用：获取一个有效的临时文档路径，用于保存转换格式后的文档
* @param {*} doc
*/
function pGetValidDocTempPath(doc) {
if (!doc) {
return;
}
if (doc.Path == "") { //对于不落地文档，文档路径为空
return wps.Env.GetTempPath()+"/"+doc.Name.split(".")[0];
} else {
return doc.FullName.split(".")[0]
}
}
/**
* 作用：转格式保存上传成功后，触发这个事件的回调
* @param {} response
*/
function OnChangeSuffixUploadSuccess(response) {
l_result = handleResultBody(response);
alert("文件转格式保存成功！");
}
/**
* 作用：转格式保存失败，触发失败事件回调
* @param {*} response
*/
function OnChangeSuffixUploadFail(response) {
var l_result = "";
l_result = handleResultBody(response);
alert("保存失败" + "\n" + +"系统返回数据：" + +JSON.stringify(l_result));
}
/**
* 解析返回response的参数
* @param {*} resp
* @return {*} body
*/
function handleResultBody(resp) {
var l_result = "";
if (resp.Body) {
//解析返回response的参数
}
return l_result;
}
/**
* 把OA文件的当前编辑内容，自动提交到OA后台
*/
function pAutoUploadToServer(p_Doc) {
if (!p_Doc) {
return;
}
/**
* 参数定义：OAAsist.UploadFile(name, path, url, field, "OnSuccess", "OnFail")
* 上传一个文件到远程服务器。
* name：为上传后的文件名称；
* path：是文件绝对路径；
* url：为上传地址；
* field：为请求中name的值；
* 最后两个参数为回调函数名称；
*/
var l_uploadPath = GetDocParamsValue(p_Doc, constStrEnum.uploadPath); // 文件上载路径
if (l_uploadPath == "") {
//wps.alert("系统未传入文件上载路径，不能执行上传操作！");
return;
}
var l_FieldName = GetDocParamsValue(p_Doc, constStrEnum.uploadFieldName); //上载到后台的字段名称
if (l_FieldName == "") {
l_FieldName = wps.PluginStorage.getItem(constStrEnum.DefaultUploadFieldName); // 默认为‘file’
}
var l_UploadName = GetDocParamsValue(p_Doc, constStrEnum.uploadFileName); //设置OA传入的文件名称参数
if (l_UploadName == "") {
l_UploadName = p_Doc.Name; //默认文件名称就是当前文件编辑名称
}
var l_DocPath = p_Doc.FullName; // 文件所在路径
if (pIsOnlineOADoc(p_Doc) == false) {
console.log("落地文档自动保存");
//对于本地磁盘文件上传OA，先用Save方法保存后，在上传
//设置用户保存按钮标志，避免出现禁止OA文件保存的干扰信息
wps.PluginStorage.setItem(constStrEnum.OADocUserSave, EnumDocSaveFlag.OADocSave);
p_Doc.Save(); //执行一次保存方法
//设置用户保存按钮标志
wps.PluginStorage.setItem(constStrEnum.OADocUserSave, EnumDocSaveFlag.NoneOADocSave);
//落地文档，调用UploadFile方法上传到OA后台
try {
//调用OA助手的上传方法
UploadFile(l_UploadName, l_DocPath, l_uploadPath, l_FieldName, OnAutoUploadSuccess, OnAutoUploadFail);
} catch (err) {
alert("上传文件失败！请检查系统上传参数及网络环境！");
}
} else {
console.log("不落地文档自动保存");
// 不落地的文档，调用 Document 对象的不落地上传方法
wps.PluginStorage.setItem(constStrEnum.OADocUserSave, EnumDocSaveFlag.OADocSave);
try {
//调用不落地上传方法
p_Doc.SaveAsUrl(l_UploadName, l_uploadPath, l_FieldName, "OnAutoUploadSuccess", "OnAutoUploadFail");
} catch (err) {}
wps.PluginStorage.setItem(constStrEnum.OADocUserSave, EnumDocSaveFlag.NoneOADocSave);
}
}
/**
* 作用：自动上传到OA后台成功后出发事件
*/
function OnAutoUploadSuccess(resp) {
return;
}
/**
* 作用：自动上传到OA后台成功后出发事件
*/
function OnAutoUploadFail(resp) {
return;
}
/**
* 按照定时器的时间，自动执行所有文档的自动保存事件
*/
function OnDocSaveByAutoTimer() {
var l_Doc;
var l_Count = 0
var l_docCounts = wps.WpsApplication().Documents.Count;
for (l_Count = 0; l_Count < l_docCounts; l_Count++) {
l_Doc = wps.WpsApplication().Documents.Item(l_Count);
if (l_Doc) {
if (pCheckIfOADoc(l_Doc) == true) { // 是否为OA文件
if (pISOADocReadOnly(l_Doc) == false) { // 是否为只读文档
//执行自动上传到OA服务器端的操作
pAutoUploadToServer(l_Doc);
//保存该文档对应的访问过程记录信息
}
}
}
}
}
/**
* 实现一个定时器
*/
function OpenTimerRun(funcCallBack) {
var l_mCount = 0; //设置一个计时器，按每分钟执行一次; 10分钟后重复执行
var l_timeID = 0; //用于保存计时器ID值
// 对间隔时间做处理
var l_AutoSaveToServerTime = wps.PluginStorage.getItem(constStrEnum.AutoSaveToServerTime);
if (l_AutoSaveToServerTime == 0) { // 设置为0则不启动定时器
l_timeID = wps.PluginStorage.getItem(constStrEnum.TempTimerID);
clearInterval(l_timeID);
return;
} else if (l_AutoSaveToServerTime < 3) {
l_AutoSaveToServerTime = 3;
}
l_timeID = setInterval(function() {
l_mCount = l_mCount + 1;
if (l_mCount > l_AutoSaveToServerTime) { //l_AutoSaveToServerTime 值由系统配置时设定，见pInitParameters()函数
l_mCount = 0;
funcCallBack(); //每隔l_AutoSaveToServerTime 分钟（例如10分钟）执行一次回调函数
}
}, 60000); //60000 每隔1分钟，执行一次操作(1000*60)
wps.PluginStorage.setItem(constStrEnum.TempTimerID, l_timeID); //保存计时器ID值
}
/**
* 从OA-web端点击套红头
* params : 需要存在以下参数
* 'insertFileUrl':'',获取红头模板接口
* 'bkInsertFile':'' ,正文书签
*/
function InsertRedHead(params) {
var wpsApp = wps.WpsApplication();
var activeDoc = wpsApp.ActiveDocument;
if (!activeDoc) {
alert('文档不存在，请先新建一个文档!');
return;
}
var bookmark = GetParamsValue(params, constStrEnum.bkInsertFile);
var strFile = GetParamsValue(params, constStrEnum.insertFileUrl);
if (strFile == "") {
alert("未获取到传入的红头模板URL路径，不能正常套红");
return;
}
if (bookmark == "") {
alert("获取到传入的正文书签，不能正常套红");
return;
}
pInsertRInedHead(activeDoc, strFile, bookmark);
}
/**
* 套红头
* doc ：套红头的文档
* strFile ：获取红头模板接口
* bookmark ：,正文书签
*/
function pInsertRInedHead(doc, strFile, bookmark) {
var bookMarks = doc.Bookmarks;
if (bookMarks.Item("quanwen")) { // 当前文档存在"quanwen"书签时候表示已经套过红头
alert("当前文档已套过红头，请勿重复操作!");
return;
}
var wpsApp = wps.WpsApplication();
var activeDoc = wpsApp.ActiveDocument;
var selection = wpsApp.ActiveWindow.Selection;
// 准备以非批注的模式插入红头文件(剪切/粘贴等操作会留有痕迹,故先关闭修订)
activeDoc.TrackRevisions = false;
selection.WholeStory(); //选取全文
bookMarks.Add("quanwen", selection.Range)
selection.Cut();
selection.InsertFile(strFile);
if (bookMarks.Exists(bookmark)) {
var bookmark1 = bookMarks.Item(bookmark);
bookmark1.Range.Select(); //获取指定书签位置
var s = activeDoc.ActiveWindow.Selection;
s.Paste();
} else {
alert("套红头失败，您选择的红头模板没有对应书签：" + bookmark);
}
// 轮询插入书签
var elements = GetDocParamsValue(doc, constStrEnum.redFileElement);
if (elements != "") {
for (var key in elements) {
console.log(key + "----" + elements[key])
if (bookMarks.Exists(key)) {
// 直接插入
var eleBookmark = bookMarks.Item(key);
eleBookmark.Range.Text = elements[key];
}
}
}
// 恢复修订模式(根据传入参数决定)
var l_revisionCtrl = GetDocParamsValue(activeDoc, constStrEnum.revisionCtrl);
activeDoc.TrackRevisions = l_revisionCtrl == "" ? false : l_revisionCtrl.bOpenRevision;
//取消WPS关闭时的提示信息
wps.WpsApplication().DisplayAlerts = wps.Enum&&wps.Enum.wdAlertsNone||0;
}
/**
* 从OA-web端点击套红头
* doc : 需要存在以下属性
* 'insertFileUrl':'',获取红头模板接口
* 'bkInsertFile':'' ,正文书签
*/
function InsertRedHeadDoc(doc) { //插入红头
if (!doc) {
alert('文档不存在!');
return;
}
var bookmark = GetDocParamsValue(doc, constStrEnum.bkInsertFile);
var strFile = GetDocParamsValue(doc, constStrEnum.insertFileUrl);
if (strFile == "") {
alert("未获取到系统传入的红头模板URL路径，不能正常套红");
return;
}
if (bookmark == "") {
alert("套红头失败，您选择的红头模板没有正文书签！");
return;
}
pInsertRInedHead(doc, strFile, bookmark)
}
/**
* 打开本地文档，并插入文档
*/
function OpenLocalFile() {
var l_FileName = "";
//msoFileDialogFilePicker = 3
var l_FileDialog = wps.WpsApplication().FileDialog(3);
if (l_FileDialog.Show()) {
l_FileName = l_FileDialog.SelectedItems;
if (l_FileName.Count > 0) {
wps.WpsApplication().Selection.InsertFile(l_FileName.Item(1));
}
}
}
/**
* 作用：OA的正文备份按钮操作功能，把OA文件备份一份到指定的OA后台copyUrl路径中
*/
function OnUploadOABackupClicked() {
var doc = wps.WpsApplication().ActiveDocument;
if (!doc) {
alert("当前没有打开任何文档");
return;
}
var l_copyUrl = GetDocParamsValue(doc, constStrEnum.copyUrl);
var l_uploadFieldName = GetDocParamsValue(doc, constStrEnum.uploadFieldName);
if (!l_copyUrl) {
alert("系统未传入备份URL路径，不能执行备份！");
return;
}
if (!l_uploadFieldName) {
l_uploadFieldName = "file";
}
// 默认保存为新文档，走上传文档的接口
UploadFile(doc.Name, doc.FullName, l_copyUrl, l_uploadFieldName, OnBackupSuccess, OnBackupFail);
}
/**
* 备份成功后的回调
*/
function OnBackupSuccess() {
wps.alert("备份上传成功");
}
/**
* 备份失败后的回调
*/
function OnBackupFail() {
wps.alert("备份失败");
}
/* commen */
/**
* WPS下载文件到本地打开（业务系统可根据实际情况进行修改）
* @param {*} url 文件流的下载路径
* @param {*} callback 下载后的回调
*/
function DownloadFile(url, callback) {
var xhr = new XMLHttpRequest();
xhr.onreadystatechange = function () {
if (this.readyState == 4 && this.status == 200) {
//需要业务系统的服务端在传递文件流时，确保请求中的参数有filename
var fileName = pGetFileName(xhr, url)
//落地打开模式下，WPS会将文件下载到本地的临时目录，在关闭后会进行清理
var path = wps.Env.GetTempPath() + "/" + fileName
var reader = new FileReader();
reader.onload = function () {
wps.FileSystem.writeAsBinaryString(path, reader.result);
callback(path);
};
reader.readAsBinaryString(xhr.response);
}
}
xhr.open('GET', url);
xhr.responseType = 'blob';
xhr.send();
}