vxe-table 3.22.9 → 3.22.10

package/lib/grid/src/grid.js

@@ -678,14 +678,14 @@ var _default = exports.default = /* define-vxe-component start */(0, _comp.defin
       const pagerOpts = $xeGrid.computePagerOpts;
       const toolbarOpts = $xeGrid.computeToolbarOpts;
       const {
-        beforeQuery,
-        afterQuery,
-        beforeQueryFooter,
-        afterQueryFooter,
-        beforeDelete,
-        afterDelete,
-        beforeSave,
-        afterSave,
+        beforeQuery: oldBeforeQuery,
+        afterQuery: oldAfterQuery,
+        beforeQueryFooter: oldBeforeQueryFooter,
+        afterQueryFooter: oldAfterQueryFooter,
+        beforeDelete: oldBeforeDelete,
+        afterDelete: oldAfterDelete,
+        beforeSave: oldBeforeSave,
+        afterSave: oldAfterSave,
         ajax = {}
       } = proxyOpts;
       const resConfigs = proxyOpts.response || proxyOpts.props || {};
@@ -744,10 +744,12 @@ var _default = exports.default = /* define-vxe-component start */(0, _comp.defin
         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) {
@@ -831,80 +833,105 @@ var _default = exports.default = /* define-vxe-component start */(0, _comp.defin
                 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 && (0, _utils.isEnableConf)(pagerOpts)) {
-                    const totalProp = resConfigs.total;
-                    const total = (_xeUtils.default.isFunction(totalProp) ? totalProp(reParams) : _xeUtils.default.get(rest, totalProp || 'page.total')) || 0;
-                    tablePage.total = _xeUtils.default.toNumber(total);
-                    const resultProp = resConfigs.result;
-                    tableData = (_xeUtils.default.isFunction(resultProp) ? resultProp(reParams) : _xeUtils.default.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.default.isArray(rest)) {
-                      tableData = rest;
-                    } else if (listProp) {
-                      tableData = (_xeUtils.default.isFunction(listProp) ? listProp(reParams) : _xeUtils.default.get(rest, listProp)) || [];
-                    }
-                  }
-                  if (showFooter) {
-                    const fdProp = resConfigs.footerData;
-                    const footerList = fdProp ? _xeUtils.default.isFunction(fdProp) ? fdProp(reParams) : _xeUtils.default.get(rest, fdProp) : [];
-                    if (_xeUtils.default.isArray(footerList)) {
-                      reactData.footerData = footerList;
+                    let tableData = [];
+                    if (rest) {
+                      const reParams = {
+                        data: rest,
+                        $table: $xeTable,
+                        $grid: $xeGrid,
+                        $gantt: null
+                      };
+                      if (pagerConfig && (0, _utils.isEnableConf)(pagerOpts)) {
+                        const totalProp = resConfigs.total;
+                        const total = (_xeUtils.default.isFunction(totalProp) ? totalProp(reParams) : _xeUtils.default.get(rest, totalProp || 'page.total')) || 0;
+                        tablePage.total = _xeUtils.default.toNumber(total);
+                        const resultProp = resConfigs.result;
+                        tableData = (_xeUtils.default.isFunction(resultProp) ? resultProp(reParams) : _xeUtils.default.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.default.isArray(rest)) {
+                          tableData = rest;
+                        } else if (listProp) {
+                          tableData = (_xeUtils.default.isFunction(listProp) ? listProp(reParams) : _xeUtils.default.get(rest, listProp)) || [];
+                        }
+                      }
+                      if (showFooter) {
+                        const fdProp = resConfigs.footerData;
+                        const footerList = fdProp ? _xeUtils.default.isFunction(fdProp) ? fdProp(reParams) : _xeUtils.default.get(rest, fdProp) : [];
+                        if (_xeUtils.default.isArray(footerList)) {
+                          reactData.footerData = footerList;
+                        }
+                      }
                     }
-                  }
-                }
-                if ($xeTable) {
-                  $xeTable.loadData(tableData);
-                } else {
-                  $xeGrid.$nextTick(() => {
-                    const $xeTable = $xeGrid.$refs.refTable;
                     if ($xeTable) {
                       $xeTable.loadData(tableData);
+                    } else {
+                      $xeGrid.$nextTick(() => {
+                        const $xeTable = $xeGrid.$refs.refTable;
+                        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
-                };
-              });
+                    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']);
             }
@@ -912,47 +939,81 @@ var _default = exports.default = /* define-vxe-component start */(0, _comp.defin
           }
         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 ((0, _utils.isEnableConf)(pagerConfig)) {
+                  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.default.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.default.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']);
             }
@@ -960,10 +1021,12 @@ var _default = exports.default = /* define-vxe-component start */(0, _comp.defin
           }
         case 'delete':
           {
-            const dMethods = ajax.delete;
-            const deleteSuccessMethods = ajax.deleteSuccess;
-            const deleteErrorMethods = ajax.deleteError;
-            if (dMethods) {
+            const bdMethod = ajax.beforeDelete;
+            const dMethod = ajax.delete;
+            const adMethod = ajax.afterDelete;
+            const deleteSuccessMethod = ajax.deleteSuccess;
+            const deleteErrorMethod = ajax.deleteError;
+            if (dMethod) {
               const selectRecords = $xeTable.getCheckboxRecords();
               const removeRecords = selectRecords.filter(row => !$xeTable.isInsertByRow(row));
               const body = {
@@ -977,62 +1040,87 @@ var _default = exports.default = /* define-vxe-component start */(0, _comp.defin
                 button,
                 body,
                 form: formData,
-                options: dMethods
+                options: dMethod
               };
-              const applyArgs = [commitParams].concat(args);
               if (selectRecords.length) {
                 return $xeGrid.handleDeleteRow(code, 'vxe.grid.deleteSelectRecord', () => {
                   if (!removeRecords.length) {
                     return $xeTable.remove(selectRecords);
                   }
-                  reactData.tableLoading = true;
-                  return Promise.resolve((beforeDelete || dMethods)(...applyArgs)).then(rest => {
-                    reactData.tableLoading = false;
-                    $xeTable.setPendingRow(removeRecords, false);
-                    if (isRespMsg) {
-                      if (_ui.VxeUI.modal) {
-                        _ui.VxeUI.modal.message({
-                          content: $xeGrid.getRespMsg(rest, 'vxe.grid.delSuccess'),
+                  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);
+                      } else {
+                        $xeTable.setPendingRow(removeRecords, false);
+                        if (isRespMsg) {
+                          if (_ui.VxeUI.modal) {
+                            _ui.VxeUI.modal.message({
+                              content: $xeGrid.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;
+                          $xeGrid.updateQueryFooter();
+                        }
                       }
-                    }
-                    if (afterDelete) {
-                      afterDelete(...applyArgs);
-                    } else {
-                      internalData.uFoot = true;
-                      $xeGrid.commitProxy('query');
-                      internalData.uFoot = false;
-                      $xeGrid.updateQueryFooter();
-                    }
-                    if (deleteSuccessMethods) {
-                      deleteSuccessMethods(Object.assign(Object.assign({}, commitParams), {
-                        response: rest
-                      }));
-                    }
-                    return {
-                      status: true
-                    };
-                  }).catch(rest => {
-                    reactData.tableLoading = false;
-                    if (isRespMsg) {
-                      if (_ui.VxeUI.modal) {
-                        _ui.VxeUI.modal.message({
-                          id: code,
-                          content: $xeGrid.getRespMsg(rest, 'vxe.grid.operError'),
+                      if (deleteSuccessMethod) {
+                        deleteSuccessMethod(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 (_ui.VxeUI.modal) {
+                            _ui.VxeUI.modal.message({
+                              id: code,
+                              content: $xeGrid.getRespMsg(rest, 'vxe.grid.operError'),
+                              status: 'error'
+                            });
+                          }
+                        }
                       }
-                    }
-                    if (deleteErrorMethods) {
-                      deleteErrorMethods(Object.assign(Object.assign({}, commitParams), {
-                        response: rest
-                      }));
-                    }
-                    return {
-                      status: false
-                    };
-                  });
+                      if (deleteErrorMethod) {
+                        deleteErrorMethod(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 {
                 if (isActiveMsg) {
@@ -1052,10 +1140,12 @@ var _default = exports.default = /* define-vxe-component start */(0, _comp.defin
           }
         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 = $xeGrid.getRecordset();
               const {
                 insertRecords,
@@ -1071,9 +1161,8 @@ var _default = exports.default = /* define-vxe-component start */(0, _comp.defin
                 button,
                 body,
                 form: formData,
-                options: ajaxMethods
+                options: sMethod
               };
-              const applyArgs = [commitParams].concat(args);
               // 排除掉新增且标记为删除的数据
               if (insertRecords.length) {
                 body.pendingRecords = pendingRecords.filter(row => insertRecords.indexOf(row) === -1);
@@ -1093,54 +1182,75 @@ var _default = exports.default = /* define-vxe-component start */(0, _comp.defin
                   return;
                 }
                 if (body.insertRecords.length || removeRecords.length || updateRecords.length || body.pendingRecords.length) {
-                  reactData.tableLoading = true;
-                  return Promise.resolve((beforeSave || ajaxMethods)(...applyArgs)).then(rest => {
-                    reactData.tableLoading = false;
-                    $xeTable.clearPendingRow();
-                    if (isRespMsg) {
-                      if (_ui.VxeUI.modal) {
-                        _ui.VxeUI.modal.message({
-                          content: $xeGrid.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) {
+                        $xeTable.clearPendingRow();
+                        if (isRespMsg) {
+                          if (_ui.VxeUI.modal) {
+                            _ui.VxeUI.modal.message({
+                              content: $xeGrid.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;
+                          $xeGrid.updateQueryFooter();
+                        }
                       }
-                    }
-                    if (afterSave) {
-                      afterSave(...applyArgs);
-                    } else {
-                      internalData.uFoot = true;
-                      $xeGrid.commitProxy('query');
-                      internalData.uFoot = false;
-                      $xeGrid.updateQueryFooter();
-                    }
-                    if (saveSuccessMethods) {
-                      saveSuccessMethods(Object.assign(Object.assign({}, commitParams), {
-                        response: rest
-                      }));
-                    }
-                    return {
-                      status: true
-                    };
-                  }).catch(rest => {
-                    reactData.tableLoading = false;
-                    if (isRespMsg) {
-                      if (_ui.VxeUI.modal) {
-                        _ui.VxeUI.modal.message({
-                          id: code,
-                          content: $xeGrid.getRespMsg(rest, 'vxe.grid.operError'),
+                      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 (_ui.VxeUI.modal) {
+                            _ui.VxeUI.modal.message({
+                              id: code,
+                              content: $xeGrid.getRespMsg(rest, 'vxe.grid.operError'),
+                              status: 'error'
+                            });
+                          }
+                        }
                       }
-                    }
-                    if (saveErrorMethods) {
-                      saveErrorMethods(Object.assign(Object.assign({}, commitParams), {
-                        response: rest
-                      }));
-                    }
-                    return {
-                      status: false
-                    };
-                  });
+                      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) {
                     if (_ui.VxeUI.modal) {