vxe-table 4.20.8 → 4.20.10

package/es/grid/src/grid.js

@@ -899,7 +899,7 @@ export default defineVxeComponent({
                 const proxyOpts = computeProxyOpts.value;
                 const pagerOpts = computePagerOpts.value;
                 const toolbarOpts = computeToolbarOpts.value;
-                const { beforeQuery, afterQuery, beforeQueryFooter, afterQueryFooter, beforeDelete, afterDelete, beforeSave, afterSave, ajax = {} } = proxyOpts;
+                const { beforeQuery: oldBeforeQuery, afterQuery: oldAfterQuery, beforeQueryFooter: oldBeforeQueryFooter, afterQueryFooter: oldAfterQueryFooter, beforeDelete: oldBeforeDelete, afterDelete: oldAfterDelete, beforeSave: oldBeforeSave, afterSave: oldAfterSave, ajax = {} } = proxyOpts;
                 const resConfigs = (proxyOpts.response || proxyOpts.props || {});
                 const $xeTable = refTable.value;
                 if (!$xeTable) {
@@ -950,10 +950,12 @@ export default defineVxeComponent({
                     case 'initial':
                     case 'reload':
                     case 'query': {
-                        const qMethods = ajax.query;
-                        const qsMethods = ajax.querySuccess;
-                        const qeMethods = ajax.queryError;
-                        if (qMethods) {
+                        const bqMethod = ajax.beforeQuery;
+                        const qMethod = ajax.query;
+                        const aqMethod = ajax.afterQuery;
+                        const qsMethod = ajax.querySuccess;
+                        const qeMethod = ajax.queryError;
+                        if (qMethod) {
                             const isInited = code === 'initial';
                             const isReload = code === 'reload';
                             if (!isInited && reactData.tableLoading) {
@@ -1035,73 +1037,91 @@ export default defineVxeComponent({
                                 sorts: sortList,
                                 filters: filterList,
                                 form: formData,
-                                options: qMethods
+                                options: qMethod
                             };
-                            reactData.sortData = sortList;
-                            reactData.filterData = filterList;
-                            reactData.tableLoading = true;
-                            return Promise.all([
-                                Promise.resolve((beforeQuery || qMethods)(commitParams, ...args)),
-                                operPromise
-                            ]).then(([rest]) => {
-                                let tableData = [];
-                                reactData.tableLoading = false;
-                                if (rest) {
-                                    const reParams = { data: rest, $table: $xeTable, $grid: $xeGrid, $gantt: null };
-                                    if (pagerConfig && isEnableConf(pagerOpts)) {
-                                        const totalProp = resConfigs.total;
-                                        const total = (XEUtils.isFunction(totalProp) ? totalProp(reParams) : XEUtils.get(rest, totalProp || 'page.total')) || 0;
-                                        tablePage.total = XEUtils.toNumber(total);
-                                        const resultProp = resConfigs.result;
-                                        tableData = (XEUtils.isFunction(resultProp) ? resultProp(reParams) : XEUtils.get(rest, resultProp || 'result')) || [];
-                                        // 检验当前页码，不能超出当前最大页数
-                                        const pageCount = Math.max(Math.ceil(total / tablePage.pageSize), 1);
-                                        if (tablePage.currentPage > pageCount) {
-                                            tablePage.currentPage = pageCount;
-                                        }
+                            const handleQuery = () => {
+                                reactData.sortData = sortList;
+                                reactData.filterData = filterList;
+                                reactData.tableLoading = true;
+                                return Promise.all([
+                                    Promise.resolve((oldBeforeQuery || qMethod)(commitParams, ...args)),
+                                    operPromise
+                                ]).then(([rest]) => {
+                                    reactData.tableLoading = false;
+                                    if (aqMethod) {
+                                        aqMethod(Object.assign(Object.assign({}, commitParams), { response: rest, status: 'success' }), ...args);
                                     }
                                     else {
-                                        const listProp = resConfigs.list;
-                                        if (XEUtils.isArray(rest)) {
-                                            tableData = rest;
-                                        }
-                                        else if (listProp) {
-                                            tableData = (XEUtils.isFunction(listProp) ? listProp(reParams) : XEUtils.get(rest, listProp)) || [];
-                                        }
-                                    }
-                                    if (showFooter) {
-                                        const fdProp = resConfigs.footerData;
-                                        const footerList = fdProp ? (XEUtils.isFunction(fdProp) ? fdProp(reParams) : XEUtils.get(rest, fdProp)) : [];
-                                        if (XEUtils.isArray(footerList)) {
-                                            reactData.footerData = footerList;
+                                        let tableData = [];
+                                        if (rest) {
+                                            const reParams = { data: rest, $table: $xeTable, $grid: $xeGrid, $gantt: null };
+                                            if (pagerConfig && isEnableConf(pagerOpts)) {
+                                                const totalProp = resConfigs.total;
+                                                const total = (XEUtils.isFunction(totalProp) ? totalProp(reParams) : XEUtils.get(rest, totalProp || 'page.total')) || 0;
+                                                tablePage.total = XEUtils.toNumber(total);
+                                                const resultProp = resConfigs.result;
+                                                tableData = (XEUtils.isFunction(resultProp) ? resultProp(reParams) : XEUtils.get(rest, resultProp || 'result')) || [];
+                                                // 检验当前页码，不能超出当前最大页数
+                                                const pageCount = Math.max(Math.ceil(total / tablePage.pageSize), 1);
+                                                if (tablePage.currentPage > pageCount) {
+                                                    tablePage.currentPage = pageCount;
+                                                }
+                                            }
+                                            else {
+                                                const listProp = resConfigs.list;
+                                                if (XEUtils.isArray(rest)) {
+                                                    tableData = rest;
+                                                }
+                                                else if (listProp) {
+                                                    tableData = (XEUtils.isFunction(listProp) ? listProp(reParams) : XEUtils.get(rest, listProp)) || [];
+                                                }
+                                            }
+                                            if (showFooter) {
+                                                const fdProp = resConfigs.footerData;
+                                                const footerList = fdProp ? (XEUtils.isFunction(fdProp) ? fdProp(reParams) : XEUtils.get(rest, fdProp)) : [];
+                                                if (XEUtils.isArray(footerList)) {
+                                                    reactData.footerData = footerList;
+                                                }
+                                            }
                                         }
-                                    }
-                                }
-                                if ($xeTable) {
-                                    $xeTable.loadData(tableData);
-                                }
-                                else {
-                                    nextTick(() => {
-                                        const $xeTable = refTable.value;
                                         if ($xeTable) {
                                             $xeTable.loadData(tableData);
                                         }
-                                    });
-                                }
-                                if (afterQuery) {
-                                    afterQuery(commitParams, ...args);
-                                }
-                                if (qsMethods) {
-                                    qsMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
-                                }
-                                return { status: true };
-                            }).catch((rest) => {
-                                reactData.tableLoading = false;
-                                if (qeMethods) {
-                                    qeMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
-                                }
-                                return { status: false };
-                            });
+                                        else {
+                                            nextTick(() => {
+                                                const $xeTable = refTable.value;
+                                                if ($xeTable) {
+                                                    $xeTable.loadData(tableData);
+                                                }
+                                            });
+                                        }
+                                        if (oldAfterQuery) {
+                                            oldAfterQuery(Object.assign(Object.assign({}, commitParams), { response: rest }), ...args);
+                                        }
+                                    }
+                                    if (qsMethod) {
+                                        qsMethod(Object.assign(Object.assign({}, commitParams), { response: rest }));
+                                    }
+                                    return { status: true };
+                                }).catch((rest) => {
+                                    reactData.tableLoading = false;
+                                    if (aqMethod) {
+                                        aqMethod(Object.assign(Object.assign({}, commitParams), { response: rest, status: 'error' }), ...args);
+                                    }
+                                    if (qeMethod) {
+                                        qeMethod(Object.assign(Object.assign({}, commitParams), { response: rest }));
+                                    }
+                                    return { status: false };
+                                });
+                            };
+                            if (bqMethod) {
+                                return Promise.resolve(bqMethod(commitParams, ...args)).then(status => {
+                                    if (status !== false) {
+                                        return handleQuery();
+                                    }
+                                });
+                            }
+                            return handleQuery();
                         }
                         else {
                             errLog('vxe.error.notFunc', ['proxy-config.ajax.query']);
@@ -1109,39 +1129,66 @@ export default defineVxeComponent({
                         break;
                     }
                     case 'queryFooter': {
-                        const qfMethods = ajax.queryFooter;
-                        const qfSuccessMethods = ajax.queryFooterSuccess;
-                        const qfErrorMethods = ajax.queryFooterError;
-                        if (qfMethods) {
+                        const bqfMethod = ajax.beforeQueryFooter;
+                        const qfMethod = ajax.queryFooter;
+                        const aqfMethod = ajax.afterQueryFooter;
+                        const qfSuccessMethod = ajax.queryFooterSuccess;
+                        const qfErrorMethod = ajax.queryFooterError;
+                        if (qfMethod) {
                             let filterList = [];
                             if ($xeTable) {
                                 filterList = $xeTable.getCheckedFilters();
                             }
+                            let pageParams = {};
+                            if (pagerConfig) {
+                                if (isEnableConf(pagerOpts)) {
+                                    pageParams = Object.assign({}, tablePage);
+                                }
+                            }
                             const commitParams = {
                                 $table: $xeTable,
                                 $grid: $xeGrid,
                                 $gantt: null,
                                 code,
                                 button,
+                                page: pageParams,
                                 filters: filterList,
                                 form: formData,
-                                options: qfMethods
+                                options: qfMethod
                             };
-                            return Promise.resolve((beforeQueryFooter || qfMethods)(commitParams, ...args)).then(rest => {
-                                reactData.footerData = XEUtils.isArray(rest) ? rest : [];
-                                if (afterQueryFooter) {
-                                    afterQueryFooter(commitParams, ...args);
-                                }
-                                if (qfSuccessMethods) {
-                                    qfSuccessMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
-                                }
-                                return { status: true };
-                            }).catch((rest) => {
-                                if (qfErrorMethods) {
-                                    qfErrorMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
-                                }
-                                return { status: false };
-                            });
+                            const handleQueryFooter = () => {
+                                return Promise.resolve((oldBeforeQueryFooter || qfMethod)(commitParams, ...args)).then(rest => {
+                                    if (aqfMethod) {
+                                        aqfMethod(Object.assign(Object.assign({}, commitParams), { response: rest, status: 'success' }), ...args);
+                                    }
+                                    else {
+                                        reactData.footerData = XEUtils.isArray(rest) ? rest : [];
+                                        if (oldAfterQueryFooter) {
+                                            oldAfterQueryFooter(Object.assign(Object.assign({}, commitParams), { response: rest }), ...args);
+                                        }
+                                    }
+                                    if (qfSuccessMethod) {
+                                        qfSuccessMethod(Object.assign(Object.assign({}, commitParams), { response: rest }));
+                                    }
+                                    return { status: true };
+                                }).catch((rest) => {
+                                    if (aqfMethod) {
+                                        aqfMethod(Object.assign(Object.assign({}, commitParams), { response: rest, status: 'error' }), ...args);
+                                    }
+                                    if (qfErrorMethod) {
+                                        qfErrorMethod(Object.assign(Object.assign({}, commitParams), { response: rest }));
+                                    }
+                                    return { status: false };
+                                });
+                            };
+                            if (bqfMethod) {
+                                return Promise.resolve(bqfMethod(commitParams, ...args)).then(status => {
+                                    if (status !== false) {
+                                        return handleQueryFooter();
+                                    }
+                                });
+                            }
+                            return handleQueryFooter();
                         }
                         else {
                             errLog('vxe.error.notFunc', ['proxy-config.ajax.queryFooter']);
@@ -1149,10 +1196,12 @@ export default defineVxeComponent({
                         break;
                     }
                     case 'delete': {
-                        const dMethods = ajax.delete;
+                        const bdMethod = ajax.beforeDelete;
+                        const dMethod = ajax.delete;
+                        const adMethod = ajax.afterDelete;
                         const deleteSuccessMethods = ajax.deleteSuccess;
                         const deleteErrorMethods = ajax.deleteError;
-                        if (dMethods) {
+                        if (dMethod) {
                             const selectRecords = $xeGrid.getCheckboxRecords();
                             const removeRecords = selectRecords.filter(row => !$xeTable.isInsertByRow(row));
                             const body = { removeRecords };
@@ -1164,49 +1213,69 @@ export default defineVxeComponent({
                                 button,
                                 body,
                                 form: formData,
-                                options: dMethods
+                                options: dMethod
                             };
                             if (selectRecords.length) {
                                 return handleDeleteRow(code, 'vxe.grid.deleteSelectRecord', () => {
                                     if (!removeRecords.length) {
                                         return $xeTable.remove(selectRecords);
                                     }
-                                    reactData.tableLoading = true;
-                                    return Promise.resolve((beforeDelete || dMethods)(commitParams, ...args))
-                                        .then(rest => {
-                                        reactData.tableLoading = false;
-                                        $xeTable.setPendingRow(removeRecords, false);
-                                        if (isRespMsg) {
-                                            if (VxeUI.modal) {
-                                                VxeUI.modal.message({ content: getRespMsg(rest, 'vxe.grid.delSuccess'), status: 'success' });
+                                    const handleDelete = () => {
+                                        reactData.tableLoading = true;
+                                        return Promise.resolve((oldBeforeDelete || dMethod)(commitParams, ...args))
+                                            .then(rest => {
+                                            reactData.tableLoading = false;
+                                            if (adMethod) {
+                                                adMethod(Object.assign(Object.assign({}, commitParams), { response: rest, status: 'success' }), ...args);
                                             }
-                                        }
-                                        if (afterDelete) {
-                                            afterDelete(commitParams, ...args);
-                                        }
-                                        else {
-                                            internalData.uFoot = true;
-                                            $xeGrid.commitProxy('query');
-                                            internalData.uFoot = false;
-                                            updateQueryFooter();
-                                        }
-                                        if (deleteSuccessMethods) {
-                                            deleteSuccessMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
-                                        }
-                                        return { status: true };
-                                    })
-                                        .catch(rest => {
-                                        reactData.tableLoading = false;
-                                        if (isRespMsg) {
-                                            if (VxeUI.modal) {
-                                                VxeUI.modal.message({ id: code, content: getRespMsg(rest, 'vxe.grid.operError'), status: 'error' });
+                                            else {
+                                                $xeTable.setPendingRow(removeRecords, false);
+                                                if (isRespMsg) {
+                                                    if (VxeUI.modal) {
+                                                        VxeUI.modal.message({ content: getRespMsg(rest, 'vxe.grid.delSuccess'), status: 'success' });
+                                                    }
+                                                }
+                                                if (oldAfterDelete) {
+                                                    oldAfterDelete(Object.assign(Object.assign({}, commitParams), { response: rest }), ...args);
+                                                }
+                                                else {
+                                                    internalData.uFoot = true;
+                                                    $xeGrid.commitProxy('query');
+                                                    internalData.uFoot = false;
+                                                    updateQueryFooter();
+                                                }
                                             }
-                                        }
-                                        if (deleteErrorMethods) {
-                                            deleteErrorMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
-                                        }
-                                        return { status: false };
-                                    });
+                                            if (deleteSuccessMethods) {
+                                                deleteSuccessMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
+                                            }
+                                            return { status: true };
+                                        })
+                                            .catch(rest => {
+                                            reactData.tableLoading = false;
+                                            if (adMethod) {
+                                                adMethod(Object.assign(Object.assign({}, commitParams), { response: rest, status: 'error' }), ...args);
+                                            }
+                                            else {
+                                                if (isRespMsg) {
+                                                    if (VxeUI.modal) {
+                                                        VxeUI.modal.message({ id: code, content: getRespMsg(rest, 'vxe.grid.operError'), status: 'error' });
+                                                    }
+                                                }
+                                            }
+                                            if (deleteErrorMethods) {
+                                                deleteErrorMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
+                                            }
+                                            return { status: false };
+                                        });
+                                    };
+                                    if (bdMethod) {
+                                        return Promise.resolve(bdMethod(commitParams, ...args)).then(status => {
+                                            if (status !== false) {
+                                                return handleDelete();
+                                            }
+                                        });
+                                    }
+                                    return handleDelete();
                                 });
                             }
                             else {
@@ -1223,10 +1292,12 @@ export default defineVxeComponent({
                         break;
                     }
                     case 'save': {
-                        const ajaxMethods = ajax.save;
-                        const saveSuccessMethods = ajax.saveSuccess;
-                        const saveErrorMethods = ajax.saveError;
-                        if (ajaxMethods) {
+                        const bSaveMethod = ajax.beforeSave;
+                        const sMethod = ajax.save;
+                        const aSaveMethod = ajax.afterSave;
+                        const sSuccessMethod = ajax.saveSuccess;
+                        const sErrorMethod = ajax.saveError;
+                        if (sMethod) {
                             const body = $xeTable.getRecordset();
                             const { insertRecords, removeRecords, updateRecords, pendingRecords } = body;
                             const commitParams = {
@@ -1237,7 +1308,7 @@ export default defineVxeComponent({
                                 button,
                                 body,
                                 form: formData,
-                                options: ajaxMethods
+                                options: sMethod
                             };
                             // 排除掉新增且标记为删除的数据
                             if (insertRecords.length) {
@@ -1258,42 +1329,62 @@ export default defineVxeComponent({
                                     return;
                                 }
                                 if (body.insertRecords.length || removeRecords.length || updateRecords.length || body.pendingRecords.length) {
-                                    reactData.tableLoading = true;
-                                    return Promise.resolve((beforeSave || ajaxMethods)(commitParams, ...args))
-                                        .then(rest => {
-                                        reactData.tableLoading = false;
-                                        $xeTable.clearPendingRow();
-                                        if (isRespMsg) {
-                                            if (VxeUI.modal) {
-                                                VxeUI.modal.message({ content: getRespMsg(rest, 'vxe.grid.saveSuccess'), status: 'success' });
+                                    const handleSave = () => {
+                                        reactData.tableLoading = true;
+                                        return Promise.resolve((oldBeforeSave || sMethod)(commitParams, ...args))
+                                            .then(rest => {
+                                            reactData.tableLoading = false;
+                                            if (aSaveMethod) {
+                                                aSaveMethod(Object.assign(Object.assign({}, commitParams), { response: rest, status: 'success' }), ...args);
                                             }
-                                        }
-                                        if (afterSave) {
-                                            afterSave(commitParams, ...args);
-                                        }
-                                        else {
-                                            internalData.uFoot = true;
-                                            $xeGrid.commitProxy('query');
-                                            internalData.uFoot = false;
-                                            updateQueryFooter();
-                                        }
-                                        if (saveSuccessMethods) {
-                                            saveSuccessMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
-                                        }
-                                        return { status: true };
-                                    })
-                                        .catch(rest => {
-                                        reactData.tableLoading = false;
-                                        if (isRespMsg) {
-                                            if (VxeUI.modal) {
-                                                VxeUI.modal.message({ id: code, content: getRespMsg(rest, 'vxe.grid.operError'), status: 'error' });
+                                            else {
+                                                $xeTable.clearPendingRow();
+                                                if (isRespMsg) {
+                                                    if (VxeUI.modal) {
+                                                        VxeUI.modal.message({ content: getRespMsg(rest, 'vxe.grid.saveSuccess'), status: 'success' });
+                                                    }
+                                                }
+                                                if (oldAfterSave) {
+                                                    oldAfterSave(Object.assign(Object.assign({}, commitParams), { response: rest }), ...args);
+                                                }
+                                                else {
+                                                    internalData.uFoot = true;
+                                                    $xeGrid.commitProxy('query');
+                                                    internalData.uFoot = false;
+                                                    updateQueryFooter();
+                                                }
                                             }
-                                        }
-                                        if (saveErrorMethods) {
-                                            saveErrorMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
-                                        }
-                                        return { status: false };
-                                    });
+                                            if (sSuccessMethod) {
+                                                sSuccessMethod(Object.assign(Object.assign({}, commitParams), { response: rest }));
+                                            }
+                                            return { status: true };
+                                        })
+                                            .catch(rest => {
+                                            reactData.tableLoading = false;
+                                            if (aSaveMethod) {
+                                                aSaveMethod(Object.assign(Object.assign({}, commitParams), { response: rest, status: 'error' }), ...args);
+                                            }
+                                            else {
+                                                if (isRespMsg) {
+                                                    if (VxeUI.modal) {
+                                                        VxeUI.modal.message({ id: code, content: getRespMsg(rest, 'vxe.grid.operError'), status: 'error' });
+                                                    }
+                                                }
+                                            }
+                                            if (sErrorMethod) {
+                                                sErrorMethod(Object.assign(Object.assign({}, commitParams), { response: rest }));
+                                            }
+                                            return { status: false };
+                                        });
+                                    };
+                                    if (bSaveMethod) {
+                                        return Promise.resolve(bSaveMethod(commitParams, ...args)).then(status => {
+                                            if (status !== false) {
+                                                return handleSave();
+                                            }
+                                        });
+                                    }
+                                    return handleSave();
                                 }
                                 else {
                                     if (isActiveMsg) {