TBA_GXPT/ruoyi-ui/src/utils/biz.js

import request from "@/utils/request";
import jp from 'jsonpath';
import qs from "qs";
import {isArray} from "@/utils/validate";
import {objectMerge} from "@/utils/index";
import {getYAxisListByUnit} from "@/utils/chart";
import {formatStringByTemplate} from "@/utils/string";
import {getBizDataById} from "@/api/standardization/bizDataShowConfig.js";

/**
 * 查询业务接口信息数据及业务数据
 * @param id              业务编码
 * @returns {Promise<*>}
 */
// export async function getBizDataByAid(id, params) {
//   if (!id) {
//     return null;
//   }
//
//   let bizData = await getBizConfigById(id).then(r => r.data)
//
//   if (params) {
//     if (!bizData.params) {
//       bizData.params = {}
//     }
//     objectMerge(bizData.params, params)
//   }
//
//   let dataList = await getBizData(bizData)
//   if (dataList) {
//     bizData.dataList = dataList
//   }
//   return bizData
// }


/**
 * 查询业务数据
 * @param biz 业务详情
 */
export async function getBizData(biz) {
    let data = null;
    if (biz.type === 'api') {
        // 1. 从接口查询数据
        data = await getApiData(biz)
    } else {
        // 2. 从文件查询数据
        data = await getFileData(biz)
    }
    if (!data) {
        // 数据请求失败
        return null;
    }

    // 转换格式
    let list = []
    const keys = Object.keys(biz.resParams || {});
    if (isArray(data)) {
        if (keys.length === 0) {
            return data;
        }
        for (let i = 0; i < data.length; i++) {
            let d = data[i]
            let dd = {}

            keys.forEach(key => {
                dd[biz.resParams[key]] = d[key]
            })
            list.push(dd);
        }
    } else {
        if (keys.length === 0) {
            return [data];
        }
        let dd = {}
        keys.forEach(key => {
            dd[biz.resParams[key]] = data[key]
        })
        list.push(dd);
    }

    return list;
}

async function getApiData(biz) {
    let isFormData = false
    if (biz.header && JSON.stringify(biz.header).indexOf('application/x-www-form-urlencoded') > 0) {
        isFormData = true
    }
    // 1. 查询数据
    let requestData = {
        url: biz.url,
        method: biz.method,
        headers: biz.header,
        timeout: 960 * 1000,
    }
    if (biz.method === 'GET') {
        requestData.params = biz.params
    } else {
        requestData.data = isFormData ? qs.stringify(biz.params) : biz.params
    }
    let r = await request(requestData)
    // 返回值格式转JSON
    // r = getJSONResponse(r)
    // 解析格式
    return parsingFormat(r, biz.resFormat, biz.params)
}

async function getFileData(biz) {
    let r = await request({
        url: '/att/biz/api/getBizDataByFileUrl',
        params: {fileUrl: biz.url}
    })
    // 返回值格式转JSON
    // r = getJSONResponse(r)
    // 解析格式
    return parsingFormat(r, biz.resFormat, biz.params)
}

function getJSONResponse(res) {
    let data = this.x2js.xml2js(r);
}

/**
 * 解析返回值格式
 * @param r       返回值
 * @param format  解析格式
 * @param params  传参
 * @returns {*}
 */
function parsingFormat(r, format, params) {
    format = format || '$.data';
    const reg = /\{(.+?)\}/;
    const reg_g = /\{(.+?)\}/g;
    const result = format.match(reg_g);
    if (result && result.length > 0) {
        for (let i = 0; i < result.length; i++) {
            let item = result[i]
            let value = params[item.match(reg)[1]];
            format = format.replace(item, value);
        }
    }
    return jp.query(r, format)[0];
}

export async function getDataByDataId(id) {
    if (!id) {
        return null
    }
    const bizDataRes = await getBizDataById(id)
    if (!bizDataRes?.data || bizDataRes?.data?.length === 0) {
        return null
    }
    return bizDataRes.data;
}

export async function getChartOption(config) {
    const data = await getDataByDataId(config.id)
    if (!data || data.length === 0) {
        return {}
    }

    const renderingOptions = config.renderingOptionsData
    switch (renderingOptions.chartType) {
        case 'linebar':
            return getBarLineChartOption(renderingOptions, data)
        case 'pie':
            return getPieChartOption(renderingOptions, data)
    }
}

function getBarLineChartOption(config, data) {
    let option = {
        grid: config.grid,
        tooltip: {
            trigger: 'axis',
        },
    }
    let xparams = config.xparams;
    let yparams = config.yparams;

    const legendSelected = {};
    yparams.forEach(item => {
        legendSelected[item.name.value] = item.selected
    })
    const legend = {
        data: yparams.map(item => item.name.value),
        selected: legendSelected,
    };
    if (legend.data.length > 30) {
        legend.type = 'scroll';
    }
    option.legend = objectMerge(config.legend, legend);

    option.xAxis = {
        data: data.map((item) => {
            return item[xparams[0].key]
        }),
        axisLine: {
            show: true,
        },
    }
    option.xAxis = objectMerge(config.xAxis, option.xAxis)

    let yAxis = getYAxisListByUnit(Array.from(new Set(yparams.map(i => i.unit))));
    yAxis = yAxis.map(y => objectMerge(config.yAxis, y));
    option.yAxis = yAxis

    const series = [];
    yparams.forEach((y, index) => {
        const serie = {
            type: y.type,
            name: y.name.value,
            yAxisIndex: yAxis.map(i => i.name).indexOf(y.unit),
            data: data.map(item => item[y.name.key]),
        }
        // 柱状图样式配置
        if (y.type === 'bar') {
            serie.itemStyle = {}
            serie.showBackground = config.series.showBackground
            serie.itemStyle.borderRadius = config.series.itemStyle.borderRadius
            serie.itemStyle.barWidth = config.barWidth
            if (config.color && index < config.color.length) {
                serie.itemStyle.color = config.color[index]
            }
        } else if (y.type === 'line') {
            serie.itemStyle = {}
            serie.itemStyle.opacity = config.lineShow ? 1 : 0
            serie.smooth = config.smooth
            if (config.lineColors && index < config.lineColors.length) {
                serie.itemStyle.color = config.lineColors[index]
            }
            serie.symbolSize = config.symbolSize
            serie.areaStyle = {}
            serie.areaStyle.opacity = config.areaShow ? 1 : 0
            if (config.areaColors && index < config.areaColors.length) {
                serie.areaStyle.color = config.areaColors[index]
            }
        }
        series.push(serie);
    });
    series.forEach(s => {
        s = objectMerge(config.series, s)
        // if (s.type === 'bar') {
        // }
    })
    option.series = series
    return option;
}

function getPieChartOption(config, data) {
    let option = {
        grid: config.grid,
        tooltip: {
            trigger: 'item',
            formatter: '{a} <br/>{b} : {c} ({d}%)'
        },
        legend: config.legend,
        series: []
    }
    config.series.data = data.map((d, index) => {
        const seriesData = {
            name: d[config.nameField],
            value: d[config.valueField],
        }

        if (config.color && index < config.color.length) {
            seriesData.itemStyle = {color: config.color[index]}
        }
        return seriesData
    })

    config.series.type = 'pie';
    config.series.name = config.valueField;
    option.series.push(config.series);

    console.log('option', option)
    return option;
}

export async function getTableData(config) {
    const dataList = await getDataByDataId(config.id)
    if (!dataList || dataList.length === 0) {
        return []
    }
    return dataList;
}

export async function getFormListData(config) {
    const dataList = await getDataByDataId(config.id)
    if (!dataList || dataList.length === 0) {
        return []
    }

    let data = dataList[0]
    if (!isArray(dataList)) {
        data = dataList
    }

    const list = []
    config.renderingOptionsData.columns.forEach(column => {
        list.push({name: column.value, value: data[column.key]})
    })
    return list;
}

export async function getText(config) {
    let dataList = await getDataByDataId(config.dataId)
    if (!dataList || dataList.length === 0) {
        return ''
    }

    if (config.dataFormat === 'OBJECT') {
        dataList = dataList[0]
    }

    return formatStringByTemplate(dataList, config.template);
}