Métodos públicos encapsulados por el proyecto baidu

/**
 * @file 公共方法
 * @author [email protected]
 */
import Cookies from 'js-cookie';
import fileDownload from 'js-file-download';
import axios from 'axios';
import _get from 'lodash/get';

/* eslint-disable */
// 获取最长公共前缀
export const longestCommonPrefix = (...strs) => {
    
    
    if (strs.length === 0) {
    
    
        return '';
    }
    else if (strs.length === 1) {
    
    
        return strs[0]
    }
    let first = strs.shift();
    let hashTable = {
    
    };
    let index = first.length - 1;
    for(let i = 0;i < strs.length; i++) {
    
    
        let j;
        let str = strs[i];
        if (str.length < first.length) {
    
    
            index = Math.min(index, str.length - 1);
        }

        for (j = 0;j < str.length; j++) {
    
    
            if (first[j] !== str[j]) {
    
    
                index = Math.min(index, j - 1);
                break;
            }
        }
    }

    return index >= 0 ? first.slice(0, index + 1) : '';
};

// 对于xpath进行过滤 最后一个节点需要是html|body|p|div|h*其中之一，且过滤掉因为公共前缀匹配到'['的情况
// eg: '/html/body/p[5]' & '/html/body/p[3]' 公共前缀是 '/html/body/p['
export const filterPath = path => {
    
    
    let pathArr = path.split('/');
    let endIndex;

    for (let i = pathArr.length - 1; i >= 0; i--) {
    
    
        const pathPiece = pathArr[i];

        if (pathPiece[pathPiece.length - 1] === '[') {
    
    
            continue;
        }

        if (/^(html|body|p|div|h[1-7]|table)\[{
    
    0,1}/.test(pathPiece)) {
    
    
            endIndex = i + 1;
            break;
        }
    }

    return pathArr.slice(0, endIndex).join('/');
};


/**
 * 多租户传递的参数
 */
 export function getTenantParams() {
    
    
    const search = location.search;
    if (search.startsWith('?u=')) {
    
    
        const url = decodeURIComponent(search.split('?u=')[1]);
        const queryUrl = {
    
    };
        const dz_url = url.split('#')[0];
        if (dz_url.split('?') && dz_url.split('?')[1]) {
    
    
            const cs = dz_url.split('?') && dz_url.split('?')[1];
            const cs_arr = cs.split('&');
            if (cs_arr.length === 0) {
    
    
                return {
    
    };
            }
            for (let i = 0; i < cs_arr.length; i++) {
    
    
                const name = decodeURIComponent(cs_arr[i].split('=')[0]);
                const value = decodeURIComponent(cs_arr[i].split('=')[1]);
                queryUrl[name] = value;
            }
        }
        return queryUrl;
    } else {
    
    
        const queryUrl = {
    
    };
        if (search.split('?') && search.split('?')[1]) {
    
    
            const cs = search.split('?') && search.split('?')[1];
            const cs_arr = cs.split('&');
            if (cs_arr.length === 0) {
    
    
                return {
    
    };
            }
            for (let i = 0; i < cs_arr.length; i++) {
    
    
                const name = decodeURIComponent(cs_arr[i].split('=')[0]);
                const value = decodeURIComponent(cs_arr[i].split('=')[1]);
                queryUrl[name] = value;
            }
        }
        return queryUrl;
        // 需要确认#啥时候加上去
        // return queryString.parse(search);
    }
}

export function getTenantCookieName() {
    
    
    return 'tenant-' + window.location.port;
}

// cookie
export function setTenantData(tenantData) {
    
    
    if (tenantData && tenantData.namespace) {
    
    
        Cookies.set(getTenantCookieName(), encodeURIComponent(JSON.stringify(tenantData)))
    }
}

// 从链接取，取不到从cookie取
export function getTenantData() {
    
    
    const tenantData = getTenantParams();
    if (tenantData.namespace) {
    
    
        setTenantData(tenantData);
        return tenantData;
    }
    return JSON.parse(decodeURIComponent(Cookies.get(getTenantCookieName()) || '{}'));
}

export function getAdminAddress() {
    
    
    const hostName = window.location.hostname;
    const protocol = window.location.protocol;

    const tenantParams = getTenantData();
    let adminPort = '8080';
    if (tenantParams.adminPort) {
    
    
        adminPort = tenantParams.adminPort;
    }
    return `${
    
    protocol}//${hostName}:${adminPort}`;
}

export function getTenantHeaders() {
    
    
    const headers = {
    
    };
    const {
    
    namespace, orgId, projectId} = getTenantData();
    if (namespace) {
    
    
        orgId && (headers['orgId'] = orgId);
        projectId && (headers['projectId'] = projectId);
    }
    return headers;
}

export const tenantHeader = getTenantHeaders();

export function downloadFileByOriUrl(url, name) {
    
    
    axios.get(`${
    
    tenantUrlPrefix}${
    
    url}`,
        {
    
    responseType: 'blob', headers: tenantHeader}).then(res => {
    
    
        const fileName = name || decodeURI((_get(res,
            'headers.content-disposition') || '')).split('filename=')[1];
        fileDownload(res.data, `${
    
    fileName}`);
    });
}

//  文件预览以及下载使用前缀
export function getTenantUrlPrefix (baseUrl) {
    
    
    let {
    
    namespace, prefix} = getTenantData();
    if (namespace) {
    
    
        if (prefix) {
    
    
            prefix = '/' + prefix;
        } else {
    
    
            prefix = '';
        }
        return  prefix + '/' + namespace + (baseUrl || '');
    }
    return (baseUrl || '');
    
}
export const tenantUrlPrefix = getTenantUrlPrefix ();

// url判断开头,重新拼接
export function multiTenantPrefix(parameter){
    
    
    if (tenantUrlPrefix) {
    
    
        let urlPrefix = /(http|https):\/\/([\w.]+\/?)\S*/;
        let objExp = new RegExp(urlPrefix);
        if (objExp.test(parameter)) {
    
    
            // let definitionUrl = new URL(parameter)
            // let {protocol, host, pathname, search} = definitionUrl
            // return protocol + '//' + host + tenantUrlPrefix + pathname + search
            // 带http绝对路径后端自己拼前缀
            return parameter;
        }else if(!!parameter.match(/^[.]/)){
    
    
            return parameter
        }else {
    
    
            return tenantUrlPrefix + parameter
        }     
    } else {
    
    
        return parameter
    }
}

// 相对路径，绝对路径判断
export function pathJudgment(parameter){
    
    
    let mediaPrefix = /(http|https):\/\/([\w.]+\/?)\S*/;
    let objExp = new RegExp(mediaPrefix);
    if (!objExp.test(parameter)){
    
    
        let urlPath = `http://${window.location.host}`+ getTenantUrlPrefix(parameter);
        return urlPath
    }else {
    
    
        return parameter
    }
}

// 去除多余的<em>标签
export function replaceEmTag(val) {
    
    
    if (typeof val === 'string') {
    
    
        return val.replace(/<em>/g, '').replace(/<\/em>/g, '');
    }
    else {
    
    
        return val;
    }
}

/**
 * 表单验证部分
 */
const getBLen = function(str) {
    
    
    if (str === null) {
    
    
        return 0;
    }

    let len = 0;
    for (let i = 0; i < str.length; i++) {
    
    
        let a = str.charAt(i);
        if (a.match(/[^\x00-\xff]/ig) != null) {
    
    
            len += 2;
        }
        else {
    
    
            len += 1;
        }
    }
    return len;
}

export const validate = {
    
    
    whitespace(rule, value, callback) {
    
    
        const msg = rule.message || '不能为空';
        if (value.toString().trim() === '') {
    
    
            callback(new Error(msg));
        }

        callback();
    },
    length(rule, value, callback) {
    
    
        const msg = rule.message || `不得超过${
    
    rule.max}个字符`;
        if (value && value.trim && (value.trim().length > rule.max)) {
    
    
            callback(new Error(msg));
        }

        callback();
    },
    bLength(rule, value, callback) {
    
    
        const msg = rule.message || `不得超过${
    
    rule.max}个字符`;
        if (value && value.trim && (getBLen(value.trim()) > rule.max)) {
    
    
            callback(new Error(msg));
        }

        callback();
    },
    name(rule, value, callback) {
    
    
        const msg = rule.message || `不符合校验规则`;

        if (value && !/^[a-zA-Z][a-zA-Z_]*$/.test(value)) {
    
    
            callback(new Error(msg));
        }

        callback();
    },
    aliasLength(rule, value, callback) {
    
    
        const msg = rule.message || `不得超过${
    
    rule.max}个字符`;
        if (value === undefined || value.length === 0) {
    
    
            callback();
        }
        else {
    
    
            let aliasArray = value.split(/[,，]/);
            let invalidAlias = aliasArray.filter(alias => {
    
    
                return alias.length > rule.max;
            });

            if (invalidAlias.length > 0) {
    
    
                callback(new Error(msg));
            }
            else {
    
    
                callback();
            }
        }
    },
    aliasListLength(rule, value, callback) {
    
    
        const msg = rule.message || `不得超过${
    
    rule.max}个别名`;
        if (value === undefined || value.length === 0) {
    
    
            callback();
        }
        else {
    
    
            let aliasArray = value.split(/[,，]/);
            if (aliasArray.length > rule.max) {
    
    
                callback(new Error(msg));
            }
            else {
    
    
                callback();
            }
        }
    },
    url(rule, value, callback) {
    
    
        const msg = rule.message || `URL不合法`;

        const strRegex = '^((https|http|ftp)://)?'                  //(https或http或ftp):// 可有可无
        + '(([\\w_!~*\'()\\.&=+$%-]+: )?[\\w_!~*\'()\\.&=+$%-]+@)?' //ftp的user@ 可有可无
        + '(([0-9]{1,3}\\.){3}[0-9]{1,3}'                           // IP形式的URL- 3位数字.3位数字.3位数字.3位数字
        + '|'                                                       // 允许IP和DOMAIN（域名）
        + '(localhost)|'                                            //匹配localhost
        + '([\\w_!~*\'()\-]+\\.)*'                                  // 域名- 至少一个[英文或数字_!~*\'()-]加上.
        + '[\\w_!~*\'()\-]+\\.'                                     // 一级域名 -英文或数字 加上.
        + '[a-zA-Z]{1,6})'                                          // 顶级域名- 1-6位英文
        + '(:[0-9]{1,5})?'                                          // 端口- :80 ,1-5位数字
        + '((/?)|'                                                  // url无参数结尾 - 斜杆或这没有
        + '(/[\\w_!~*\'()\\.;?:@&=+$,%#-]+)+/?)$';                  //请求参数结尾- 英文或数字和[]内的各种字符

        const re = new RegExp(strRegex, 'i');
        if (re.test(value)) {
    
    
            callback();
        }
        else {
    
    
            callback(new Error(msg));
        }
    },
    agreementUrl(rule, value, callback) {
    
    
        const msg = rule.message || `URL不合法`;

        const strRegex = '^((https|http|ftp)://)'                  //(https或http或ftp):// 必须有
        + '(([\\w_!~*\'()\\.&=+$%-]+: )?[\\w_!~*\'()\\.&=+$%-]+@)?' //ftp的user@ 可有可无
        + '(([0-9]{1,3}\\.){3}[0-9]{1,3}'                           // IP形式的URL- 3位数字.3位数字.3位数字.3位数字
        + '|'                                                       // 允许IP和DOMAIN（域名）
        + '(localhost)|'                                            //匹配localhost
        + '([\\w_!~*\'()\-]+\\.)*'                                  // 域名- 至少一个[英文或数字_!~*\'()-]加上.
        + '[\\w_!~*\'()\-]+\\.'                                     // 一级域名 -英文或数字 加上.
        + '[a-zA-Z0-9]{1,6})'                                       // 顶级域名- 1-6位英文
        + '(:[0-9]{1,5})?'                                          // 端口- :80 ,1-5位数字
        + '((/?)|'                                                  // url无参数结尾 - 斜杆或这没有
        + '(/[\\w_!~*\'()\\.;?:@&=+$,%#-]+)+/?)$';                  //请求参数结尾- 英文或数字和[]内的各种字符

        const re = new RegExp(strRegex, 'i');
        if (value) {
    
    
            if (re.test(value)) {
    
    
                callback();
            }
            else {
    
    
                callback(new Error(msg));
            }
        }
        else {
    
    
            callback();
        }
    },
    chnEngNumLine(rule, value, callback) {
    
    
        const msg = rule.message || `仅支持输入中英文、数字、下划线和横线，且不能以下划线开头。`;
        const strRegex = /^(?!_)[a-zA-Z0-9_\u4e00-\u9fa5]+$/;

        const re = new RegExp(strRegex);
        if (re.test(value)) {
    
    
            callback();
        }
        else {
    
    
            callback(new Error(msg));
        }
    },
    chnEngNumLines(rule, value, callback) {
    
    
        const msg = rule.message || `仅支持输入中英文、数字、下划线和横线，且不能以下划线开头。`;
        const strRegex = /^((?!_)[a-zA-Z0-9_\u4e00-\u9fa5]|_(?!_))+$/;

        const re = new RegExp(strRegex);
        if (re.test(value)) {
    
    
            callback();
        }
        else {
    
    
            callback(new Error(msg));
        }
    },
    chnEng(rule, value, callback) {
    
    
        const msg = rule.message || `仅支持输入中文、英文。`;
        const strRegex = /^[a-zA-Z\u4e00-\u9fa5]+$/;

        const re = new RegExp(strRegex);
        if (re.test(value)) {
    
    
            callback();
        }
        else {
    
    
            callback(new Error(msg));
        }
    },
    engNum(rule, value, callback) {
    
    
        const msg = rule.message || `仅支持输入英文、数字。`;
        const strRegex = /^[a-zA-Z0-9]+$/;

        const re = new RegExp(strRegex);
        if (re.test(value)) {
    
    
            callback();
        }
        else {
    
    
            callback(new Error(msg));
        }
    },
    chnEngNum(rule, value, callback) {
    
    
        const msg = rule.message || `仅支持输入中文、英文和数字。`;
        const strRegex = /^[a-zA-Z\u4e00-\u9fa50-9]+$/;

        const re = new RegExp(strRegex);
        if (re.test(value)) {
    
    
            callback();
        }
        else {
    
    
            callback(new Error(msg));
        }
    },
    filter(rule, value, callback) {
    
    
        const msg = rule.message || `输入不合法，请重试。`;

        const regexArr = rule.category.map(item => {
    
    
            return validateFilter[item];
        });

        const strRegex = `^[${
    
    regexArr.join('')}]+$`;
        const re = new RegExp(strRegex);
        if (re.test(value)) {
    
    
            callback();
        }
        else {
    
    
            callback(new Error(msg));
        }
    },
    emoji(rule, value, callback) {
    
    
        const msg = rule.message || `请勿输入表情`;

        if (!isEmojiCharacter(value)) {
    
    
            callback();
        }
        else {
    
    
            callback(new Error(msg));
        }
    },
    telephone(rule, value, callback) {
    
    
        const msg = rule.message || `手机号码不合法`;
        const strRegex = /^(13[0-9]|14[01456879]|15[0-35-9]|16[2567]|17[0-8]|18[0-9]|19[0-35-9])\d{
    
    8}$/;

        const re = new RegExp(strRegex);
        if (re.test(value)) {
    
    
            callback();
        }
        else {
    
    
            callback(new Error(msg));
        }
    }
};

export const isEmojiCharacter = (value) => {
    
    
    value = String(value);
     for (let i = 0; i < value.length; i++) {
    
    
         const hs = value.charCodeAt(i);
         if (0xd800 <= hs && hs <= 0xdbff) {
    
    
             if (value.length > 1) {
    
    
                 const ls = value.charCodeAt(i + 1);
                 const uc = ((hs - 0xd800) * 0x400) + (ls - 0xdc00) + 0x10000;
                 if (0x1d000 <= uc && uc <= 0x1f77f) {
    
    
                     return true;
                 }
             }
         } else if (value.length > 1) {
    
    
             const ls = value.charCodeAt(i + 1);
             if (ls == 0x20e3) {
    
    
                 return true;
             }
         } else {
    
    
             if (0x2100 <= hs && hs <= 0x27ff) {
    
    
                 return true;
             } else if (0x2B05 <= hs && hs <= 0x2b07) {
    
    
                 return true;
             } else if (0x2934 <= hs && hs <= 0x2935) {
    
    
                 return true;
             } else if (0x3297 <= hs && hs <= 0x3299) {
    
    
                 return true;
             } else if (hs == 0xa9 || hs == 0xae || hs == 0x303d || hs == 0x3030
                     || hs == 0x2b55 || hs == 0x2b1c || hs == 0x2b1b
                     || hs == 0x2b50) {
    
    
                 return true;
             }
         }
     }
    return false;
 }

const validateFilter = {
    
    
    chn: '\u4e00-\u9fa5',
    eng: 'a-zA-Z',
    num: '0-9',
    quote: '"\'“”‘’',
    colon: ':：',
    bracket: '\(\)（）',
    underline: '\_',
    dot: '\\.',
    dash: '\\-',
    caesura: '、'
}

export const getDisplayPattern = (pattern, currentClass, property, type) => {
    
    
    const categoryReg = new RegExp(`\\[D:category\\]`, 'g');
    const subjectReg = new RegExp(`\\[D:subject\\]`, 'g');
    let subjectCounter = 0;
    const objectReg = new RegExp(`\\[D:object\\]`, 'g');
    let objectCounter = 0;
    const propertyReg = new RegExp(`\\[D:(${
    
    property.id})\\]`, 'g');
    const differenceReg = new RegExp(`\\[D:difference\\]`, 'g');
    const extremalReg = new RegExp(`\\[D:extremal\\]`, 'g');

    pattern = pattern.replace(categoryReg, () => {
    
    
        return `<span class="spo-tag el-tag el-tag--mini el-tag--deeppurple el-tag--light">${
    
    currentClass.label}</span>`;
    });

    pattern = pattern.replace(subjectReg, () => {
    
    
        subjectCounter++;
        return `<span class="spo-tag el-tag el-tag--mini el-tag--light">${
    
    currentClass.label}${
    
    subjectCounter}</span>`;
    });

    pattern = pattern.replace(objectReg, () => {
    
    
        objectCounter++;
        return `<span class="spo-tag el-tag el-tag--mini el-tag--success el-tag--light">${
    
    property.name}${
    
    objectCounter}</span>`;
    });

    pattern = pattern.replace(propertyReg, (matchString, predicate, matchStringIndex, template) => {
    
    
        return `<span class="spo-tag el-tag el-tag--mini el-tag--bluegray el-tag--light">${
    
    property.name}</span>`;
    });

    pattern = pattern.replace(differenceReg, () => {
    
    
        return `<span class="spo-tag el-tag el-tag--mini el-tag--brown el-tag--light">差值</span>`;
    });

    pattern = pattern.replace(extremalReg, () => {
    
    
        return `<span class="spo-tag el-tag el-tag--mini el-tag--brown el-tag--light">最值</span>`;
    });

    return pattern;
};

/**
 * 格式化日期方法
 * @param {string} fmt 输出格式
 * @param {date} date date类型参数
 * @return {string} 格式化结果
 */
export const dateFormat = (fmt, date) => {
    
    
    let ret;
    const opt = {
    
    
        "Y+": date.getFullYear().toString(),        // 年
        "m+": (date.getMonth() + 1).toString(),     // 月
        "d+": date.getDate().toString(),            // 日
        "H+": date.getHours().toString(),           // 时
        "M+": date.getMinutes().toString(),         // 分
        "S+": date.getSeconds().toString()          // 秒
    };
    for (let k in opt) {
    
    
        ret = new RegExp("(" + k + ")").exec(fmt);
        if (ret) {
    
    
            fmt = fmt.replace(ret[1], (ret[1].length == 1) ? (opt[k]) : (opt[k].padStart(ret[1].length, "0")))
        };
    };
    return fmt;
}

/**
 * 格式化数字方法
 * @param {number} num 输出格式
 * @param {number} separator 几位加逗号
 * @return {string} 格式化结果
 */
export const formatSeparator = (num, separator) => {
    
    
    separator = separator || 3;
    let reg = `(\\d)(?=(?:\\d{
    
    ${
    
    separator}})+$)`;
    return (num || 0).toString().replace(new RegExp(reg, 'g'), '$1,');
}

/**
 * 简写数字方法
 * @param {number} num 输出格式
 * @return {string} 格式化结果
 */
export const formatNum = (num) => {
    
    
    if (num >= 100000000000) {
    
    
        return `${
    
    Math.floor(num / 1000000000) / 100}万亿+`;
    }
    else if (num >= 100000000) {
    
    
        return `${
    
    Math.floor(num / 1000000) / 100}亿+`;
    }
    else if (num >= 100000) {
    
    
        return `${
    
    Math.floor(num / 100) / 100}万+`;
    }
    else {
    
    
        return num;
    }
}

/**
 * 数组转成对象
 * @param {array} array
 * @param {string} key
 * @return {object} 转化结果
 */
export const covertArrayToObject = (array, key) => {
    
    
    if (!Array.isArray(array)) {
    
    
        return {
    
    };
    }

    let result = {
    
    };

    array.filter(item => item[key]).forEach(item => {
    
    
        result[item[key]] = item;
    });

    return result;
}

/**
 * 对象转成数组
 * @param {object} object
 * @param {string} key
 * @return {array} 转化结果
 */
export const covertObjectToArray = (object, key) => {
    
    
    return Object.keys(object).map(value => {
    
    
        let result = {
    
    
            ...object[value]
        };

        result[key] = value;
        return result;
    });
}

export const queryMatching = (val,keyWord) => {
    
    
    const Reg = new RegExp(keyWord, 'i');
    let res = '';
    val = val + ''  //字符串
    if (val) {
    
    
        res = val.replace(Reg, `<span style="color: #2468F2;">${
    
    keyWord}</span>`);
        return res;
    }
}

export const deleteAdvancedQuery = (queryObj = {
    
    }) => {
    
    
    delete queryObj.q1;
    delete queryObj.q2;
    delete queryObj.q3;
    delete queryObj.q4;
    delete queryObj.format;
    delete queryObj.queryfileType;
    delete queryObj.querylang;
    delete queryObj.queryauthor;
    delete queryObj.startDate;
    delete queryObj.endDate;
    delete queryObj.author;
    delete queryObj.fileType;
    delete queryObj.fromSource;
    delete queryObj.catogory;
    delete queryObj.tags;
    delete queryObj.keywords;
    delete queryObj.searchType;

    return queryObj;
}