https://www.emscience.org/style/js/rhhz.js?t=1785223320829

1/**
2 * rhhz.js ---仁和软件前端插件js集合
3 * tools{
4 * 	subTextMax:文本内容按长度设置截取,
5 * 	menuView:按照页面设置进行页面菜单对应高亮
6 * }
7 * function{
8 * 	hasChinese:判断当前对象中是否包含中文字符,
9 * 	trim:解决IE 对jquery Trim方法的兼容性,
10 * 	startWith:判断当前对象是否以字符开始,
11 * 	endWith:判断字符串是否以字符结束,
12 *  getFileUrl:获取本地资源文件的路径,
13 *  preImg:预览本地图片,
14 *  getUrlParam:获取URL参数列表,
15 *  getRefSupIndex:获取参考文献引用索引,
16 *  isNull:判断对象是否为空,
17 *  formatDateToEn:将日期转换成英文格式 2016-1-1 --> 01 Jan 2016
18 *  GetRandomNum:获取随机数
19 *  dateStr:获取网页顶部显示需要的日期信息 参数，type 1:中文  2英文 3英文简写 （ 2017-1-11 星期三;  Wednesday, 11 January, 2017 ;Jan 20th, Wednesday
20 * 	shareTools(type,obj):分享工具，qzone,sina,weixin,renren,google+,facebook,linkedin,twitter
21 * }
22 * 
23 * @version     v1.0
24 * @date 		2016-09-30
25 */
26
27+function ($) {
28    //设置字符串截取默认参数
29    var subTextDefaluts = {
30        add_title: true,      //默认截取后设置全内容title
31        trim: true,//默认截取后去除首尾空及换行，感觉没啥用，后面考虑取消
32        content_type: 'html',//默认处理内容为html标签，如设置为text会清除原有标签
33        keep_len: 10//默认截取保留10个字符，建议采用配置方式或者在标签中设置
34    };
35
36    //设置菜单高亮默认参数
37    var menuDefaults = {
38        defaultPage: 'index',			//默认获取不到页面索引，设置为首页
39        pageViewId: 'pageViewId',		//页面索引取值ID
40        hightLightTag: 'li',				//需要设置高亮的标签
41        highLightClass: 'current',		//当前页选中高亮class
42        pageRelAttr: 'rel_page',			//菜单列表中索引属性标识
43        pageRelTag: 'li span'			//菜单列表中索引取值标签，默认取text().trim(),pageRelTag和pageRelAttr不需要同时存在
44    }
45
46    $.fn.subTextMax = function (options) {
47        var opts = $.extend({}, subTextDefaluts, options);
48        return this.each(function () {
49            var keepindex = parseInt($(this).attr("keep_len") == undefined ? opts.keep_len : $(this).attr("keep_len"));//超出keep值需要截取
50            var contentHtml = $(this).html().replace(/&nbsp;/ig, '').replace(/\s+/g, ' ').replace(/\t|\r|\n/g, "").replace('<sec> <b>', '<sec><b>').replace(/<br[ ]*[/]{0,1}>/g, "<br/>").trim();
51            //var contentText = $(this).text().replace(/&nbsp;/ig, '').replace(/\s+/g, ' ').replace(/\t|\r|\n/g,"").trim();
52            var contentText = filterHTMLTag(contentHtml);
53
54            if (contentText.length > keepindex) {
55                //如果需要，可加title，title为全部文本内容
56                if (opts.add_title) {
57                    if ($(this).attr("title") == '' || $(this).attr("title") == undefined) {
58                        $(this).attr("title", contentText);
59                    }
60                }
61                contentText = contentText.substr(0, keepindex);
62                if (opts.content_type == 'text') {
63                    $(this).html(contentText + "...");
64                } else {
65                    //对HTML标签内容进行截取分为四个步骤1存储原有标签  2按照text进行截取  3对截取后的text进行标签插入  4补全未闭合标签
66                    //1.处理原有标签
67                    //获取当前内容中的各个标签及所在位置
68                    var rgx = /<[^<^>]+>/; //标签匹配正则
69                    var index = 0;
70                    var tags = new Array();
71                    while (rgx.test(contentHtml)) {
72                        var t = new Object();
73                        //标签出现的位置
74                        t.index = index + contentHtml.search(rgx);
75                        //标签内容
76                        t.tag = contentHtml.match(rgx).toString();

77                        //每次匹配第一个标签，匹配完删除此标签，同时索引位置加当前标签的长度
78                        var len = contentHtml.search(/<[^<^>]+>/) + contentHtml.match(/<[^<^>]+>/)[0].length;
79                        contentHtml = contentHtml.substr(len);
80                        index += len;
81                        tags.push(t);
82                    }
83                    //2.截取text内容，上面已经截取过了
84                    //3.填充原有标签
85                    if (tags.length > 0) {
86                        $.each(tags, function (i, e) {
87                            if (e.index > contentText.length) {
88                                //如果当前节点的开始位置大于当前返回字符串的长度则不再继续判断
89                                tags = tags.slice(0, i);
90                                return false;
91                            } else {
92                                //将原有标签插入原位置
93                                contentText = contentText.substr(0, e.index) + e.tag + contentText.substr(e.index, contentText.length);
94                            }
95                        })
96                    }
97                    //4.闭合标签
98                    //获取未闭合标签，标签填充时不需要填充的标签都被slice过滤掉了，所以剩下的都是已经在内容中的标签了，需要进行判断闭合处理
99                    var insertTags = new Array();//已正确插入标签
100                    var uncloseTags = new Array();//未闭合标签
101                    if (tags.length > 0) {
102                        $.each(tags, function (i, e) {
103                            //先将所有插入的标签放到插入和未闭合列表中
104                            uncloseTags.push(e.tag);
105                            insertTags.push(e.tag);
106                        })
107                        $.each(insertTags, function (i, e) {
108                            //自闭合标签不需要补全，删除如<br/>
109                            if (/<[^<^>^\/]+\/>/.test(e)) {
110                                uncloseTags.splice($.inArray(e, uncloseTags), 1);
111                                return true;
112                            }
113                            //对左标签进行闭合判断，如果同时存在一组左右标签，则同时删除即可，由于成组的删除，所以不用考虑多个<div>对应一个</div>的情况，我们只需要按照顺序获取到未闭合的列表即可
114                            if (/<[^<^>^\/]+>/.test(e)) {
115                                var tagClosed = "";
116                                if (e.indexOf(" ") > 0) {
117                                    tagClosed = "</" + e.substring(1, e.indexOf(" ")) + ">";
118                                } else {
119                                    tagClosed = "</" + e.substring(1, e.length);
120                                }
121                                //同时存在闭合标签
122                                if ($.inArray(tagClosed, uncloseTags) != -1) {
123                                    uncloseTags.splice($.inArray(e, uncloseTags), 1);
124                                    uncloseTags.splice($.inArray(tagClosed, uncloseTags), 1);
125                                }
126                            }
127                        })
128                    }
129                    //此时uncloseTags已经是未闭合的标签列表了
130                    //生成闭合标签，根据标签嵌套规则，右标签和左标签对应，如<div><p>   --  </p></div>，所以先将未闭合标签数组逆序
131                    if (uncloseTags.length > 0) {
132                        var closeTagStr = "";
133                        uncloseTags.reverse();
134                        $.each(uncloseTags, function (i, e) {
135                            if (e.indexOf(" ") > 0) {
136                                closeTagStr += "</" + e.substring(1, e.indexOf(" ")) + ">";
137                            } else {
138                                closeTagStr += "</" + e.substring(1, e.length);
139                            }
140                        })
141                        contentText += "..." + closeTagStr;
142                    } else {
143                        contentText += "...";
144                    }
145                    //拼接完成
146                    $(this).html(contentText);
147                }
148
149            }
150        })
151    }
152}(jQuery);
153
154/**
155 * 自定义字符串结尾判定方法，以s结尾返回true，否则返回false
156 * @param s
157 * @return
158 */
159String.prototype.endsWith = function (s) {
160    if (s == null || s == "" || this.length == 0 || s.length > this.length)
161        return false;
162    if (this.substring(this.length - s.length) == s)
163        return true;
164    else
165        return false;
166    return true;
167}
168String.prototype.endWith = function (s) {
169    if (s == null || s == "" || this.length == 0 || s.length > this.length)
170        return false;
171    if (this.substring(this.length - s.length) == s)
172        return true;
173    else
174        return false;
175    return true;
176}
177
178/**
179 * 自定义字符串开始判定方法，以s开始返回true，否则返回false
180 * @param s
181 * @return
182 */
183String.prototype.startsWith = function (s) {
184    if (s == null || s == "" || this.length == 0 || s.length > this.length)
185        return false;
186    if (this.substr(0, s.length) == s)
187        return true;
188    else
189        return false;
190    return true;
191}
192String.prototype.startWith = function (s) {
193    if (s == null || s == "" || this.length == 0 || s.length > this.length)
194        return false;
195    if (this.substr(0, s.length) == s)
196        return true;
197    else
198        return false;
199    return true;
200}
201
202/**
203 * IE浏览器兼容jquery trim方法
204 * @return
205 */
206String.prototype.trim = function () {
207    return this.replace(/(^\s*)|(\s*$)/g, "");
208}
209/**
210 * 获取地址栏url参数
211 * @param name
212 * @return
213 */
214function getUrlParam(name) {
215    var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)");
216    var r = window.location.search.substr(1).match(reg);
217    if (r != null) return decodeURI(r[2]); return null;
218    //return $("#language").val();
219}
220
221/**
222 * 从参考文献引用信息中提取参考文献索引
223 * 支持格式"[1,3,5-8,11,13-18,19]"
224 * @param refSup
225 * @return
226 */
227function getRefSupIndex(refSup) {
228    if (!isNull(refSup)) {
229        refSup = refSup.replace(/[\[|\]]/g, '').trim();
230        var chars = ['~', '—', '–', '，', '-', '−', '⁃'];
231        $.each(chars, function (ind, val) {
232            var reg = new RegExp(val, "g");
233            refSup = refSup.replace(reg, '&');
234        });
235        var refIndexs = [];
236        $.each(refSup.split(","), function (i, e) {
237            if (isNaN(e)) {
238                var startEnd = e.split("&");
239                var start = parseInt(startEnd[0]);
240                var end = parseInt(startEnd[1]);
241                for (var i = start; i <= end; i++) {
242                    refIndexs.push(i);
243                }
244            } else {
245                refIndexs.push(e);
246            }
247        })
248        //alert(refIndexs);
249        return refIndexs;
250    }
251    return null;
252}
253
254/**
255 * 封装判断对象为空方法
256 * @param object
257 * @return
258 */
259function isNull(object) {
260    return typeof (object) == "undefined" || object == null || object == "";
261}
262
263/**
264 * 获取随机数
265 * @param Min
266 * @param Max
267 * @return
268 */
269function GetRandomNum(Min, Max) {
270    var Range = Max - Min;
271    var Rand = Math.random();
272    return (Min + Math.round(Rand * Range));
273}
274
275/**
276 * 获取网页顶部显示需要的日期信息
277 * @param type 1:中文  2英文 3英文简写
278 * 	  2017-1-11 星期三
279 * 	  Wednesday, 11 January, 2017 
280 *    Jan 20th, Wednesday
281 * @return
282 */
283function dateStr(type) {
284    var date = new Date();
285    return parseInt(type) == 1 ?
286        formatDate(date, type) + " " + getTodayWeek(type) :
287        getTodayWeek(type) + ", " + formatDate(date, type);
288}
289
290
291/**
292 * 将日期格式化成英文格式
293 * 2017-1-11
294 * 11 January, 2017
295 * Jan 11, 2017
296 * @param date
297 * */
298function formatDate(date, type) {
299    if (!isNull(date)) {
300        var dateStr = JSON.stringify(date).substring(1, 11);
301        var dateVal = dateStr.split("-");

302        var month = dateVal[1];
303        if (month.charAt(0) == 0) { month = month.charAt(1); }
304        var monthArray = new Array
305            ("January", "February", "March", "April", "May", "June", "July", "August",
306                "September", "October", "November", "December");
307        var monthArraySimple = new Array
308            ("Jan", "Feb", "Mar", "Apr", "May", "June", "July", "Aug",
309                "Sep", "Oct", "Nov", "Dec");
310        switch (type) {
311            case 1:
312                return dateStr;
313            case 2:
314                return dateVal[2] + " " + monthArray[month - 1] + ", " + dateVal[0];
315            case 3:
316                return monthArraySimple[month - 1] + " " + dateVal[2] + ", " + dateVal[0];
317        }
318    }
319}
320
321/**
322 * 获取星期几
323 * @param type 1:中文  2英文 3英文简写
324 * @return
325 */
326function getTodayWeek(type) {
327    var chinese = new Array("星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六");
328    var english = new Array("Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday");
329    var englishSigle = new Array("Sun.", "Mon.", "Tues.", "Wed.", "Thur.", "Fri.", "Sat.");
330    var week = new Date().getDay();
331    switch (type) {
332        case 1:
333            return chinese[week];
334        case 2:
335            return english[week];
336        case 3:
337            return englishSigle[week];
338    }
339}
340
341/**
342 * 分享工具方法
343 * @param type
344 * @return
345 */
346function shareTools(type, obj) {
347    if (obj && obj.parents(".shareUrlTools").length) {
348        var url = window.location.protocol + "//" + window.location.host + obj.parents(".shareUrlTools").attr("data-url");
349        var title = obj.parents(".shareUrlTools").attr("data-title");
350    } else {
351        var url = window.location;
352        var title = $("head title").text();
353    }
354    var description = $("meta[name='abstract']").attr("content") || $("meta[name='description']").attr("content") || $("meta[name='dc.description']").attr("content") || $("meta[http-equiv='description']").attr("content");
355    var shareUrl = "";
356    switch (type) {
357        case 'qzone':
358            shareUrl = "http://sns.qzone.qq.com/cgi-bin/qzshare/cgi_qzshare_onekey?url=" + url + "&title=" + title;
359            break;
360        case 'sina':
361            shareUrl = "http://service.weibo.com/share/share.php?title=" + title + "&url=" + url + "&pic=";
362            break;
363        case 'weixin':
364            shareUrl = basePath + "util/QrcodeServlet?url=" + url;
365            break;
366        case 'renren':
367            shareUrl = "http://widget.renren.com/dialog/share?resourceUrl=" + url + "&srcUrl=" + url + "&title=" + title + "&pic=&description=" + description;
368            break;
369        case 'google+':
370            shareUrl = "https://plus.google.com/share?url=" + url + "&t=" + title;
371            break;
372        case 'facebook':
373            shareUrl = "http://www.facebook.com/sharer.php?s=100&p[title]=" + title + "&p[summary]=" + description + "&p[url]=" + url + "&p[images]=";
374            break;
375        case 'linkedin':
376            shareUrl = "http://www.linkedin.com/shareArticle?armin=armin&ro=true&mini=true&url=" + url + "&source=&title=" + title + "&summary=" + description;
377            break;
378        case 'twitter':
379            shareUrl = "https://twitter.com/intent/tweet?text=" + title + "&url=" + url;
380            break;
381        default:
382            shareUrl = "http://sns.qzone.qq.com/cgi-bin/qzshare/cgi_qzshare_onekey?url=" + url + "&title=" + title;
383            break;
384    }
385    if ("weixin" == type) {
386        $(".weixinQrcode").attr("src", shareUrl);
387    } else {
388        window.open(shareUrl, "_blank");
389    }
390}
391function closeWeiXinBox(obj) {
392    $(obj).parent().hide();
393}
394
395//过滤HTML标签
396function filterHTMLTag(str) {
397    if (!str) {
398        return str;
399    } else {
400        var msg = str.replace(/<\/?[^>]*>/g, ''); //去除HTML Tag
401        msg = msg.replace(/[|]*\n/, ''); //去除行尾空格
402        msg = msg.replace(/&nbsp;/ig, ''); //去掉npsp
403        return msg;
404    }
405}
406
407//查询条件相关方法
408function SearchCond(field, operator, value, dataType, relation, paramEntity, paramNameVo) {
409    this.dataType = dataType;
410    this.paramName = field;
411    this.operate = operator;
412    this.paramValue = value;
413    this.relation = relation;
414    this.paramEntity = paramEntity;
415    this.paramNameVo = paramNameVo;
416}
417
418function SearchTools_put(conds, searchCond) {
419    if (searchCond.paramValue != null && searchCond.paramValue != "") {
420        conds.push(searchCond);
421    }
422}
423
424function OrderByCond(field, value) {
425    this.dataType = "";
426    this.paramName = field;
427    this.operate = "";
428    this.paramValue = value;
429}
430
431function OrderTools_put(conds, orderByCond) {
432    if (orderByCond.paramValue != null && orderByCond.paramValue != "") {
433        conds.push(orderByCond);
434    }
435}
436
437function SearchCondition(field, operator, value, paramNameVo) {
438    this.searchField = field;
439    this.searchType = operator;
440    this.searchVal = value;
441    if (!isNull(paramNameVo)) {
442        this.searchFieldVo = paramNameVo;
443    } else {
444        this.searchFieldVo = field;
445    }
446}
447
448/**
449 * 条件构建器，用于组合多个查询条件
450 * @class
451 * @param {string} [relationStr="and"] - 条件关系类型，"and" 表示逻辑与，"or" 表示逻辑或
452 */
453function ConditionBuilder(relationStr) {
454    this.relationStr = relationStr || "and";
455    this.conditions = [];
456}
457
458/**
459 * 添加一个条件构建器（包含多个条件）
460 * @memberOf ConditionBuilder
461 * @instance
462 * @param {ConditionBuilder} cond2 - 另一个 ConditionBuilder 实例
463 * @returns {ConditionBuilder} 返回当前实例，支持链式调用
464 */
465ConditionBuilder.prototype.addConds = function (cond2) {
466    if (cond2.conditions.length > 0) {
467        this.conditions.push(cond2);
468    }
469    return this;
470};

471
472/**
473 * 添加单个查询条件
474 * @memberOf ConditionBuilder
475 * @instance
476 * @param {Object} searchCond - 查询条件对象
477 * @param {*} searchCond.searchVal - 搜索值，非 null 且非空时才添加
478 * @returns {ConditionBuilder} 返回当前实例，支持链式调用
479 */
480ConditionBuilder.prototype.addCond = function (searchCond) {
481    if (searchCond) {
482        if (searchCond.searchVal != null && searchCond.searchVal != "") {
483            this.conditions.push(searchCond);
484        }
485    }
486    return this;
487};
488
489function isNull(object) {
490    return typeof (object) == "undefined" || object == null || object == "";
491}
492
493/**
494 * 处理内容中的xml链接标签
495 * @param input 内容
496 * @returns {*} 处理结果
497 */
498function convertLink(input) {
499    var output = input;
500    output = output.replace(/<ext-link/g, "<a")
501        .replace(/<\/ext-link/g, "</a")
502        .replace(/xlink:href/g, "href")
503        .replace(/ext-link-type="uri"/g, "target=\"_blank\"");
504
505    return output;
506}
507
508/**
509 * 按索引获取内容中的正则匹配结果
510 * @param source 内容
511 * @param regx 正则表达式
512 * @param index 索引
513 * @returns {*|string} 索引位置的正则匹配结果
514 */
515function getMatcherByIndex(source, regx, index) {
516
517    var pattern = new RegExp(regx);
518    var list = source.match(pattern);
519    if (!isNull(list)) {
520        var result = list[index];
521        if (!isNull(result)) {
522            return result;
523        }
524    }
525
526    return "";
527}
528
529function isNull(object) {
530    return typeof (object) == "undefined" || object == null || object == "";
531}
532
533/**
534 * 处理内容中的xml链接标签
535 * @param input 内容
536 * @returns {*} 处理结果
537 */
538function convertLink(input) {
539    var output = input;
540    output = output.replace(/<ext-link/g, "<a")
541        .replace(/<\/ext-link/g, "</a")
542        .replace(/xlink:href="([^"]*)"/g, "href=\"$1\"")
543        .replace(/ext-link-type="uri"/g, "target=\"_blank\"");
544
545    return output;
546}
547
548/**
549 * 正则替换,replaceAll不好用,重写逻辑
550 * @param source 源字符串
551 * @param target 替换结果
552 * @param regx 正则表达式
553 * @returns {*} 替换结果
554 */
555function replaceRegx(source, target, regx) {
556    var result = source;
557    var pattern = new RegExp(regx, 'g');
558    var list = result.match(pattern);
559    if (!isNull(list))
560        for (var i = 0; i < list.length; i++) {
561            var str = list[i];
562            result = result.replace(str, target);
563        }
564
565    return result;
566}
567
568/**
569 * 判断内容是否包含doi:
570 * @param context
571 * @returns {boolean}
572 */
573function isContainsByDoi(context) {
574    if (!isNull(context)) {
575        var re = context.toUpperCase().replace(/ /g, "");
576        return re.indexOf("DOI:") != -1;
577    }
578    return false;
579}
580
581/**
582 * 处理公式内容
583 * @param sourceStr 需要处理的字符串
584 * @returns {*|string|string} 处理结果
585 */
586function convertMathHtml(sourceStr) {
587
588    if (isNull(sourceStr)) return "";
589    sourceStr = replaceRegx(sourceStr, "", "<[/]{0,1}multi_end[/]{0,1}>");
590    sourceStr = replaceRegx(sourceStr, "", "<[/]{0,1}multi_start[/]{0,1}>");
591    sourceStr = sourceStr.trim();
592    sourceStr = sourceStr.replace(/jlmText/g, "text");
593
594    //xdf20220615 兼容mml格式公式,剔除mml:
595    sourceStr = sourceStr.replace(/<mml:/g, "<").replace(/<\/mml:/g, "</").replace(/:mml/g, "");
596
597    //xdf20220712 剔除输出数据中的cdata标签
598    sourceStr = sourceStr.replace(/<!\[CDATA\[/g, "").replace(/]]>/g, "");
599
600    var tempStr = sourceStr;
601    if (sourceStr.indexOf("<disp-formula") != -1) { //独立段落行公式
602
603        var imgSrc = "";
604        //如果是公式图片，直接图片输出
605        if (sourceStr.indexOf("graphic ") != -1) {
606            imgSrc = getMatcherByIndex(sourceStr, "xlink:href=\"(.*?)\"", 1);
607        }
608
609        tempStr = replaceRegx(tempStr, "", "<label>.*?</label>");
610        tempStr = replaceRegx(tempStr, "", "<disp-formula.*?>");
611        tempStr = replaceRegx(tempStr, "", "<tex-math.*?>");

612        tempStr = replaceRegx(tempStr, "", "<graphic.*?>.*?</graphic>");
613        tempStr = replaceRegx(tempStr, "", "<alternatives.*?>");
614        tempStr = replaceRegx(tempStr, "", "<graphic.*?>");
615
616        tempStr = tempStr.replace(/<label\/>/g, "")
617            .replace(/\\begin{document}/g, "").replace(/\\end{document}/g, "")
618            .replace(/\\begin{equation} \\begin{CJK}{GBK}{song}/g, "")
619            .replace(/\\end{CJK} \\end{equation}/g, "")
620            .replace(/<\/disp-formula>/g, "")
621            .replace(/<\/tex-math>/g, "")
622            .replace(/<\/alternatives>/g, "")
623            .replace(/<\/graphic>/g, "").trim();
624
625        if (tempStr.startsWith("<p>") && tempStr.endsWith("</p>")) {
626            tempStr = replaceRegx(tempStr, "", "\r\n\t");
627            tempStr = tempStr.replace(/<p>/g, "").replace(/<\/p>/g, "").trim();
628            if (tempStr.startsWith("$") && !tempStr.startsWith("$$")) {
629                tempStr = "$" + tempStr + "$";
630            }
631        }
632        //如果是公式图片，直接图片输出
633        if (sourceStr.indexOf("graphic ") !== -1) {
634            var result = "";
635            if (sourceStr.indexOf("<tex-math") !== -1) {//如内容包含<tex-math,隐藏图片
636                result = tempStr + "<p class='img-formula' style='display:none;'><img class='formula-img' src='" + imgSrc + "'></p>";
637            } else {
638                result = tempStr + "<p class='img-formula'><img class='formula-img' src='" + imgSrc + "'></p>";
639            }
640            result = convertLink(result);
641            return result;
642        }
643    } else if (sourceStr.indexOf("<tex-math") !== -1) { //非段落公式且内容中包含公式则为行内公式
644        //正则匹配inline-formula,循环处理
645        var pattern = new RegExp("(<inline-formula[^>]*>[\\s\\S]*?</inline-formula>)", "g");
646
647        var results = sourceStr.match(pattern);
648        if (results) {
649            for (var i = 0; i < results.length; i++) {
650                currentMath = results[i]
651                var imgSrc = getMatcherByIndex(currentMath, "xlink:href=\"(.*?)\"", 1);
652                var textMathStr = getMatcherByIndex(currentMath, "<tex-math.*?>([\\s\\S]*?)</tex-math?>", 0);
653                var textMath = textMathStr;
654                textMath = replaceRegx(textMath, "", "<tex-math.*?>");
655                textMath = replaceRegx(textMath, "", "<inline-graphic>.*?</inline-graphic>");
656                textMath = replaceRegx(textMath, "\\$", "\\$((\n)|[ ])*\\$");
657                textMath = replaceRegx(textMath, "", "<inline-graphic.*?>.*?</inline-graphic>");
658                textMath = replaceRegx(textMath, "", "<inline-graphic.*?>");
659                textMath = replaceRegx(textMath, "", "</inline-graphic>");
660                textMath = textMath.replace(/\\begin{document}/g, "$")
661                    .replace(/\\end{document}/g, "$")
662                    .replace(/\\begin{equation} \\begin{CJK}{GBK}{song}/g, "$")
663                    .replace(/\\end{CJK} \\end{equation}/g, "$")
664                    .replace(/<\/tex-math>/g, "");
665
666                var mathId = getMatcherByIndex(currentMath, "<tex-math.*?id=\"(.*?)\">", 0);
667                mathId = replaceRegx(mathId, "", "<tex-math.*?id=\"");
668                mathId = replaceRegx(mathId, "", "\">");
669                if (!isNull(imgSrc)) {//有图片时将图片隐藏后输出
670                    var imgTag = "<span class=\"inline-formula-span\">" + textMath
671                        + "</span><img text_id='" + mathId + "' class='formula-img' style='display:none;' src='" + imgSrc + "'>";
672                    sourceStr = sourceStr.replaceAll(textMathStr, imgTag);
673                } else {
674                    sourceStr = sourceStr.replaceAll(currentMath, textMath);
675                }
676            }
677        }
678
679        if (!isNull(sourceStr)) {
680            tempStr = sourceStr;
681            tempStr = replaceRegx(tempStr, "", "<label>.*?</label>");
682            tempStr = tempStr.replace(/<label\/>/g, "");
683            tempStr = tempStr.replace(/\\\\begin{equation} \\\\begin{CJK}{GBK}{song}/g, "")
684                .replace(/\\\\end{CJK} \\\\end{equation}/g, "");
685            tempStr = replaceRegx(tempStr, "", "<disp-formula.*?>");
686            tempStr = tempStr.replace(/<\/disp-formula>/g, "");
687            tempStr = replaceRegx(tempStr, "", "<tex-math.*?>");
688            tempStr = tempStr.replace(/<\/tex-math>/g, "");
689            if (tempStr.indexOf("</graphic>") != -1) {

690                tempStr = replaceRegx(tempStr, "", "<graphic.*?>.*?</graphic>");
691            }
692            tempStr = replaceRegx(tempStr, "", "<graphic.*?>");
693            tempStr = tempStr.replace(/<\/graphic>/g, "").trim();
694        }
695    } else if (sourceStr.indexOf("<graphic ") !== -1) {
696        // 处理自闭合的 <graphic /> 标签
697        tempStr = tempStr.replace(/<graphic[^>]*xlink:href="([^"]+)"[^>]*\/>/g, function (match, href) {
698            return '<img src="' + href + '" />';
699        });
700
701        // 处理成对的 <graphic>...</graphic> 标签
702        tempStr = tempStr.replace(/<graphic[^>]*xlink:href="([^"]+)"[^>]*>(.*?)<\/graphic>/g, function (match, href, content) {
703            return '<img src="' + href + '" />' + content;
704        });
705
706        // 返回处理后的字符串
707        return tempStr;
708    } else if (sourceStr.indexOf("<inline-graphic ") !== -1) {
709        // 处理自闭合的 <inline-graphic /> 标签
710        tempStr = tempStr.replace(/<inline-graphic[^>]*xlink:href="([^"]+)"[^>]*\/>/g, function (match, href) {
711            return '<img class="inlineformula-img" src="' + href + '" />';
712        });
713
714        // 处理成对的 <inline-graphic>...</inline-graphic> 标签
715        tempStr = tempStr.replace(/<inline-graphic[^>]*xlink:href="([^"]+)"[^>]*>(.*?)<\/inline-graphic>/g, function (match, href, content) {
716            return '<img class="inlineformula-img" src="' + href + '" />' + content;
717        });
718
719        // 返回处理后的字符串
720        return tempStr;
721    }
722    tempStr = convertLink(tempStr);
723    return tempStr;
724
725}
726
727/**
728 * 拼装参考文献链接
729 * @param source url或doi
730 * @param isIcon 是否展示为按钮
731 * @param type 类型:doi,url
732 * @returns {string} 拼装的a链接html
733 */
734function getReferLinkHtml(source, isIcon, type) {
735    var typeClass = 'ref-doi';
736    if (type == 'url') typeClass = 'ref-url'
737
738    var iconClass = '';
739    var show = source;
740    if (isIcon && isIcon == "true") {
741        iconClass = 'icon';
742        show = '';
743    }
744
745    var href = source;
746    if (type != 'url') href = 'https://dx.doi.org/' + source;
747
748    return ' <a class=\"mainColor ' + typeClass + ' ' + iconClass + '\" href=\"' + href + '\" target=\"_blank\">' + show + '</a>';
749}
750
751/**
752 * 获取参考文献的输出结果
753 * @param content 参考文献的文本内容
754 * @param doi 参考文献的doi
755 * @param isIcon 链接是否要显示为按钮
756 * @param isUp doi:是否需要大写
757 * @param url 参考文献的链接
758 * @returns {string} 拼装后的参考文献
759 */
760function referenceDOIReplace(content, doi, isIcon, isUp, url, isReferNotAllowLinks) {
761    // 参考文献不允许带有链接配置开启，可传或者直接拿数据字典项
762    if (isReferNotAllowLinks || allData.dic.isReferNotAllowLinks) {
763        // 不包含doi且有传入doi,将'doi:'+doi链接拼装到内容尾部
764        if (!isContainsByDoi(content) && !isNull(doi)) {
765            if ("U" == isUp) {
766                content = content + "<span>" + " doi: ".toUpperCase() + doi + "</span>";
767            } else {
768                content = content + "<span>" + " doi: ".toLowerCase() + doi + "</span>";
769            }
770        } else if (content.indexOf("<a") == "-1" && content.indexOf("<ext-link") == "-1") {
771            if (content.indexOf("http") != "-1") {
772                // xml排版的网址链接中的&为&amp;
773                content = content.replace(/&amp;/g, '&');
774                // content = content.replace(/https?:\/\/[\w\-\.]+\.[a-z]+(?:\/[\w\.\/?%&=-]*)?/g, "");
775                content = content.replace(/https?:\/\/[^\s\]\)]+\.?/g, "");
776            }
777        } else {
778            if (content.indexOf("<a") != "-1") {
779                content = content.replace(/<a[^>]*>(.*?)<\/a>/g, '');
780            } else {
781                content = content.replace(/<ext-link[^>]*>(.*?)<\/ext-link>/g, '');
782            }
783        }
784    } else {
785        var doiHtml = "";
786        if (isNull(doi)) doi = "";
787        if (isNull(url)) url = "";
788        if (isContainsByDoi(content)) {//判断是否包含doi:
789            if (!isNull(doi)) {//传入doi时直接将doi转为链接进行替换
790                doiHtml = getReferLinkHtml(doi, isIcon, 'doi');
791                content = content.replaceAll(doi, doiHtml);
792            } else {//未传入doi时,从内容中切出doi,然后转为链接并进行替换
793                var re = content.toUpperCase().replace(/ /g, "");
794                var inner = re.indexOf("DOI:") + 4;
795                doi = content.replace(/ /g, "").substring(inner);
796
797                if (doi.endsWith(".")) {
798                    doi = doi.substring(0, doi.length - 1);
799                }
800                doiHtml = getReferLinkHtml(doi, isIcon, 'doi');
801                content = content.replaceAll(doi, doiHtml);
802            }
803        } else {//不包含doi:时
804            if (content.indexOf("doi.org") != "-1" && content.indexOf(doi) != "-1" && !isNull(doi)) {//doi的链接是带有doi.org的完整链接时,整条链接转a标签
805                var doiurl = content.substring(content.indexOf("http"), content.indexOf(doi));
806                doiHtml = " <a class=\"mainColor ref-doi\" href=\"" + doiurl + doi + "\" target=\"_blank\">" + doiurl + doi + "</a>";
807                content = content.replaceAll(doiurl + doi, doiHtml);
808            } else if (!isNull(doi)) {//doi的链接不是带doi.org的完整链接时,且有传入doi,将'doi:'+

808doi链接拼装到内容尾部
809                doiHtml = getReferLinkHtml(doi, isIcon, 'doi');
810                if ("U" == isUp) {
811                    content = content + "<span>" + " doi: ".toUpperCase() + doiHtml + "</span>";
812                } else {
813                    content = content + "<span>" + " doi: ".toLowerCase() + doiHtml + "</span>";
814                }
815            } else if (!isNull(url)) {//没有doi:,没有doi.org,没有传入doi的情况,一般不是doi而是其他链接,需要判断是否传入url
816                if (url.lastIndexOf("/10.") != -1) {//有传入url时,看看url是不是包含doi,如果是,则将doi切出,转为链接后拼装至内容尾部
817                    doi = url.substring(url.lastIndexOf("/10.") + 1, url.length);
818                    doiHtml = getReferLinkHtml(doi, isIcon, 'doi');
819                    if ("U" == isUp) {
820                        content = content + "<span>" + " doi: ".toUpperCase() + doiHtml + "</span>";
821                    } else {
822                        content = content + "<span>" + " doi: ".toLowerCase() + doiHtml + "</span>";
823                    }
824                } else {//如果url不包含doi,按普通链接处理
825                    doiHtml = getReferLinkHtml(url, isIcon, 'url');
826                    // 如果内容中包含url，则替换内容中的url为链接形式
827                    if (content.indexOf(url) != "-1") {
828                        content = content.replaceAll(url, doiHtml);
829                    } else {
830                        content = content + doiHtml;
831                    }
832                }
833            } else if (content.indexOf("http") != "-1") {//没有doi:,没有doi.org,没有传入doi和url的情况,但是内容中包含链接
834                if (content.indexOf("<a") == "-1" && content.indexOf("<ext-link") == "-1") {
835                    try {
836                        var isConvertHttpUrl = allData.dic.referenceHttpUrl;
837                        if ("1" == isConvertHttpUrl) {//仅当后台配置=1时才对内部链接进行处理
838                            //使用正则匹配内容中的链接并逐条转为html后替换
839                            // var pattern = new RegExp("^(http://|ftp://|https://|www){0,1}[^\u4e00-\u9fa5\\s]*?\\.(com|net|cn|me|tw|fr)[^\u4e00-\u9fa5\\s]*", "g");
840                            // var pattern = new RegExp("(http|ftp|https)://(?:www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}(?:[-a-zA-Z0-9@:%_\+.~#?&/=]+)*$", "g");
841                            var pattern = /https?:\/\/[\w\-\.]+\.[a-z]+(?:\/[\w\.\/?%&=-]*)?/gi;
842                            var results = content.match(pattern);
843                            for (var i = 0; i < results.length; i++) {
844                                var httpUrl = results[i];
845                                if (!isNull(httpUrl) && httpUrl.endsWith(".")) {
846                                    httpUrl = httpUrl.substring(0, httpUrl.length - 1);
847                                }
848
849                                doiHtml = getReferLinkHtml(httpUrl, isIcon, 'url');
850                                content = content.replaceAll(httpUrl, doiHtml);
851                            }
852
853                        }
854                    } catch (e) {
855                        console.log("doi链接处理未配置!!!")
856                    }
857                } else if (content.indexOf("<ext-link") != "-1") {
858                    // 使用xlink:href属性时，需要声明xmlns:xlink命名空间
859                    var xmlWrapper = '<root xmlns:xlink="http://www.w3.org/1999/xlink">' + content + '</root>';
860                    // 创建DOMParser实例
861                    var parser = new DOMParser();
862                    // 解析为XML文档
863                    var parseTempStr = parser.parseFromString(xmlWrapper, "text/xml");
864
865                    // 遍历XML文档，转换ext-link为a标签
866                    function convertExtLinkToA(node) {
867                        if (node.nodeType === Node.ELEMENT_NODE && node.tagName.toLowerCase() === 'ext-link') {
868                            var aTag = document.createElement('a');
869                            // 复制属性
870                            for (var i = 0; i < node.attributes.length; i++) {
871                                var attr = node.attributes[i];
872                                if (attr.name.startsWith('xlink:')) {
873                                    if (attr.name === 'xlink:href') {
874                                        aTag.href = attr.value;
875                                    }
876                                }
877                            }
878                            // 移动子节点到新创建的a标签中
879                            while (node.firstChild) {
880                                aTag.appendChild(node.firstChild);
881                            }
882                            // 替换原节点
883                            node.parentNode.replaceChild(aTag, node);
884                        } else {
885                            for (var i = 0; i < node.childNodes.length; i++) {
886                                var child = node.childNodes[i];

887                                convertExtLinkToA(child);
888                            }
889                        }
890                    }
891
892                    // 调用函数进行转换
893                    convertExtLinkToA(parseTempStr.documentElement);
894
895                    // 序列化XML文档为字符串，注意这里直接序列化可能包含XML声明等额外信息，需要进一步处理
896                    var serializer = new XMLSerializer();
897                    var modifiedString = serializer.serializeToString(parseTempStr.documentElement);
898
899                    // 去除root标签，获取最终字符串
900                    content = modifiedString.replace(/<root[^>]*>|<\/root>/g, '');
901                }
902            }
903        }
904    }
905    return content;
906}
907
908/**
909 * 半角转全角
910 *
911 * @param input 输入字符串参数
912 * @return string 全角字符串
913 */
914function convert2DoubleByte(input) {
915    var result = []
916    for (var i = 0; i < input.length; i++) {
917        var str = input[i];
918        var charStr = input.charCodeAt(i);
919        if (str == ' ') result.push('\u3000');
920        else if (charStr < 177) {
921            charStr = charStr + 65248;
922            result.push(String.fromCharCode(charStr));
923        }
924    }
925    return result.join('');
926}
927
928
929/**
930 * 全角转半角
931 *
932 * @param input 输入字符串参数
933 * @return string 半角字符串
934 */
935function convertSingleByte(input) {
936    var result = []
937    for (var i = 0; i < input.length; i++) {
938        var str = input[i];
939        var charStr = input.charCodeAt(i);
940        if (str == '\u3000') result.push(' ');
941        else if (str > '\uFF00' && str < '\uFF5F') {
942            charStr = charStr - 65248;
943            result.push(String.fromCharCode(charStr));
944        }
945    }
946    return result.join('');
947}
948
949/**
950 * 判断是否为附图 附表
951 * @param tagId 图表的tagId
952 * @returns {boolean}
953 */
954function isNotSupplementary(tagId) {
955    if (isNull(tagId)) return false;
956    var pattern = new RegExp("^Table[^A-Za-z]+$");
957    var pattern1 = new RegExp("^Figure[^A-Za-z]+$");
958    var matcher = tagId.match(pattern);
959    var matcher1 = tagId.match(pattern1);
960    if (allData.journal.publisherId == "shyfyx" || allData.journal.publisherId == "xhcl") {
961        // 兼容上海预防医学中T1、F1的图、表
962        var pattern2 = new RegExp("^T[^A-Za-z]+$");
963        var pattern3 = new RegExp("^F[^A-Za-z]+$");
964        var matcher2 = tagId.match(pattern2);
965        var matcher3 = tagId.match(pattern3);
966        return !isNull(matcher) || !isNull(matcher1) || !isNull(matcher2) || !isNull(matcher3);
967    } else {
968        return !isNull(matcher) || !isNull(matcher1);
969    }
970}
971
972
973/**
974 * 替换特殊字符
975 */
976function replaceXmlSpecialChar(sourceStr) {
977    if (isNull(sourceStr)) return "";
978    return sourceStr.replace(/©/g, "&#169;")
979        .replace(/\*/g, "&#42;")
980        .replace(/—/g, "&#8212;")
981        .replace(/&gt;/g, "&#62;")
982        .replace(/&lt;/g, "&#60;");
983}
984
985/**
986 * 特殊字符输出转换
987 * @param input
988 * @returns {*|string}
989 */
990function convertInut(input) {
991    //(<)(&)(>)(")(')
992    //&lt，&amp; >" &apos; (')
993
994    if (isNull(input)) return "";
995    input = input.replace(/&/g, "&amp;")
996        .replace(/</g, "&lt;")
997        .replace(/>/g, "&gt;")
998        .replace(/"/g, "&quot;")
999        .replace(/'/g, "&apos;");
1000    return input;
1001}
1002
1003/**
1004 * 处理摘要内容
1005 *
1006 * @param str      摘要
1007 * @param language 语言
1008 * @return string 处理结果
1009 */
1010function convertAbstractHtml(str, language) {
1011    if (isNull(str)) return "";
1012    var secReplace = "";
1013    var titleReplace = "";
1014
1015    str = str.replace(/<italic>/g, "<i>").replace(/<\/italic>/g, "</i>")
1016        .replace(/<bold>/g, "<b>").replace(/<\/bold>/g, "</b>")
1017        .replace(/<underline>/g, "<u>").replace(/<\/underline>/g, "</u>") //下划线
1018        .replace(/<overline>/g, "<span style=\"text-decoration:overline\">").replace(/<\/overline>/g, "</span>") //上划线
1019        .replace(/<strike>/g, "<s>").replace(/<\/strike>/g, "</s>")//中划线、删除线
1020        // .replace(/<p>/g, "").replace(/<\/p>/g, "")//p标签
1021        .replace(/<title\/>/g, ""); //空title
1022
1023    try {
1024        if ("en" == language) {
1025            secReplace = allData.dic.abstractSecReplaceEn;
1026            titleReplace = allData.dic.abstractTitleReplaceEn;
1027        } else {
1028            secReplace = allData.dic.abstractSecReplaceCn;
1029            titleReplace = allData.dic.abstractTitleReplaceCn;
1030        }
1031    } catch (e) {
1032        console.log("方法convertAbstractHtml错误!摘要中sec,title替换标签未配置!!!")
1033    }
1034
1035    if (isNull(secReplace)) {//默认替换为div
1036        str = str.replace(/<sec>/g, "<div>").replace(/<\/sec>/g, "</div>");
1037    } else {
1038        var secReplaceArr = secReplace.split("\\$\\$\\$");
1039        var secReplace1 = secReplaceArr[0];
1040        var secReplace2 = secReplaceArr[1];
1041        str = str.replace(/<sec>/g, secReplace1).replace(/<\/sec>/g, secReplace2);
1042    }
1043
1044    if (isNull(titleReplace)) {//默认替换为b
1045        str = str.replace(/<title>/g, "<b>").replace(/<\/title>/g, "</b>&nbsp;");
1046    } else {
1047        var titleReplaceArr = titleReplace.split("\\$\\$\\$");
1048        var titleReplace1 = titleReplaceArr[0];
1049        var titleReplace2 = titleReplaceArr[1];
1050        str = str.replace(/<title>/g, titleReplace1).replace(/<\/title>/g, titleReplace2);
1051    }
1052
1053    return convertMathHtml(str);
1054}
1055
1056
1057/**
1058 * 获取文章类型转换后的输出
1059 */
1060function getArticleTypeOutput(input, language) {
1061    if (isNull(input)) {
1062        try {
1063            //获取配置
1064            var settingVal = allData.dic.articleTypeTrans;
1065            //配置格式为 文章类型(储存):文章类型(中文输出),文章类型(英文输出);
1066            if (!isNull(settingVal)) {
1067                var convertMap = new Map();
1068                //解析配置文件
1069                var types = settingVal.split(";");
1070                for (var type in types) {
1071                    if (!isNull(type)) {
1072                        var typeToTrans = type.split(":");
1073                        var cnToEn = typeToTrans[1].split(",");
1074                        if ("en" == language) {
1075                            convertMap.put(typeToTrans[0], cnToEn[1]);
1076                        } else {
1077                            convertMap.put(typeToTrans[0], cnToEn[0]);
1078                        }
1079                    }
1080                }
1081                //获取文章类型所对应的输出
1082                return convertMap.get(input);
1083            }
1084        } catch (e) {
1085            console.log("方法getArticleTypeOutput错误!字典中articleTypeTrans未配置!!!")
1086        }
1087
1088    }
1089    return "";
1090}
1091
1092/**
1093 * 获取参考文献格式 1顺序编码制   2作者出版年制
1094 */
1095function getReferenceType(refLable) {
1096    return !isNull(refLable) && (/b[0-9]{1,3}/.test(refLable) || /[0-9]{1,3}/.test(refLable)) ? 1 : 2;
1097}
1098
1099/**
1100 *  删除Html标签
1101 *  @return string
1102 */
1103function delHTMLTag(htmlStr) {
1104    if (isNull(htmlStr)) return "";
1105
1106    var regEx_script = "<script[^>]*?>[\\s\\S]*?<\\/script>"; //定义script的正则表达式
1107    var regEx_style = "<style[^>]*?>[\\s\\S]*?<\\/style>"; //定义style的正则表达式
1108    var regEx_html = "<[^>]+>"; //定义HTML标签的正则表达式
1109    //var regEx_space = "\\s*|\t|\r|\n";//定义空格回车换行符
1110    var regEx_space = "\t|\r|\n";//定义空格回车换行符
1111
1112    htmlStr = replaceRegx(htmlStr, "", regEx_script);
1113    htmlStr = replaceRegx(htmlStr, "", regEx_style);
1114    htmlStr = replaceRegx(htmlStr, "", regEx_html);
1115    htmlStr = replaceRegx(htmlStr, "", regEx_space);
1116
1117    return htmlStr.trim();
1118}
1119
1120/**
1121 * 判断文章内容中是否有图片
1122 */
1123function isImg(context) {
1124    if (isNull(context)) return false;

1125    if (context.indexOf("img ") != "-1" && context.indexOf("src=") != "-1") {
1126        return true;
1127    }
1128    return context.indexOf("graphic") != "-1";
1129}
1130
1131
1132/**
1133 * 判断是否包含中文字符
1134 */
1135function containsChinese(input) {
1136    if (isNull(input)) return false;
1137
1138    var result = []
1139    for (var i = 0; i < input.length; i++) {
1140        var str = input[i];
1141        var charStr = input.charCodeAt(i);
1142        if ((charStr >= 0x4e00) && (charStr <= 0x9fbb)) {
1143            return true;
1144        }
1145    }
1146    return false;
1147}
1148
1149
1150/**
1151 * 组装参考文献作者信息
1152 * @param surNames 单条参考文献的surNames
1153 * @param givenNames 单条参考文献的givenNames
1154 * @returns {null|*[]}
1155 */
1156function buildRefAuthor(surNames, givenNames) {
1157    var containsChinese = containsChinese(surNames) || containsChinese(givenNames);
1158    var surNameList = surNames.split("(\\%\\$\\%)");
1159    var givenNameList = givenNames.split("(\\%\\$\\%)");
1160    var authors = [];
1161    for (var i = 0; i < surNameList.length; i++) {
1162        if (!isNull(surNameList[i])) {
1163            var author = surNameList[i];
1164            //姓名同时存在时进行拼接
1165            if (givenNameList.length == surNameList.length)
1166                author = containsChinese ? surNameList[i] + givenNameList[i] : surNameList[i] + " " + givenNameList[i];
1167            authors.push(author);
1168        }
1169    }
1170    return authors.length == 0 ? null : authors;
1171}
1172
1173
1174/**
1175 * 判断字符串中是否包含数字
1176 *
1177 * @param inputStr
1178 * @return
1179 */
1180function isContainsNumber(inputStr) {
1181    if (!isNull(inputStr)) {
1182        var p = new RegExp(".*\\d+.*", "g");
1183        if (p.test(inputStr)) {
1184            return true;
1185        }
1186    }
1187    return false;
1188}
1189
1190/**
1191 * 处理页码中转页等问题
1192 * @param pageNum 页码
1193 * @returns {*|string}
1194 */
1195function getSinglePageNum(pageNum) {
1196    if (!isNull(pageNum)) {
1197        if (pageNum.indexOf("(") != "-1") {
1198            pageNum = pageNum.substring(0, pageNum.indexOf("("));
1199        }
1200        if (pageNum.indexOf(",") != "-1") {
1201            pageNum = pageNum.substring(0, pageNum.indexOf(","));
1202        }
1203        if (pageNum.indexOf("-") != "-1") {
1204            pageNum = pageNum.substring(0, pageNum.indexOf("-"));
1205        }
1206        return pageNum.trim();
1207    }
1208    return "0";
1209}
1210
1211
1212/**
1213 * 输出文章页码
1214 * @param fpage 首页码
1215 * @param lpage 尾页码
1216 * @param pageLength 页码长度限制,一般为6,此为旧版针对elocationId设置,新版已丧失使用场景
1217 * @returns {string}
1218 */
1219function outputPages(fpage, lpage, pageLength) {
1220    if (isNull(pageLength) || isNull(fpage)) {
1221        return "";
1222    }
1223    var result = "";
1224    if (fpage.length < pageLength) {
1225        if (fpage == "0" || fpage == "00") {
1226            return "";
1227        }
1228        result = fpage;
1229        if (!isNull(lpage)) {
1230            result = result + "-" + lpage;
1231        }
1232    } else {
1233        result = fpage.substring(0, pageLength);
1234    }
1235
1236    return result;
1237}
1238
1239/**
1240 * 判断是否为doi
1241 * @param str
1242 * @returns {boolean}
1243 */
1244function isDoi(str) {
1245    var doiReg = new RegExp("^10.\\d{4,9}/[-._;()/:a-zA-Z0-9]+$");
1246    if (!isNull(str)) {
1247        return doiReg.test(str);
1248    }
1249    return false;
1250}
1251
1252/**
1253 * 把字符串转成首字母大写,其余小写的形式
1254 */
1255function shiftString(sourceStr) {
1256    if (isNull(sourceStr)) return "";
1257    sourceStr = sourceStr.replace(/ /g, "").trim();
1258    var tempString = sourceStr.toLowerCase();
1259    return tempString[0].toUpperCase() + tempString.substring(1);
1260}
1261
1262/**
1263 * 将作者地址信息中符号tag替换为数字tag
1264 */
1265function replaceAffilTag(addressTag) {
1266    if (isNull(addressTag)) return "";
1267    return addressTag.replace(/①/g, "1").replace(/②/g, "2").replace(/③/g, "3")
1268        .replace(/④/g, "4").replace(/⑤/g, "5").replace(/⑥/g, "6")
1269        .replace(/⑦/g, "7").replace(/⑧/g, "8").replace(/⑨/g, "9")
1270        .replace(/a/g, "1").replace(/b/g, "2").replace(/c/g, "3")
1271        .replace(/d/g, "4").replace(/e/g, "5").replace(/f/g, "6")
1272        .replace(/g/g, "7").replace(/h/g, "8").replace(/i/g, "9")
1273        .replace(/j/g, "10").replace(/k/g, "11").replace(/l/g, "12")
1274        .replace(/m/g, "13").replace(/n/g, "14").replace(/o/g, "15");
1275}
1276
1277
1278/**
1279 * 获取页码输出,优先elocationid,其次pageRange,最后用fpagelpage拼装
1280 */
1281function getPageOutput(elocationId, pageRange, fpage, lpage, pageLength) {
1282
1283    if (!isNull(elocationId)) {
1284        return elocationId;
1285    }
1286
1287    if (!isNull(pageRange)) {
1288        return pageRange;
1289    }
1290
1291    return outputPages(fpage, lpage, pageLength);
1292}
1293
1294
1295/**
1296 * 查找字符串中包含字符串个数
1297 *
1298 * @param str     文本
1299 * @param findStr 要查找的字符串
1300 * @param isInit  是否内部调用，模式true
1301 */
1302function stringNumbers(str, findStr, isInit) {
1303    var counter = 0;
1304    if (isInit) {
1305        counter = 0;
1306    }
1307    var findStrSize = findStr.length;
1308    if (str.indexOf(findStr) == -1) {
1309        return 0;
1310    } else if (str.indexOf(findStr) != -1) {
1311        counter++;

1312        stringNumbers(str.substring(str.indexOf(findStr) + findStrSize), findStr, false);
1313        return counter;
1314    }
1315    return 0;
1316}
1317
1318/**
1319 * 数字转指定编号
1320 * @param number
1321 * @returns {string}
1322 * @constructor
1323 */
1324function Number2ListItem(number) {
1325    if (isNull(number)) return "";
1326    var tmp = "0,①,②,③,④,⑤,⑥,⑦,⑧,⑨,⑩,⑪," +
1327        "⑫,⑬,⑭,⑮,⑯,⑰,⑱,⑲,⑳,㉑,㉒" +
1328        ",㉓,㉔,㉕,㉖,㉗,㉘,㉙,㉚,㉛" +
1329        ",㉜,㉝,㉞,㉟,㊱,㊲,㊳,㊴,㊵,㊶,㊷," +
1330        "㊸,㊹,㊺,㊻,㊼,㊽,㊾,㊿,(51),(52),(53),(54),(55),(56),(57),(58),(59)," +
1331        "(60),(61),(62),(63),(64),(65),(66),(67),(68),(69)," +
1332        "(70),(71),(72),(73),(74),(75),(76),(77),(78),(79)," +
1333        "(80),(81),(82),(83),(84),(85),(86),(87),(88),(89),(90)";
1334    var tmpIndex = tmp.split(",");
1335    if (number > 90) {
1336        return "";
1337    }
1338    return tmpIndex[number];
1339}
1340
1341/**
1342 * 转换作者简介中的邮箱为可点击的邮箱地址
1343 * 有mailto： 标识的不转换
1344 *
1345 * @param input
1346 * @return
1347 */
1348function convertAuthorEmailHref(input) {
1349
1350    //空的就直接返回
1351    if (isNull(input)) return input;
1352
1353    //包含mailto的直接返回
1354    if (input.indexOf("mailto:") != "-1") return input;
1355
1356    var emailHref = input;
1357    var reg = "[A-Za-z0-9\\u4e00-\\u9fa5]+@[a-zA-Z0-9_-]+(\\.[a-zA-Z0-9_-]+)+";
1358
1359    try {
1360        var regSetting = allData.dic.excelAuthorEmailHrefConvert;
1361        if (!isNull(regSetting)) {
1362            reg = regSetting;
1363        }
1364    } catch (e) {
1365        console.log("方法convertAuthorEmailHref错误!字典中excelAuthorEmailHrefConvert未配置!!!")
1366    }
1367
1368
1369    var pattern = new RegExp(reg, 'g');                //编译正则表达式
1370    var list = input.match(pattern);
1371    if (!list) {
1372        return;
1373    } else {
1374        for (var i = 0; i < list.length; i++) {
1375            var email = list[i];
1376
1377            if (!isNull(email)) {
1378                emailHref = emailHref.replace(new RegExp(email, 'g'), "<a href=\"mailto:" + email + "\">" + email + "</a>");
1379            }
1380        }
1381    }
1382
1383    return emailHref;
1384}
1385
1386/**
1387 * 替换表格中的图片路径
1388 * @param {*} content 表格内容
1389 * @param {*} article 文章
1390 */
1391function repalceTableImg(content, article) {
1392    if (!content) {
1393        return;
1394    } else {
1395        var srcStart = ""
1396        if (article.articleState && article.articleState != "") {
1397            srcStart = filePath + "journal/article/" + allData.journal.publisherId.toLowerCase() + "/newcreate/";
1398        } else {
1399            srcStart = filePath + "journal/article/" + allData.journal.publisherId.toLowerCase() + "/" + article.year + "/" + article.issue + "/";
1400        }
1401        return content.replace(/src="/g, 'src="' + srcStart);
1402    }
1403}
1404
1405/**
1406 * 判断是否是数字类型
1407 */
1408function isNumber(obj) {
1409    return typeof parseInt(obj) === 'number' && !isNaN(parseInt(obj));
1410}
1411
1412/**
1413 * 去除普通空格（\s）、制表符、换行符和 &nbsp;（非断空格）
1414 */
1415function removeSpacesAndNbsp(inputString) {
1416    // 使用正则表达式匹配普通空格、制表符、换行符和&nbsp;
1417    var regex = /[\s\u00A0]+/g;
1418    return inputString.replace(regex, '');
1419}
1420
1421/**
1422 * 数字转带圈的数字，仅支持1-50，50后的普通字符集没有
1423 */
1424function arabicToCircledNumber(arabicNumber) {
1425    if (isNull(arabicNumber)) return "";
1426    if (arabicNumber >= 1 && arabicNumber <= 50) {
1427        const circledNumbers = [
1428            '①', '②', '③', '④', '⑤',
1429            '⑥', '⑦', '⑧', '⑨', '⑩',
1430            '⑪', '⑫', '⑬', '⑭', '⑮',
1431            '⑯', '⑰', '⑱', '⑲', '⑳',
1432            '㉑', '㉒', '㉓', '㉔', '㉕',
1433            '㉖', '㉗', '㉘', '㉙', '㉚',
1434            '㉛', '㉜', '㉝', '㉞', '㉟',
1435            '㊱', '㊲', '㊳', '㊴', '㊵',
1436            '㊶', '㊷', '㊸', '㊹', '㊺',
1437            '㊻', '㊼', '㊽', '㊾', '㊿'
1438        ];

1439        return circledNumbers[arabicNumber - 1];
1440    } else {
1441        return arabicNumber.toString(); // 超出范围的数字原样返回
1442    }
1443}
1444
1445/**
1446 * 过滤文章的作者，把文章的英文作者authorEnList追加到article上
1447 */
1448function articleAuthors2AhthorsEn(article) {
1449    if (article && article.authors && article.authors.length) {
1450        article.authorEnList = [];
1451        $.each(article.authors, function (i, author) {
1452            if (author.authorNameEn) {
1453                article.authorEnList.push(author);
1454            }
1455        })
1456    }
1457    return article;
1458}
1459/**
1460 * 过滤文章的作者，把文章的中文作者authorCnList、英文作者authorEnList追加到article上
1461 */
1462function articleAuthors2AuthorsCnOrAuthorsEn(article) {
1463    if (article && article.authors && article.authors.length) {
1464        article.authorCnList = [];
1465        article.authorEnList = [];
1466        $.each(article.authors, function (i, author) {
1467            author.authorNameEn ? article.authorEnList.push(author) : '';
1468            author.authorNameCn ? article.authorCnList.push(author) : '';
1469        })
1470    }
1471    return article;
1472}
1473/**
1474 * 过滤文章的keywords，把文章的中文作者keywordsCnList、英文作者keywordsEnList追加到article上
1475 */

1476function articleKeyword2KeywordCnOrKeywordEn(article) {
1477    if (article && article.keywords && article.keywords.length) {
1478        article.keywordCnList = [];
1479        article.keywordEnList = [];
1480        $.each(article.keywords, function (i, keyword) {
1481            keyword.keywordEn ? article.keywordEnList.push(keyword) : '';
1482            keyword.keywordCn ? article.keywordCnList.push(keyword) : '';
1483        })
1484    }
1485    return article;
1486}
1487/**
1488 * 转义字符串中的单引号、双引号
1489 */
1490function escapeString(str) {
1491    if (str) {
1492        return str.replace(/[\"\']/g, function (match) {
1493            switch (match) {
1494                case '\"': return '"';
1495                case "\'": return '&#39';
1496            }
1497        });
1498    }
1499}
1500
1501if (!String.prototype.replaceAll) {
1502    String.prototype.replaceAll = function (str, newStr) {
1503        // If a regex pattern
1504        if (Object.prototype.toString.call(str).toLowerCase() === '[object regexp]') {
1505            return this.replace(str, newStr);
1506        }
1507        // If a string
1508        return this.replace(new RegExp(str, 'g'), newStr);
1509    };
1510    template.defaults.imports.replaceAll = String.prototype.replaceAll;
1511}
1512
1513/**
1514 * 替换内容中的图片路径
1515 */
1516function replaceImg(context, path) {
1517    if (context && path) {
1518        // 创建一个正则表达式，匹配<img src="...">中的src属性
1519        var regex = /<img\s+src="([^"]+)"/g;
1520
1521        // 通过循环匹配所有的<img>标签，并替换其中的src属性
1522        var updatedContext = context;
1523        var match = regex.exec(context);
1524        while (match !== null) {
1525            var originalSrc = match[1];
1526            var replacement = '<img src="' + path + originalSrc + '"';
1527            updatedContext = updatedContext.replace('<img src="' + originalSrc + '"', replacement);
1528            match = regex.exec(context);
1529        }
1530
1531        return updatedContext;
1532    }
1533}
1534
1535if (typeof Object.assign !== 'function') {
1536    Object.defineProperty(Object, 'assign', {
1537        value: function (target) {
1538            'use strict';
1539            if (target == null) {
1540                throw new TypeError('Cannot convert undefined or null to object');
1541            }
1542
1543            var to = Object(target);
1544
1545            for (var index = 1; index < arguments.length; index++) {
1546                var nextSource = arguments[index];
1547
1548                if (nextSource != null) {
1549                    for (var nextKey in nextSource) {
1550                        if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
1551                            to[nextKey] = nextSource[nextKey];
1552                        }
1553                    }
1554                }
1555            }
1556            return to;
1557        },
1558        writable: true,
1559        configurable: true
1560    });
1561}
1562/**
1563 * 对作者中的通讯作者以通讯作者的correspSort排序，如果没有，则默认排序
1564 * @param {*} authors 作者数组
1565 */
1566function sortCorresper(authors) {
1567    if (!authors) return authors;
1568    var itemsWithIndex = [];
1569    var itemsWithoutIndex = [];
1570
1571    for (var i = 0; i < authors.length; i++) {
1572        var item = authors[i];
1573        if (typeof item.correspSort !== 'undefined') {
1574            itemsWithIndex.push(item);
1575        } else {
1576            itemsWithoutIndex.push(item);
1577        }
1578    }
1579
1580    itemsWithIndex.sort(function (a, b) {
1581        return a.correspSort - b.correspSort;
1582    });
1583
1584    return itemsWithIndex.concat(itemsWithoutIndex);
1585}
1586
1587/**
1588 * 校验检索词输入状态
1589 * @return
1590 */
1591function checkSearchNew(form) {
1592    var searchText = $(form).find("input[name='q']").val().replace(" ", "");
1593    if (isNull($("#language").val()) || $("#language").val() == "cn") {
1594        if (typeof (searchText) == "undefined" || searchText == "" || searchText == "请输入检索词！") {
1595            alert("请输入检索词！");
1596            return false;
1597        } else {
1598            if ($(".formToken").length && $(".formToken").val() != "") {
1599                return true;
1600            }
1601        }
1602    } else if ($("#language").val() == "en") {
1603        if (typeof (searchText) == "undefined" || searchText == "" || searchText == "Please enter the search word") {
1604            alert("Please enter the search word");
1605            return false;
1606        } else {
1607            if ($(".formToken").length && $(".formToken").val() != "") {
1608                return true;
1609            }
1610        }
1611    }
1612    return false;
1613}
1614
1615function kb2Mb(value) {
1616    var n = 1;
1617    if (typeof value === 'number' && !isNaN(value) && value != 0) {
1618        return Math.round(value / 1024 * Math.pow(10, n)) / Math.pow(10, n);
1619    } else {
1620        return 0;
1621    }
1622}
1623
1624/**
1625 * doi引文转cstr引文
1626 * @param {*} doiCitation doi引文
1627 * @param {*} CSTR CSTR号，一般可直接使用doi号
1628 * @return CSTRCitation
1629 */
1630function doiCitation2CSTRCitation(doiCitation, CSTR) {
1631
1632    // 将字符串包裹在一个临时的 div 中
1633    var $doicitation = $('<div>' + doiCitation + '</div>');
1634
1635    // 使用 jQuery 选择器获取 a 标签
1636    var $a = $doicitation.find('a');
1637    if ($a.length > 0) {
1638        var href = $a.attr('href');
1639        var text = CSTR ? CSTR : $a.text();
1640
1641        if (href.indexOf('doi') > 0) {
1642            var cstrHref = 'https://www.cstr.cn/' + text;
1643
1644            // 更新 a 标签的 href 和文本
1645            $a.attr('href', cstrHref);
1646            $a.text(text);
1647
1648            // 替换 "DOI:" 为 "CSTR:"
1649            $doicitation.html($doicitation.html().replace('DOI:', 'CSTR:'));
1650        }
1651    }
1652
1653    // 移除临时的 div 并返回处理后的 HTML
1654    return $doicitation.html();
1655}
1656// article.copyRight字段中的xml转为html元素，只对copyright-statement、license-p:not([specific-use="electronic-only"])做展示，ext-link转换为a标签
1657function convertCopyRight(string) {
1658    var $xml = $("<root>" + string + "</root>");
1659    var $permissions = $xml.find("permissions");
1660    var html = "";
1661    $permissions.children().each(function () {
1662        var $element = $(this);
1663        var tagName = $element.prop("tagName").toLowerCase();
1664        if (tagName === "copyright-statement" || tagName === "license") {
1665            html += "<div class='" + tagName + "'>";
1666            if (tagName === "license") {
1667                $element.children().each(function () {
1668                    var $child = $(this);
1669                    var childTagName = $child.prop("tagName").toLowerCase();
1670                    if (
1671                        childTagName === "license-p" &&
1672                        $child.attr("specific-use") !== "electronic-only"
1673                    ) {
1674                        html += "<div class='license-p'>";
1675                        $child.contents().each(function () {
1676                            if (this.nodeType === 1 && this.tagName.toLowerCase() === "ext-link") {
1677                                var href = $(this).attr("xlink:href");
1678                                var text = $(this).text();
1679                                html += "<a href=\"" + href + "\">

1679" + text + "</a>";
1680                            } else {
1681                                html += this.nodeType === 3 ? this.nodeValue : $(this).prop("outerHTML");
1682                            }
1683                        });
1684                        html += "</div>";
1685                    }
1686                });
1687            } else {
1688                html += $element.text();
1689            }
1690            html += "</div>";
1691        }
1692    });
1693    return html;
1694}
1695
1696// article.copyRightLicense字段中的xml转为html元素，ext-link转换为a标签
1697function convertCopyRightLicense(string) {
1698    var $xml = $("<root>" + string + "</root>");
1699    var $licenseP = $xml.find("license-p");
1700    var html = "";
1701    html += "<div class='license-p'>";
1702    $licenseP.contents().each(function () {
1703        if (this.nodeType === 1 && this.tagName.toLowerCase() === "ext-link") {
1704            var href = $(this).attr("xlink:href");
1705            var text = $(this).text();
1706            html += "<a href=\"" + href + "\">" + text + "</a>";
1707        } else {
1708            html += this.nodeType === 3 ? this.nodeValue : $(this).prop("outerHTML");
1709        }
1710    });
1711    html += "</div>";
1712    return html;
1713}
1714
1715function journalCycleType(cycleType, language) {
1716    if (!language) {
1717        language = "cn";
1718    }
1719    if (cycleType && cycleType != "") {
1720        var cycleTypeMapping = {
1721            cn: { 5: "月刊", 1: "年刊", 2: "半年刊", 3: "季刊", 4: "双月刊", 6: "半月刊", 7: "旬刊", 8: "周刊" },
1722            en: { 5: "Monthly", 1: "Annuals", 2: "Semiyearly", 3: "Quarterly", 4: "Bimonthly", 6: "Semimonthly", 7: "Periodical", 8: "Weekly" },
1723        };
1724        if (cycleTypeMapping[language] && cycleTypeMapping[language][cycleType]) {
1725            return cycleTypeMapping[language][cycleType];
1726        } else {
1727            return "Unknown"; // 默认返回值
1728        }
1729    }
1730    else {
1731        return "请检查期刊信息中是否配置出版周期"
1732    }
1733
1734}
1735
1736/**
1737 * 平滑滚动到指定元素,IE降级到直接跳转
1738 * @param {string} selector - 目标元素的选择器
1739 * @param {object} options - 可选参数
1740 * @param {number} options.offset - 滚动时的偏移量，默认0
1741 * @param {number} options.duration - 滚动持续时间，默认1000毫秒
1742 * @param {string} options.scrollContainer - 滚动容器的选择器，默认窗口
1743 * @param {function} options.callback - 滚动完成后的回调函数
1744 */
1745function smoothScrollToElement(selector, options) {
1746    // 参数处理（强制要求 options 为对象）
1747    options = options || {};
1748
1749    // 默认值合并
1750    var offset = options.offset || 0; // 默认偏移0px
1751    var duration = typeof options.duration === 'number' ? options.duration : 1000; // 默认1秒
1752    var scrollContainer = options.scrollContainer || null; // 默认窗口滚动
1753    var callback = options.callback || function () { }; // 完成回调
1754
1755    // 获取元素和容器
1756    var $element = $(selector);
1757    var $container = scrollContainer ? $(scrollContainer) : $('html, body');
1758    if (!$element.length) return;
1759
1760    // 判断是否为窗口滚动
1761    var isWindow = $container[0] === window || $container[0] === document.documentElement;
1762
1763    // 计算目标位置
1764    function calculateTargetPosition() {
1765        if (isWindow) {
1766            return $element.offset().top - offset;
1767        } else {
1768            var elementTop = $element.offset().top;
1769            var containerTop = $container.offset().top;
1770            return elementTop - containerTop - offset + $container.scrollTop();
1771        }
1772    }
1773
1774    // 降级方案（IE10直接跳转）
1775    if (typeof window.requestAnimationFrame !== 'function') {
1776        var targetPos = calculateTargetPosition();
1777        isWindow ? $('html, body').scrollTop(targetPos) : $container.scrollTop(targetPos);
1778        callback(); // 立即触发回调
1779        return;
1780    }
1781
1782    // 动画逻辑
1783    var startPos = $container.scrollTop();
1784    var targetPos = calculateTargetPosition();
1785    var startTime = Date.now();
1786
1787    // 缓动函数
1788    function easeInOutQuad(t) {
1789        return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
1790    }
1791
1792    function animate() {
1793        var now = Date.now();

1794        var elapsed = now - startTime;
1795        var progress = Math.min(elapsed / duration, 1);
1796        var eased = easeInOutQuad(progress);
1797
1798        var currentTarget = calculateTargetPosition();
1799        var newPos = startPos + (currentTarget - startPos) * eased;
1800
1801        isWindow ? $('html, body').scrollTop(newPos) : $container.scrollTop(newPos);
1802        if (elapsed < duration) {
1803            requestAnimationFrame(animate);
1804        } else {
1805            // 最终定位并触发回调
1806            isWindow ? $('html, body').scrollTop(currentTarget) : $container.scrollTop(currentTarget);
1807            callback(); // 立即触发回调
1808        }
1809    }
1810
1811    requestAnimationFrame(animate);
1812}
1813
1814//滚动时设置某个元素fixed
1815function fixed(standardName, objName) {
1816    if ($(standardName).length > 0 && (objName).length > 0) {
1817        var scrollTop = $(document).scrollTop();
1818
1819        var standard = $(standardName),
1820            top = standard.offset().top + standard.height(),
1821            obj = $(objName);
1822
1823        if (top < scrollTop) {
1824            if (!obj.hasClass('fix')) obj.addClass('fix');
1825            return;
1826        }
1827        obj.removeClass('fix');
1828    }
1829}
1830
1831if (!Array.prototype.includes) {
1832    Object.defineProperty(Array.prototype, 'includes', {
1833        value: function (searchElement, fromIndex) {
1834            if (this == null) {
1835                throw new TypeError('"this" is null or not defined');
1836            }
1837            var o = Object(this);
1838            var len = o.length >>> 0;
1839            if (len === 0) {
1840                return false;
1841            }
1842            var n = fromIndex | 0;
1843            var k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
1844            while (k < len) {
1845                if (o[k] === searchElement) {
1846                    return true;
1847                }
1848                k++;
1849            }
1850            return false;
1851        }
1852    });
1853}
1854
1855// str转array，并trim()
1856function str2Array(str, splitStr) {
1857    if (!splitStr) { var splitStr = ',' }
1858    return str.split(splitStr).map(function (item) {
1859        return item.trim ? item.trim() : item.replace(/^\s+|\s+$/g, '');
1860    });
1861};
1862
1863// 去除包裹的p标签
1864function removeOuterPTags(input) {
1865    input = input.trim();
1866    if (input.startsWith('<p>') && input.endsWith('</p>')) {
1867        input = input.slice(3, -4).trim();
1868    }
1869    return input;
1870}
1871
1872// 根据journalId获取journal，如果没有传递journals则使用allData.jouranl
1873function getJournalByJournalId(journalId, journals) {
1874    if (journals) {
1875        var currentjournals = journals;
1876    } else {
1877        var currentjournals = allData.journals;
1878    }
1879    var journal = "";
1880    if (journalId && currentjournals) {
1881        currentjournals.forEach(function (item, index) {
1882            if (item.id == journalId) {
1883                journal = item;
1884            }
1885        })
1886    }
1887    return journal ? journal : "未获取期刊，检查journalId";
1888}
1889
1890// 如果有拆分的基金号，则给基金信息中拼接sowise埋点
1891// 如果有拆分的基金号，则给基金信息中拼接sowise埋点
1892function renderFundPrjInfo(fundPrjInfo, fundPrjs) {
1893    if (!fundPrjs) {
1894        return fundPrjInfo;
1895    }
1896
1897    var awardIds = [];
1898    if (Object.prototype.toString.call(fundPrjs) === "[object Array]") {
1899        for (var i = 0; i < fundPrjs.length; i += 1) {
1900            var item = fundPrjs[i];
1901            if (item && item.awardId) {
1902                awardIds.push(item.awardId);
1903            }
1904        }
1905    }
1906
1907    var processed = fundPrjInfo;
1908    for (var i = 0; i < awardIds.length; i += 1) {
1909        var awardId = awardIds[i];
1910        if (processed.indexOf(awardId) !== -1) {
1911            var span = '<span class="span-awardId">' + awardId + "</span>";
1912            processed = processed.split(awardId).join(span);
1913        }
1914    }
1915
1916    return processed;
1917}
1918
1919dayjs.extend(window.dayjs_plugin_relativeTime);
1920template.defaults.imports.filterHTMLTag = filterHTMLTag;
1921template.defaults.imports.startsWith = String.prototype.startsWith;
1922template.defaults.imports.endsWith = String.prototype.endsWith;
1923template.defaults.imports.trim = String.prototype.trim;
1924template.defaults.imports.split = String.prototype.split;
1925template.defaults.imports.fromCharCode = String.fromCharCode;
1926template.defaults.imports.isNull = isNull;
1927template.defaults.imports.convertLink = convertLink;
1928template.defaults.imports.isNotSupplementary = isNotSupplementary;
1929template.defaults.imports.getReferLinkHtml = getReferLinkHtml;
1930template.defaults.imports.isContainsByDoi = isContainsByDoi;
1931template.defaults.imports.replaceRegx = replaceRegx;
1932template.defaults.imports.referenceDOIReplace = referenceDOIReplace;
1933template.defaults.imports.convertMathHtml = convertMathHtml;
1934template.defaults.imports.delHTMLTag = delHTMLTag;
1935template.defaults.imports.convertAuthorEmailHref = convertAuthorEmailHref;
1936template.defaults.imports.outputPages = outputPages;
1937template.defaults.imports.repalceTableImg = repalceTableImg;
1938template.defaults.imports.convertAbstractHtml = convertAbstractHtml;
1939template.defaults.imports.isNumber = isNumber;
1940template.defaults.imports.removeSpacesAndNbsp = removeSpacesAndNbsp;

1941template.defaults.imports.arabicToCircledNumber = arabicToCircledNumber;
1942template.defaults.imports.articleAuthors2AhthorsEn = articleAuthors2AhthorsEn;
1943template.defaults.imports.articleAuthors2AuthorsCnOrAuthorsEn = articleAuthors2AuthorsCnOrAuthorsEn;
1944template.defaults.imports.articleKeyword2KeywordCnOrKeywordEn = articleKeyword2KeywordCnOrKeywordEn;
1945template.defaults.imports.escapeString = escapeString;
1946template.defaults.imports.encodeURIComponent = encodeURIComponent;
1947template.defaults.imports.decodeURIComponent = decodeURIComponent;
1948template.defaults.imports.replace = String.prototype.replace;
1949template.defaults.imports.replaceImg = replaceImg;
1950template.defaults.imports.JSON = JSON;
1951template.defaults.imports.sortCorresper = sortCorresper;
1952template.defaults.imports.kb2Mb = kb2Mb;
1953template.defaults.imports.doiCitation2CSTRCitation = doiCitation2CSTRCitation;
1954template.defaults.imports.convertCopyRight = convertCopyRight;
1955template.defaults.imports.convertCopyRightLicense = convertCopyRightLicense;
1956template.defaults.imports.journalCycleType = journalCycleType;
1957template.defaults.imports.includes = Array.prototype.includes;
1958template.defaults.imports.str2Array = str2Array;
1959template.defaults.imports.removeOuterPTags = removeOuterPTags;
1960template.defaults.imports.getJournalByJournalId = getJournalByJournalId;
1961template.defaults.imports.renderFundPrjInfo = renderFundPrjInfo;
1962window.firstBy ? template.defaults.imports.firstBy = firstBy : "";