dx-element-ui/packages/list/src/tool-list.js

import request from '../../../src/tools/request';
import {
    isTypeof,
    isArrayInnerValue,
    objectMerge,
    axiosReqParams,
    responseKeyToValue,
    responseNodeParseList,
    parseRequestParams,
    mergeRequestParams
} from '../../../src/tools/utils';

//弹出宽显示按钮
const btnList = function (number, type = 'submit') {
    let tmpNumber = number
    const defaultList = {
        iShow: true,
        list: []
    }

    if (isTypeof(number) === 'undefined') {
        tmpNumber = 3 // 3为全部按钮
    }

    if ((tmpNumber & 1) === 1) {
        defaultList.list.push({ label: '取消', type: 'close', bType: 'info', icon: 'el-icon-close' })
    }

    if ((tmpNumber & 2) === 2) {
        defaultList.list.push({ label: '确认', type: type, bType: 'primary', icon: 'el-icon-check' })
    }

    return defaultList
};

//根据key获取row的值
let getFieldToValue = function (row, field) {
    let res = '';

    if (isTypeof(row) === 'array') {
        let vals = [];

        row.forEach(item => {
            vals.push(item[field]);
        });

        res = vals.join(',');
    } else {
        res = row[field];
    }

    return res;
}

//整理代码
export function initVueData(tag) {
    let options = {},
        option = {
            keys: 1,
            row: {},
            finds: {},
            order: {},
            where: {},
            tableData: [],
            loading: true,
            tableName: tag,
            checkboxVal: [],
            showColumns: [],
            columnOptions: [],
            tableListResponse: null,
            dialogDelTableVisible: false,
            dialogEditTableVisible: false,
            dialogExecTableVisible: false,
            loadTableTreeNodeMap: new Map(),
            add_edit_dialog: '80%',
            del_dialog: '40%',
            labelPosition: 'left',
            inputType: 'show',
            pages: {
                pageSize: 10, //默认每页的数据量
                currentPage: 1, //当前页码
                pageNum: 1, //查询的页码
                totalCount: 0,
                pageSizes: [10, 30, 50, 100],
                style: 'text-align: center;',
                layout: 'total, sizes, prev, pager, next, jumper'
            },
            //操作按钮
            //buttonsList: [],
            //list请求的默认参数
            /*queryParam: [
                {
                    type: 1,
                    key: 'page',
                    value: 'pageNum'
                },{
                    type: 1,
                    key: 'size',
                    value: 'pageSize'
                }
            ],*/
            //操作删除校验规则
            /*optRules: {
                isRules: true,
                method: 'post',
                url: '/scnInfo/pageList',
                params: {
                    busCode: getFieldToValue,
                    pageNum: 1,
                    pageSize: 10
                },
                message: '该记录在数据中有关联，请先删除关联数据！'
            },*/
            //dialog按钮操作
            //dialogFooter: {},
            //composeParam: ['id'],//删除字段主键
            queryURL: {
                del: {
                    url: '',
                    method: 'get',
                    name: 'companyName'
                },
                add: {
                    url: '',
                    method: 'post'
                },
                edit: {
                    url: '',
                    method: 'post'
                },
                list: {
                    url: '',
                    method: 'post',
                    parse: {
                        tableData: ['data', 'data'],
                        totalCount: ['data', 'total']
                    }
                },
                name: '默认'
            },
            /*axios: {
                timeout: 5000,
                headers: {}
            }*/
        };

    Object.assign(options, option);

    if (arguments.length > 1) {
        options = objectMerge(options, arguments[1]());
    }

    return options;
};

export function messageFun(message, type, time) {
    message = message ? message : '错误';
    time = time ? time : 3000;
    type = type ? type : 'success';

    Message({
        message: message,
        type: type,
        duration: time
    });
}

//table全局操作事件
export function utilBtnEventList(obj, btnObj) {
    if (isTypeof(btnObj) === 'string') {
        tableEventList(obj, btnObj, {}, 'all');
    } else if (isTypeof(btnObj) === 'object') {
        if (btnObj.hasOwnProperty('event')) {
            tableEventList(obj, btnObj, {}, 'all');
        } else {
            updateShowColumns(obj, btnObj);
        }
    } else {
        messageFun('按钮事件方法未处理，请确认。', 'error', 3000);
    }
}

//table表中的操作请求入口
export function unitTableAllEvent(obj, args) {
    let row = args[0] || {},
        btnObj = args[1] || '';

    if (isTypeof(btnObj) === 'object') {
        btnObj.event = btnObj.type || '';
    }
    tableEventList(obj, btnObj, row, 'only');
}

//事件处理机制
export function tableEventList(obj, btnObj, row, opType = 'only') {
    const type = btnObj.event;

    obj.currEventObj = btnObj;
    obj.url = obj.queryURL[type] && obj.queryURL[type].url;
    obj.method = obj.queryURL[type] && obj.queryURL[type].method;
    obj.autoParams = obj.queryURL[type] && obj.queryURL[type].params;
    obj.autoMethodType = obj.queryURL[type] && obj.queryURL[type].methodType;
    obj.demandList = obj.queryURL[type] && obj.queryURL[type].demandList ? obj.queryURL[type].demandList : null;
    obj.currAxios = obj.queryURL[type] && obj.queryURL[type].axios ? Object.assign({}, obj.axios, obj.queryURL[type].axios) : obj.axios;

    obj.inputType = 'show';
    obj.add_edit_dialog = obj.queryURL[type] && obj.queryURL[type].width ? obj.queryURL[type].width : '80%';
    switch (type) {
        case 'add':
            unitAddCellData(obj);
            break;
        case 'delAll':
            if (obj.queryURL[type]) {
                if (obj.queryURL['del'] && isTypeof(obj.queryURL['del']) === 'object') {
                    for (let [k, v] of Object.entries(obj.queryURL['del'])) {
                        if (!obj.queryURL[type].hasOwnProperty(k)) {
                            obj.queryURL[type][k] = v;
                        }
                    }
                }
            } else {
                obj.queryURL[type] = Object.assign({}, obj.queryURL['del']);
            }

            obj.url = obj.url || (obj.queryURL['del'] && obj.queryURL['del'].url ? obj.queryURL['del'].url : '');
            if (obj.url) {
                unitDelAllCell(obj, type);
            } else {
                obj.$message.error('请在queryURL中配置del参数！')
            }
            break;
        case "edit":
            let rowType = obj.queryURL[type] && obj.queryURL[type].rowType ? obj.queryURL[type].rowType : false;

            if (rowType) {
                if (obj.queryURL && obj.queryURL['byid']) {
                    unitEditRowDataById(obj, row);
                } else {
                    obj.$message.error('请在queryURL中配置byid参数！')
                }
            } else {
                unitEditCellData(obj, row);
            }
            break;
        case "detail":
            obj.inputType = 'detail';
            // 自定义操作
            if (btnObj.custom) {
                obj.$emit('onListEvent', type, row);//自定义事件
                break
            }
            if (obj.queryURL['detail']) {
                unitDetailRowDataById(obj, row);
            } else {
                unitDetailCellData(obj, row);
            }
            break;
        case "del":
            if (obj.queryURL[type]) {
                unitRemoveCellData(obj, type, row);
            } else {
                obj.$message.error('请在queryURL中配置del参数！')
            }
            break;
        default:
            if (type !== 'list' && type !== 'byid' && obj.queryURL.hasOwnProperty(type)) {
                obj.inputType = type;

                if (opType == 'all') {
                    const currCheckedList = unitGetCheckedList(obj);

                    if (currCheckedList.length > 0) {
                        if (isTypeof(obj.queryURL[type].only) === 'number') {
                            if (obj.queryURL[type].only > 0 && currCheckedList.length !== obj.queryURL[type].only) {
                                obj.$message.error('该操作只允许选择' + obj.queryURL[type].only + '条记录！');
                                return false;
                            }
                        } else if (obj.queryURL[type].only && currCheckedList.length > 1) { // 只允许选择一行
                            obj.$message.error('该操作只允许选择一条记录！');
                            return false;
                        }

                        row = obj.queryURL[type].only ? currCheckedList[0] : currCheckedList;
                    } else {
                        // required默认值为true，required为false不需要传值
                        if (!obj.queryURL[type].hasOwnProperty('required')
                            || (obj.queryURL[type].hasOwnProperty('required') && obj.queryURL[type].required)) {
                            obj.$message.error('请您至少选择一条操作记录！');
                            return false;
                        }
                    }
                }
                if (obj.queryURL[type].hasOwnProperty('query') && isTypeof(obj.queryURL[type].query) === 'object') {
                    unitOtherOptRowDataById(obj, type, row)
                } else {
                    let tmpRow = row;
                    if (obj.queryURL[type].hasOwnProperty('emit') && obj.queryURL[type].emit) {
                        tmpRow = emitOnDataRow(obj, type, row) || row;
                    }
                    unitOtherOptCellData(obj, type, tmpRow);
                }
            } else {
                if (obj.$listeners && !obj.$listeners.onListEvent) {
                    console.error('未定义emit方法：onListEvent, ' + type)
                }
                obj.$emit('onListEvent', type, row, btnObj);//自定义事件
            }
    }
}

//选择显示的项
function updateShowColumns(obj, currList) {
    obj.showColumns = currList.showColumns;
    obj.keys = currList.keys;
}

export function actionBtnList(obj, type) {
    const dialogFooter = obj.dialogFooter || {}
    const btnDefaultList = btnList(3)

    if (dialogFooter.hasOwnProperty('list')) {
        let list = [],
            res = Object.assign({}, dialogFooter);

        res.type = type;
        res.btnObj = obj.currEventObj;
        if (dialogFooter.isMerge) {
            Array.prototype.push.apply(list, dialogFooter.list);
            Array.prototype.push.apply(list, btnDefaultList.list);

            res.list = list;
        }

        return res;
    } else {
        btnDefaultList.type = type;
        btnDefaultList.btnObj = obj.currEventObj;

        return btnDefaultList;
    }
}

export function unitAddCellData(obj) {
    var _obj = {};
    _obj._btn = actionBtnList(obj, 'add');
    _obj._title = (obj.queryURL.add && obj.queryURL.add.title) ? obj.queryURL.add.title : ("增加" + obj.queryURL.name);
    _obj._url = obj.url;
    _obj._method = obj.method;
    _obj._axios = obj.axios;
    _obj._params = obj.autoParams;
    _obj.methodType = obj.autoMethodType;

    obj.row = _obj;

    unitIsDemandSelectList(obj);
    obj.dialogDelTableVisible = false;
    obj.dialogEditTableVisible = true;
}

export function unitRowObjectMerge(item, row) {
    if (item.concat && isTypeof(item.concat) === 'array') {
        let tmpData = {};

        item.concat.forEach(key => {
            if (row[key] && isTypeof(row[key]) === 'object') {
                tmpData = Object.assign(tmpData, row[key])
            }
        })

        return tmpData || {};
    }

    return row || {};
}

// 其他请求方式获取编辑记录
export function unitOtherOptRowDataById(obj, type, row) {
    let queryData = {},
        item = obj.queryURL[type].query,
        key = item && item.key ? item.key : 'id',
        value = item && item.value ? item.value : key,
        axios = item && item.axios ? item.axios : obj.axios;

    if (item.params) {
        parseRequestParams(item.params, row, queryData);
    } else {
        queryData[key] = row[value];
    }
    request(axiosReqParams(item, mergeRequestParams(queryData, obj._publicParams), axios, obj.options)).then((response) => {
        let rowData = row,
            next = { keyType: 'result' };

        if (responseKeyToValue(response, obj, obj, next)) {
            const tmpData = responseNodeParseList(response, item.parse, 'object')

            if (item.hasOwnProperty('mergeList')) {
                if (isTypeof(item.mergeList) === 'array') {
                    item.mergeList.forEach(itemKey => {
                        rowData[itemKey] = tmpData[itemKey];
                    })
                } else if (isTypeof(item.mergeList) === 'object') {
                    for (let [kk, vv] of Object.entries(item.mergeList)) {
                        rowData[kk] = tmpData[vv];
                    }
                } else {
                    rowData = Object.assign({}, row, tmpData);
                }
            } else {
                rowData = Object.assign({}, row, tmpData);
            }
        }

        unitOtherOptCellData(obj, type, unitRowObjectMerge(item, rowData));
    }).catch((err) => {
        unitOtherOptCellData(obj, type, unitRowObjectMerge(item, row));
    });
}

// 通过byid获取row数据
export function unitEditRowDataById(obj, row) {
    let queryData = {},
        item = obj.queryURL['byid'],
        key = item && item.key ? item.key : 'id',
        value = item && item.value ? item.value : key,
        axios = item && item.axios ? item.axios : obj.axios;

    if (item.params) {
        parseRequestParams(item.params, row, queryData);
    } else {
        queryData[key] = row[value];
    }
    request(axiosReqParams(item, mergeRequestParams(queryData, obj._publicParams), axios, obj.options)).then((response) => {
        let rowData = row,
            next = { keyType: 'result' };

        if (responseKeyToValue(response, obj, obj, next)) {
            const tmpData = responseNodeParseList(response, item.parse, 'object')

            // 数据是否合并
            if (item.hasOwnProperty('mergeList')) {
                if (isTypeof(item.mergeList) === 'array') {
                    item.mergeList.forEach(itemKey => {
                        rowData[itemKey] = tmpData[itemKey];
                    })
                } else if (isTypeof(item.mergeList) === 'object') {
                    for (let [kk, vv] of Object.entries(item.mergeList)) {
                        rowData[kk] = tmpData[vv];
                    }
                } else {
                    rowData = Object.assign({}, row, tmpData);
                }
            } else {
                rowData = Object.assign({}, row, tmpData);
            }
        }

        unitEditCellData(obj, unitRowObjectMerge(item, rowData));
    }).catch((err) => {
        unitEditCellData(obj, unitRowObjectMerge(item, row));
    });
}

export function unitEditCellData(obj, row) {
    let editObj = obj.queryURL.edit,
        oldRow = Object.assign({}, row);

    obj.row = row;
    obj.row._oldData = oldRow;
    obj.row._btn = actionBtnList(obj, 'edit');
    obj.row._title = (editObj && editObj.title) ? (isTypeof(editObj.title) === 'function' ? editObj.title(row, obj) : editObj.title) : ("编辑" + obj.queryURL.name);
    obj.row._url = obj.url;
    obj.row._method = obj.method;
    obj.row._axios = obj.currAxios;
    obj.row._params = obj.autoParams;
    obj.row.methodType = obj.autoMethodType;

    unitIsDemandSelectList(obj);
    obj.dialogDelTableVisible = false;
    obj.dialogEditTableVisible = true;
}

export function unitOtherOptCellData(obj, type, row) {
    let objType = obj.queryURL[type] || {},
        oldRow = Object.assign({}, row),
        tmpBtnList = {
            currEventObj: obj.currEventObj,
            dialogFooter: btnList(objType.btnStatus || 3, type)
        };

    obj.row = unitOtherOptParams(obj, type, row);
    obj.row._oldData = oldRow;
    obj.row._btn = actionBtnList(tmpBtnList, type);
    obj.row._title = (objType && objType.title) ? (isTypeof(objType.title) === 'function' ? objType.title(row, obj) : objType.title) : (obj.queryURL.name);
    obj.row._url = obj.url;
    obj.row._method = obj.method;
    obj.row._axios = obj.currAxios;
    obj.row.methodType = obj.autoMethodType;

    unitIsDemandSelectList(obj);
    obj.dialogDelTableVisible = objType.isForm ? false : true;
    obj.dialogEditTableVisible = objType.isForm ? true : false;
}

export function unitExtendData(obj, item, _axios, row) {
    if (isTypeof(item) === 'object' && item.extendLabel && isTypeof(item.extendLabel) === 'array') {
        let queryData = {},
            key = item.key ? item.key : 'id',
            value = item.value ? item.value : key,
            axios = item.axios ? item.axios : _axios;

        if (item.params) {
            parseRequestParams(item.params, row, queryData);
        } else {
            queryData[key] = row[value];
        }
        request(axiosReqParams(item, mergeRequestParams(queryData, obj._publicParams), axios, obj.options)).then((response) => {
            let rowData = row || {},
                next = { keyType: 'result' };

            if (responseKeyToValue(response, obj, obj, next)) {
                rowData = responseNodeParseList(response, item.parse, 'object')
            }
            item.extendLabel.forEach(ext => {
                row[ext.label] = isTypeof(rowData[ext.key]) === 'undefined' ? '' : rowData[ext.key]
            })

            unitDetailCellData(obj, unitRowObjectMerge(item, row));
        }).catch((err) => {
            unitDetailCellData(obj, unitRowObjectMerge(item, row));
        });
    } else {
        unitDetailCellData(obj, unitRowObjectMerge(item, row));
    }
}

export function unitDetailRowDataById(obj, row) {
    let queryData = {},
        item = obj.queryURL['detail'],
        key = item && item.key ? item.key : 'id',
        value = item && item.value ? item.value : key,
        axios = item && item.axios ? item.axios : obj.axios;

    if (item.url) {
        if (item.params) {
            parseRequestParams(item.params, row, queryData);
        } else {
            queryData[key] = row[value];
        }
        request(axiosReqParams(item, mergeRequestParams(queryData, obj._publicParams), axios, obj.options)).then((response) => {
            let rowData = row,
                next = { keyType: 'result' };

            if (responseKeyToValue(response, obj, obj, next)) {
                rowData = responseNodeParseList(response, item.parse, 'object')
            }

            if (item.extend) {
                unitExtendData(obj, item.extend, axios, unitRowObjectMerge(item, rowData));
            } else {
                unitDetailCellData(obj, unitRowObjectMerge(item, rowData));
            }
        }).catch((err) => {
            if (item.extend) {
                unitExtendData(obj, item.extend, axios, unitRowObjectMerge(item, row));
            } else {
                unitDetailCellData(obj, unitRowObjectMerge(item, row));
            }
        });
    } else {
        if (item.extend) {
            unitExtendData(obj, item.extend, axios, unitRowObjectMerge(item, row));
        } else {
            unitDetailCellData(obj, unitRowObjectMerge(item, row));
        }
    }
}

export function unitDetailCellData(obj, row) {
    let tmpBtnList = {
        currEventObj: obj.currEventObj,
        dialogFooter: btnList(1)
    }

    obj.row = row;
    obj.row._btn = actionBtnList(tmpBtnList, 'detail');
    obj.row._title = (obj.queryURL.detail && obj.queryURL.detail.title) ? (isTypeof(obj.queryURL.detail.title) === 'function' ? obj.queryURL.detail.title(row, obj) : obj.queryURL.detail.title) : (obj.queryURL.name + "详情");

    unitIsDemandSelectList(obj);
    obj.dialogDelTableVisible = false;
    obj.dialogEditTableVisible = true;
}

// 批量操作参数配置
export function unitBatchOperateData(obj, queryItem, row) {
    let namesList = [], pData = [],
        tmpRow = isTypeof(row) === 'array' ? Object.assign({}, { selectRowList: row }) : Object.assign({}, row),
        fields = obj.composeParam && obj.composeParam.length > 0 ? obj.composeParam : ['id'],
        dataItem = function (props, rowData) {
            let data = {};

            if (props) { // props参数存在
                for (let [k, v] of Object.entries(props)) {
                    data[k] = rowData[v] !== '' ? rowData[v] : '';
                }
            } else { // 没有设置参数时，使用组件自定制主键
                fields.forEach(item => {
                    data[item] = rowData[item] !== '' ? rowData[item] : '';
                })
            }

            return data;
        },
        optNameList = function (item, name) {
            if (isTypeof(name) === 'array') {
                const names = [];
                name.forEach(itemName => {
                    names.push(item[itemName]);
                })
                return names.join('&');
            } else {
                return item[name];
            }
        },
        queryDataType = function (key, data, item) {
            let resData, tmpData = [...new Set(data)];

            if (item.hasOwnProperty('dataType')) { // 数据类型传递
                if (isTypeof(item.dataType) === 'object') {
                    if (item.dataType.hasOwnProperty(key)) {
                        if (item.dataType[key] === 'array') {
                            resData = tmpData;
                        } else if (item.dataType[key] === 'jsonstring') {
                            resData = JSON.stringify(tmpData);
                        } else if (item.dataType[key] === 'object') {
                            resData = tmpData.length === 1 ? (tmpData[0] || null) : tmpData
                        } else if (item.dataType[key] === 'number') {
                            resData = tmpData.length === 1 ? Number(tmpData[0]) : tmpData
                        }
                    } else {
                        resData = tmpData.join(',');
                    }
                } else {
                    if (item.dataType === 'array') {
                        resData = tmpData;
                    } else if (item.dataType === 'jsonstring') {
                        resData = JSON.stringify(tmpData);
                    } else if (item.dataType[key] === 'object') {
                        resData = tmpData.length === 1 ? (tmpData[0] || null) : tmpData
                    } else if (item.dataType[key] === 'number') {
                        resData = tmpData.length === 1 ? Number(tmpData[0]) : tmpData
                    }
                }
            } else { // 字符串传参
                resData = tmpData.join(',');
            }

            return resData;
        };

    tmpRow._params = {};

    //method 模式
    tmpRow._params.method = queryItem['method'];

    // 配置title
    if (isTypeof(queryItem.title) === 'array') {
        if (tmpRow.hasOwnProperty('hasChildren') && tmpRow.hasChildren) {
            tmpRow._title = queryItem.title[0] ? queryItem.title[0] : (obj.queryURL.name);
        } else {
            tmpRow._title = queryItem.title[1] ? queryItem.title[1] : (obj.queryURL.name);
        }
    } else {
        tmpRow._title = queryItem.title ? queryItem.title : (obj.queryURL.name);
    }

    // 删除参数提取和删除名称提示
    if (tmpRow.hasOwnProperty('selectRowList') && isTypeof(tmpRow.selectRowList) === 'array') {
        tmpRow.selectRowList.forEach(item => {
            namesList.push(optNameList(item, queryItem.name));
            pData.push(dataItem(queryItem.props, item));
        });
    } else if (isTypeof(tmpRow) === 'object') {
        namesList.push(optNameList(tmpRow, queryItem.name));
        pData.push(dataItem(queryItem.props, tmpRow));
    }

    //提交参数 pData为参数数组
    tmpRow._params.data = {};
    if (queryItem.hasOwnProperty('isprops') && queryItem.isprops) { // 参数数组整体传
        tmpRow._params.data[fields[0]] = queryDataType(fields[0], pData, queryItem);// 参数类型
    } else { // 遍历pData分开传，相同key需要合并
        pData.forEach(item => {
            for (let [kk, vv] of Object.entries(item)) {
                if (tmpRow._params.data.hasOwnProperty(kk) && isTypeof(tmpRow._params.data[kk]) === 'array') {
                    tmpRow._params.data[kk].push(vv);
                } else {
                    tmpRow._params.data[kk] = [vv];
                }
            }
        })

        for (let [k, v] of Object.entries(tmpRow._params.data)) {
            tmpRow._params.data[k] = queryDataType(k, v, queryItem);
        }
    }

    // 操作的记录总数
    if (queryItem.hasOwnProperty('optNumber') && isTypeof(queryItem.optNumber) === 'string') {
        tmpRow._params.data[queryItem.optNumber] = namesList.length
    }

    // 自带固定参数
    if (queryItem.hasOwnProperty('params') && queryItem.params) { // 参数数组整体传
        for (let [k, v] of Object.entries(queryItem.params)) {
            tmpRow._params.data[k] = v;
        }
    }

    tmpRow.optNameList = namesList

    return tmpRow;
}

//删除提示内容显示
export function unitDelParams(obj, type, row) {
    const queryItem = obj.queryURL && obj.queryURL.hasOwnProperty(type) ? obj.queryURL[type] : (obj.queryURL['del'] || {});
    const tmpRow = unitBatchOperateData(obj, queryItem, row);
    const nameString = Array.isArray(tmpRow.optNameList) ? tmpRow.optNameList.join(',') : '';

    //删除提示
    tmpRow._optMessage = queryItem.info ? queryItem.info : '确定删除【' + nameString + '】记录。';
    tmpRow._rules = actionDelRules(obj.optRules, tmpRow);//删除前判断的规则

    return tmpRow;
}

// 其他批量操作
export function unitOtherOptParams(obj, type, row) {
    const queryItem = obj.queryURL && obj.queryURL.hasOwnProperty(type) ? obj.queryURL[type] : {};
    const tmpRow = unitBatchOperateData(obj, queryItem, row);
    const nameString = Array.isArray(tmpRow.optNameList) ? tmpRow.optNameList.join(',') : '';

    //提示
    tmpRow._optMessage = queryItem.info ? queryItem.info : '确定操作【' + nameString + '】记录。';

    return tmpRow;
}

//删除时加载删除规则
export function actionDelRules(optRules, row) {
    if (optRules) {
        let res = Object.create(optRules);

        if (res.params) {
            let param = {};

            for (let [k, v] of Object.entries(res.params)) {
                if (isTypeof(v) === 'function') {
                    param[k] = v(row, k);
                } else {
                    param[k] = v;
                }
            }

            res.params = param;
        }

        return res;
    } else {
        return {
            isRules: false
        }
    }
}

export function unitRemoveCellData(obj, type, row) {
    obj.row = unitDelParams(obj, type, row);
    obj.row._btn = "确认";
    obj.row._btntype = 'del';
    obj.row._url = obj.url;
    obj.row._method = obj.method;
    obj.row._axios = obj.axios;
    obj.row._optType = 'del';
    obj.row.methodType = obj.autoMethodType;

    unitIsDemandSelectList(obj);
    obj.dialogDelTableVisible = true;
    obj.dialogEditTableVisible = false;
}

// 是否按需加载select列表
export function unitIsDemandSelectList(obj) {
    if (obj.demandList && isTypeof(obj.demandList) === 'array') {
        unitInitSelectList(obj, obj.demandList)
    }
}

// 获取listType类型,这里只提供一个
function unitGetCurrListTypeValue(obj) {
    let listType = 'table';

    if (isTypeof(obj.listType) === 'string') {
        listType = obj.listType;
    } else if (isTypeof(obj.listType) === 'array') {
        listType = obj.listType[0];
    }

    return listType;
}

// 或许选中的记录list
function unitGetCheckedList(obj) {
    const list = [];
    const listType = unitGetCurrListTypeValue(obj);

    // list数组中插入选中的记录
    if (listType === 'table') {
        if (obj.multipleSelection && obj.multipleSelection.length > 0) {
            obj.multipleSelection.forEach(item => {
                list.push(item);
            });
        }
    } else if (listType === 'card') {
        obj.tableData.forEach(item => {
            if (item.cardChecked) {
                list.push(item);
            }
        })
    }

    return list;
}

export function unitDelAllCell(obj, type) {
    const list = unitGetCheckedList(obj);

    if (list.length > 0) {
        unitRemoveCellData(obj, type, list);
    } else {
        obj.$message({
            message: '请您至少选择一条删除记录！',
            type: 'error'
        });
    }
}

// emit获取参数，在页面中设置
export function emitOnDataRow(obj, type, row) {
    let res = null;

    if (obj.$listeners && !obj.$listeners.emitOnDataRow) {
        console.error('未定义emit方法：emitOnDataRow, ' + type);
        return res;
    }
    obj.$emit('emitOnDataRow', type, obj, row, function (pRes) {
        res = pRes;
    });

    return res;
}

// emit获取当前记录信息
export function emitOnReqParams(obj, type) {
    let res = null;

    if (obj.$listeners && !obj.$listeners.onReqParams) {
        console.error('未定义emit方法：onReqParams, ' + type);
        return res;
    }
    obj.$emit('onReqParams', type, obj, function (pRes) {
        res = pRes;
    });

    return res;
}

export function getQueryParams(obj, isFindList) {
    let res = {},
        findKey = '';

    Array.isArray(obj.queryParam) && obj.queryParam.forEach(item => {
        switch (item.type) {
            case 1:
                if ((obj.page_status & 8) == 8) {
                    res[item.key] = obj.pages[item.value];
                }
                break;
            case 2:
                findKey = item.key;
                if (isTypeof(item.value) === 'object') {
                    res[item.key] = objectMerge({}, item.value);
                } else {
                    res[item.key] = item.value;
                }
                break;
            case 3:
                let defaultParams = true;

                if (isTypeof(obj.finds) == 'object' && obj.finds.hasOwnProperty(item.key) && obj.finds[item.key] === '') {
                    defaultParams = false;
                }

                if (defaultParams) {
                    if (findKey) {
                        res[findKey][item.key] = item.value;
                    } else {
                        res[item.key] = item.value;
                    }
                }
                break;
        }
    });

    if (isFindList && obj.finds) {
        if (isTypeof(obj.finds) == 'object') {
            for (let [k, v] of Object.entries(obj.finds)) {
                if (v !== '') {
                    if (findKey) {
                        res[findKey][k] = isTypeof(v) == 'array' ? v.join('') : v;
                    } else {
                        res[k] = isTypeof(v) == 'array' ? v.join('') : v;
                    }
                }
            }
        } else if (isTypeof(obj.finds) == 'string') {
            obj.page_column.forEach(item => {
                if (item.allSearch) {
                    if (obj.finds == 0 || obj.finds) {
                        if (findKey) {
                            res[findKey][item.field] = obj.finds;
                        } else {
                            res[item.field] = obj.finds;
                        }

                    }
                }
            });
        }
    }


    for (let [k, v] of Object.entries(obj.order)) {
        res.orderName = k.replace(/([A-Z])/g, "_$1").toLowerCase();
        res.orderBy = v == 'ascending' ? 'asc' : 'desc';
    }

    return res;
}

export function searchSourceData(obj) {
    if (obj.finds) {
        let params = [],
            sourceNewData = [];

        if (isTypeof(obj.finds) == 'object') {
            for (let [k, v] of Object.entries(obj.finds)) {
                if (v !== '') {
                    params.push({
                        key: k,
                        value: isTypeof(v) == 'array' ? v.join('') : v
                    });
                }
            }
        } else if (isTypeof(obj.finds) == 'string') {
            obj.page_column.forEach(item => {
                if (item.allSearch) {
                    if (obj.finds !== '') {
                        params.push({
                            key: item.field,
                            value: obj.finds
                        });
                    }
                }
            });
        }

        obj.sourceData.forEach(item => {
            let itemFlag = true;
            params.forEach(param => {
                (item[param.key].indexOf(param.value) == -1) && (itemFlag = false);
            });
            itemFlag && sourceNewData.push(item);
        });

        obj.tableData = sourceNewData;
        obj.pages.totalCount = sourceNewData.length;
    } else {
        obj.tableData = obj.sourceData;
        obj.pages.totalCount = obj.sourceData.length;
    }
    obj.loading = false;
}

export function unitInitDataTableList(obj) {
    obj.loading = true;
    obj.tableData = [];
    let item = obj.queryURL['list'],
        queryData = !obj.queryParam || isTypeof(obj.queryParam) === 'function'
            ? emitOnReqParams(obj, 'list')
            : getQueryParams(obj, true),
        // table中插入一条记录
        insertTableItem = function (obj, dataItem, mergeItem) {
            let tmpDataItem = responseNodeParseList(dataItem, mergeItem) || {}
            for (let [kk, vv] of Object.entries(tmpDataItem)) {
                obj.$set(dataItem, kk, vv);
            }
        };

    // 在没有显示table和分页信息情况下不请求接口
    if ((obj.page_status & 8) != 8 && (obj.page_status & 4) != 4) return;
    request(axiosReqParams(item, mergeRequestParams(queryData, obj._publicParams), obj.axios, obj.options)).then((response) => {
        let next = { keyType: 'result' };
        obj.loading = false; //关闭遮罩load

        obj.tableListResponse = response;
        // 对查询列表数据处理函数，或者获取数据后操作
        if (obj.$listeners && obj.$listeners.afterTableData && isTypeof(obj.$listeners.afterTableData) === 'function') {
            obj.$emit('afterTableData', response);
        }
        if (responseKeyToValue(response, obj, obj, next)) {
            if ((obj.page_status & 4) == 4) {
                let tmpTableList = responseNodeParseList(response, item.parse.tableData) || []; //table赋值值
                if (obj.rowKey || item.parse.childrenData) {
                    tmpTableList.forEach(dataItem => {
                        if (isTypeof(item.parse.childrenData) === 'object') {
                            for (let [ck, cv] of Object.entries(item.parse.childrenData)) {
                                insertTableItem(obj, dataItem, cv)
                            }
                        } else {
                            insertTableItem(obj, dataItem, item.parse.childrenData)
                        }
                        if (!obj.options.hasOwnProperty('lazy')
                            || (obj.options.hasOwnProperty('lazy') && obj.options.lazy)) {
                            dataItem.hasChildren = item.tree ? (dataItem[item.tree.key] ? true : false) : true;
                        }
                    })
                }
                if (obj.$listeners && obj.$listeners.updateColumnValue && isTypeof(obj.$listeners.updateColumnValue) === 'function') {
                    // 通过回调修改tableData值
                    obj.loading = true;
                    obj.$emit('updateColumnValue', tmpTableList, (pRes) => {
                        obj.tableData = pRes || tmpTableList;
                        obj.loading = false; //关闭遮罩load
                    });
                } else {
                    obj.tableData = tmpTableList;
                }
            }
            if ((obj.page_status & 8) == 8) {
                obj.pages.totalCount = responseNodeParseList(response, item.parse.totalCount, 'number') || 0; //赋值总页数
            }
        }
    }).catch((err) => {
        obj.loading = false;
    });
}

export function unitInitSelectList(obj, demandList = null) {
    return new Promise((resolve, reject) => {
        let selectlist = obj.select_list;

        for (let [key, val] of Object.entries(selectlist)) {
            if (isTypeof(val) === 'object') {
                // 判断对象是否需要初始化
                if (demandList === null && val.isNotInit) continue;

                // 动态加载单个select
                if (val.url) {
                    if (val.paramType) {
                        key = key.substr(0, (key.length - 5))
                    } else {
                        selectlist[(key + 'Param')] = val;
                        val.paramsTypeof = isTypeof(val.params)
                    }
                    // 查询按需加载list中是否存在
                    if (demandList && (isTypeof(demandList) !== 'array' || !isArrayInnerValue(demandList, key))) continue;

                    let post = val.paramsTypeof === 'function'
                        ? emitOnReqParams(obj, key)
                        : (val.params ? val.params : getQueryParams(obj, false));
                    //增加默认参数

                    val.params = post;
                    val.paramType = true;// 是否重复加载
                    selectlist[key] = [];
                    (async function (keys) {
                        let tmpAxios = Object.assign({}, obj.axios, val.axios);
                        await selectListRequest(selectlist, val, keys, mergeRequestParams(post, obj._publicParams), tmpAxios, obj.options);
                    }(key));
                }
            }
        }
    });
}

export async function reloadItemSelectList(obj, type, field) {
    let post = {},
        selectlist = obj.select_list,
        selectkey = field + 'Param',
        item = selectlist[selectkey],
        currPage = item.pageProps && item.pageProps.page ? item.pageProps.page : 'page';

    if (item.url) {
        if (type === 'remote') {
            selectlist[field] = []
            if (item.hasOwnProperty('remote')
                && item.remote.paramKey
                && item.remote.key
                && item.remote.hasOwnProperty('paramKey')
            ) {
                if (isTypeof(item.remote.paramKey) === 'array') {
                    let tmpItemParams = item.params

                    item.remote.paramKey.forEach(k => {
                        if (tmpItemParams.hasOwnProperty(k)) {
                            tmpItemParams = tmpItemParams[k]
                        } else {
                            tmpItemParams[k] = {}
                            tmpItemParams = tmpItemParams[k]
                        }
                    });
                    tmpItemParams[item.remote.key] = item.remote.value;
                } else {
                    if (!item.params.hasOwnProperty(item.remote.paramKey)) {
                        item.params[item.remote.paramKey] = {};
                    }

                    item.params[item.remote.paramKey][item.remote.key] = item.remote.value;
                }
            } else {
                item.remote && item.remote.key && (item.params[item.remote.key] = item.remote.value);
            }
            if (item.params && item.params[currPage]) {
                item.params[currPage] = 1;
            }
        } else if (type === 'infinite') {
            if (item.params && item.params[currPage]) {
                item.params[currPage] += 1;
            } else {
                return false;
            }
        }

        post = item.params;
        // 存在扩展参数函数
        if (item.extParamsFunc && isTypeof(item.extParamsFunc) == 'function') {
            post = item.extParamsFunc(obj.rowData, post)
        }
        let tmpAxios = Object.assign({}, obj.axios, item.axios);
        await selectListRequest(selectlist, item, field, mergeRequestParams(post, obj._publicParams), tmpAxios, obj.options);
    }
}

export async function selectListRequest(selectlist, item, field, data, axios, options) {
    const responseData = await request(axiosReqParams(item, data, axios, options)).then((response) => {
        return response
    }).catch((err) => {
    });
    selectlist[field].push(...parseResListData(responseData, item));
}

export function parseResListData(response, item) {
    let result = [],
        node = item.node ? item.node : 'data',
        props = item.props ? item.props : { value: 'oid', label: 'name' },
        list = responseNodeParseList(response, node),
        isListType = isTypeof(list);

    if (item.result) {
        result = list;
    } else {
        if (isListType === 'array') {
            if (list && list.length > 0) {
                list.forEach(it => {
                    let tmpLabel = '',
                        tmpValue = '';

                    if (isTypeof(it) === 'object') {
                        if (isTypeof(props['value']) === 'array') {
                            let tmpArray = [];

                            props['value'].forEach(labelItem => {
                                tmpArray.push(it[labelItem]);
                            });
                            tmpValue = tmpArray.join('#0');
                        } else {
                            tmpValue = it[props['value']];
                        }
                        if (isTypeof(props['label']) === 'array') {
                            let tmpArray = [];

                            props['label'].forEach(labelItem => {
                                tmpArray.push(it[labelItem]);
                            });
                            tmpLabel = tmpArray.join(' / ');
                        } else {
                            tmpLabel = it[props['label']];
                        }
                    } else if (isTypeof(it) === 'array') {
                        tmpValue = it.join('#0')
                        tmpLabel = it.join(' / ')
                    } else {
                        tmpValue = it
                        tmpLabel = it
                    }

                    result.push({
                        value: tmpValue,
                        label: tmpLabel
                    });
                });
            }
        } else if (isListType === 'object') {
            for (let [k, v] of Object.entries(list)) {
                result.push({
                    value: k.toString(),
                    label: v
                });
            }
        }
    }
    if (item.filter) {
        result = result.filter(it => !isArrayInnerValue(item.filter, it.label))
    }

    return result;
}