【代码】jdbc数据源 pdf预览 前端打印预览

const p = {};
p.Printer = function (options) {
    // 默认配置
    var defaults = {
        tenantCode: config.printTenantCode, // 租户
        userCode: config.printUserCode, // 用户
        baseUrl: `${config.printUrl}/T-LPAAS/logistics-paas-printer`, // 网关
        printerJsonKey: '__printerJson',
        printUrl: 'http://129.0.0.1:19999/report/' // 打印客户端中转服务
    };
    this.opts = Object.assign(defaults, options);
    var split = ';'; // 数组参数 分隔符

    // 生成 token*/
    this.genToken = function (printCode, params, time) {
        /*
        * 打印模板编号值+ 时间戳+租户编码+用户编码+非空动态业务参数拼接  utf-8编码取md5的hash值
        * 也可直接调api获取token https://apisit.midea.com/T-LPAAS/logistics-paas-printer/pdf/token/distribution_order/T881914257/MC225206943?etdoNo=T2009186745920&etdoNo=T2009186745921&userId=150
        */
        var tenantCode = this.opts.tenantCode;
        var userCode = this.opts.userCode;

        // 打印模板编号值+ 时间戳+租户编码+用户编码+非空动态业务参数拼接  utf-8编码取md5的hash值
        var token = md5(
            printCode +
            time +
            tenantCode +
            userCode +
            getParamsStr(params, true)
        );

        return token;
    };

    // 获取pdf url
    this.pdf = function (printCode, params) {
        var time = this.getTime();
        var tenantCode = this.opts.tenantCode;
        var userCode = this.opts.userCode;
        var baseUrl = this.opts.baseUrl;

        var token = this.genToken(printCode, params, time);

        // 构建url
        return (
            baseUrl +
            stringFormat(
                '/pdf/{0}/{1}/{2}/{3}/{4}?{5}',
                printCode,
                time,
                tenantCode,
                userCode,
                token,
                getParamsStr(params, false)
            )
        );
    };
//该函数用于打开报表的跨域预览。
//打开一个空的窗口。
//构造一个HTML表单，并将表单的内容写入到打开的窗口中,获取表单元素并提交表单。
    this.corsPreview = function (printCode, params, postData) {
        var printerJsonKey = this.opts.printerJsonKey;
        var url = this.pdf(printCode, null);
        if (this.endWiths(url, '?')) {
            url = url.substr(0, url.length - 1);
        }
        var printerIframe = window.open('', '');
        var html =
        "<form id='__printerForm' method='post' action='" +
        url +
        "'><textarea style='visibility: hidden;'  name='" +
        printerJsonKey +
        '>' +
        postData +
        '</textarea></from>';
        printerIframe.document.write(html);
        var printerForm = printerIframe.document.getElementById(
            '__printerForm'
        );
        printerForm.submit();
    };
    this.endWiths = function (str, target) {
        var start = str.length - target.length;
        var arr = str.substr(start, target.length);
        if (arr === target) {
            return true;
        }
        return false;
    };
    /打开报表预览*/
//该函数调用pdf方法生成一个URL,用于打开报表的预览

    this.preview = function (printCode, params, postData) {
        var url = this.pdf(printCode, params);
        if (this.endWiths(url, '?')) {
        //检查URL是否以'?'结尾，若是则截取掉最后一个字符
            url = url.substr(0, url.length - 1);

        }

        if (postData === null || postData === undefined) {
            genLink(url);
        } else {
//使用axios发送POST请求，并在请求成功后下载响应的数据
            axios({
                url: url,
                method: 'POST',
                headers: { 'Content-Type': 'application/json;charset=UTF-8' },
                data: postData,
                responseType: 'blob'
            }).then((res) => {
                const downloadElement = document.createElement('a');
                try {
                    downloadElement.href = window.URL.createObjectURL(res.data);
                } catch (error) {
                    downloadElement.href = res.config.url;
                }
                downloadElement.target = '_blank';
                document.body.appendChild(downloadElement);
                downloadElement.click();
            });
        }
    };
    this.silentPrint =function(printCode, params, postData) {
        const that = this;
        return new Promise(function(resolve, reject) {
            if (postData === null || postData === undefined) {
                postData = '{}';
            }
            var url = that.pdf(printCode, params);
            var printData = {
                url: url,
                postData: postData,
                _report: printCode
            };
            var printUrl = that.opts.printUrl;
            axios({
                url: printUrl,
                method: "POST",
                data: printData,
                headers: {
                    'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'
                },
                transformRequest: [
                    function (data) {
                        let ret = ''
                        for (let it in data) {
                            if (data.hasOwnProperty(it)) {
                                ret += encodeURIComponent(it) + '=' + encodeURIComponent(data[it]) + '&'
                            }
                        }
                        ret = ret.substring(0, ret.lastIndexOf('&'));
                        return ret
                    }
                ]
            }).then(res => {
                let response = {};
                response = res;
                // if (Object.prototype.toString.call(res) === '[Object Object]') {
                //     response = res;
                // } else {
                //     response = JSON.parse(res);
                // }
                // alert(response.msg);
                resolve(response);
            }).catch(err => {
                reject(err)
            });
        })
    }
    // 获取到秒的时间戳，精确到秒*/
    this.getTime = function () {
        var time = Date.parse(new Date()).toString();
        return time.substr(0, 10);
    };

    function genLink(href) {
        var a = document.createElement('a');
        a.setAttribute('href', href);
        a.setAttribute('target', '_blank');
        document.body.appendChild(a);
        a.click();
    }
//遍历params对象的每个属性，属性值是数组：
//type为true，函数将直接连接数组的每个元素。
//type为false，函数将对每个数组元素使用encodeURIComponent编码，并以&连接符拼接字符串。

//非数组类型的参数值：
//type为true，函数直接连接参数值。
//type为false，函数将参数名和使用encodeURIComponent编码后的参数值以&连接符拼接字符串。type为false且生成的查询字符串不为空，将去除第一个&连接符
    function getParamsStr(params, type) {
        var paramsStr = '';
        if (params === null) {
            return paramsStr;
        }
        for (var param in params) {
            if (params.hasOwnProperty(param)) {
                var value = params[param].toString();
                if (value.indexOf(split) !== -1) {
                    var arr = value.split(split);
                    for (var index in arr) {
                        if (type) {
                            paramsStr += arr[index];
                        } else {
                            paramsStr +=
                            '&' + param + '=' + encodeURIComponent(arr[index]);
                        }
                    }
                } else {
                    if (type) {
                        if(Array.isArray(params[param])){
                            params[param].forEach((item)=>{
                                paramsStr += item
                            })
                        }else{
                        paramsStr += params[param];
                        }
                    } else if(Array.isArray(params[param])){
                        params[param].forEach((item)=>{
                            paramsStr +=
                        '&' + param + '=' + encodeURIComponent(item);
                        })
                    } else {
                        paramsStr +=
                        '&' + param + '=' + encodeURIComponent(params[param]);
                    }
                }
            }
        }

        if (type === false && paramsStr.length > 0) {
            paramsStr = paramsStr.substr(1);
        }
        return paramsStr;
    }
//该函数用于将字符串中的占位符{}替换为传入的参数值
//遍历从第二个参数开始的剩余参数，依次替换占位符。
//使用正则表达式和replace方法，全局且不区分大小写的替换。

    function stringFormat() {
        if (arguments.length === 0) return null;
        var str = arguments[0];
        for (var i = 1; i < arguments.length; i++) {
            var re = new RegExp('\\{' + (i - 1) + '\\}', 'gm');
            str = str.replace(re, arguments[i]);
        }
        return str;
    }
};

export default p;

import p from '@/utils/print.js';          
const printer = new p.Printer();
const pdfUrl = printer.pdf(printCode.value, printParmas);
closeDialog();
printer
      .silentPrint(printCode.value, printParmas)
      .then(() => {
              ElMessage.success('打印成功！');
           })
           .catch(() => {
               window.open(pdfUrl);
           });