@steedos-widgets/amis-lib 1.3.21 → 1.3.22-beta.2

package/dist/index.cjs.js

@@ -1789,21 +1789,21 @@ async function getQuickEditSchema(field, options){
                     break;
                 case "avatar":
                 case "image":
-                quickEditSchema.body[0].receiver.adaptor = `
-                    const { context } = api.body; 
-                    var rootUrl = context.rootUrl + "/api/files/${field.type}s/";
-                    payload = {
-                        status: response.status == 200 ? 0 : response.status,
-                        msg: response.statusText,
-                        data: {
-                            value: rootUrl + payload._id,//为了实现图片crud的回显，需要将value从id改为url，当保存数据数据时，再在发送适配器内重新将id提取出来
-                            name: payload.original.name,
-                            url: rootUrl + payload._id,
+                    quickEditSchema.body[0].receiver.adaptor = `
+                        const { context } = api.body; 
+                        var rootUrl = context.rootUrl + "/api/files/${field.type}s/";
+                        payload = {
+                            status: response.status == 200 ? 0 : response.status,
+                            msg: response.statusText,
+                            data: {
+                                value: rootUrl + payload._id,//为了实现图片crud的回显，需要将value从id改为url，当保存数据数据时，再在发送适配器内重新将id提取出来
+                                name: payload.original.name,
+                                url: rootUrl + payload._id,
+                            }
                         }
-                    }
-                    return payload;
-                `;
-                break;
+                        return payload;
+                    `;
+                    break;
             }
             quickEditSchema.body[0].visibleOn = "${quickedit_record_permissions.allowEdit && quickedit_record_permissions_loading == false}";
             quickEditSchema.body.push({
@@ -2010,6 +2010,11 @@ async function getQuickEditSchema(field, options){
         if(field.type == "location"){
             quickEditSchema = false;
         }
+        if(field.type == "color"){
+            quickEditSchema = {
+                type: "input-color"
+            };
+        }
     }
     return quickEditSchema;
 }
@@ -7995,7 +8000,8 @@ function getObjectFooterToolbar(mainObject, formFactor, options) {
         {
           "type": "pagination",
           "maxButtons": 5,
-          "showPageInput": false
+          "showPageInput": true,
+          "layout": "total,pager,go"
         }
       ]
     }
@@ -11561,6 +11567,13 @@ async function convertSFieldToAmisField(field, readonly, ctx) {
             };
             if(readonly){
                 convertData.defaultColor = null;
+            }else {
+                convertData.pipeIn = (value, data) => {
+                    if(value && value.indexOf('#')<0){
+                        return '#'+value;
+                    }
+                    return value;
+                };
             }
             break;
         case 'boolean':
@@ -11577,7 +11590,16 @@ async function convertSFieldToAmisField(field, readonly, ctx) {
                 format:'YYYY-MM-DDT00:00:00.000[Z]',
                 tpl: readonly ? getDateTpl(field) : null,
                 // utc: true,
-                joinValues: false
+                joinValues: false,
+                "shortcuts": [
+                    "thismonth",
+                    "2monthsago",
+                    "3monthslater",
+                    "prevquarter",
+                    "thisquarter",
+                    "thisyear",
+                    "lastYear"
+                  ]
             };
             break;
         case 'date':
@@ -11988,6 +12010,8 @@ async function convertSFieldToAmisField(field, readonly, ctx) {
                     let subFieldName = subField.name.replace(`${field.name}.$.`, '').replace(`${field.name}.`, '');
                     if(subField.type === 'grid'){
                         subField = await getGridFieldSubFields(subField, ctx.__formFields);
+                    }else if(subField.type === 'table'){
+                        subField = await getTabledFieldSubFields(subField, ctx.__formFields);
                     }else {
                         if(readonly){
                             subFieldName = `${field.name}.${subFieldName}`;
@@ -12104,7 +12128,8 @@ async function getFieldSearchable(perField, permissionFields, ctx){
             fieldNamePrefix = `${fieldNamePrefix}between__`;
         }
         if(_field.type === 'datetime'){
-            _field.type = 'input-datetime-range';
+            // 特意改为日期范围而不是日期时间范围，因为搜索时一般精确到日期就足够了，需要精确到日期时间范围需要在字段上配置amis属性来实现
+            _field.type = 'input-date-range';
             _field.is_wide = true;
             fieldNamePrefix = `${fieldNamePrefix}between__`;
         }
@@ -12416,7 +12441,7 @@ async function getFormBody(permissionFields, formFields, ctx){
  * @Author: 殷亮辉 yinlianghui@hotoa.com
  * @Date: 2023-11-15 09:50:22
  * @LastEditors: 殷亮辉 yinlianghui@hotoa.com
- * @LastEditTime: 2023-12-16 16:39:49
+ * @LastEditTime: 2023-12-23 22:13:22
  */
 
 /**
@@ -12462,6 +12487,28 @@ function getInputTableCell(field, showAsInlineEditMode) {
     }
 }
 
+function getComponentId(name, tag) {
+    let id = "";
+    switch (name) {
+        case "table_service":
+            id = `service_wrapper__${tag}`;
+            break;
+        case "form_pagination":
+            id = `service_popup_pagination_wrapper__${tag}`;
+            break;
+        case "form":
+            id = `form_popup__${tag}`;
+            break;
+        case "dialog":
+            id = `dialog_popup__${tag}`;
+            break;
+        default:
+            id = `${name}__${tag}`;
+            break;
+    }
+    return id;
+}
+
 /**
  * @param {*} props 
  * @param {*} mode edit/new/readonly
@@ -12509,39 +12556,46 @@ async function getInputTableColumns(props) {
     }
 }
 
-function getFormPagination(props) {
+/**
+ * @param {*} props input-table组件props
+ * @param {*} mode edit/new/readonly
+ * @returns 翻页组件
+ */
+function getFormPagination(props, mode) {
+    let showPagination = true;
+    if(mode === "new" && !!!props.editable){
+        //不允许编辑只允许新建时不应该让用户操作翻页
+        showPagination = false;
+    }
+    let buttonPrevId = getComponentId("button_prev", props.id);
+    let buttonNextId = getComponentId("button_next", props.id);
+    let formId = getComponentId("form", props.id);
+    let tableServiceId = getComponentId("table_service", props.id);
+    let formPaginationId = getComponentId("form_pagination", props.id);
     let onPageChangeScript = `
         let scope = event.context.scoped;
-        let __paginationServiceId = event.data.__paginationServiceId;
-        let __wrapperServiceId = event.data.__wrapperServiceId;
-        let __formId = event.data.__formId;
-        let fieldValue = event.data.__changedItems;//这里不可以_.cloneDeep，因为翻页form中用的是event.data.changedItems，直接变更其值即可改变表单中的值
+        let __paginationServiceId = "${formPaginationId}";
+        let __wrapperServiceId = "${tableServiceId}";
+        let __formId = "${formId}";
+        let fieldValue = event.data.__tableItems;//这里不可以_.cloneDeep，因为翻页form中用的是event.data.__tableItems，直接变更其值即可改变表单中的值
         let pageChangeDirection = context.props.pageChangeDirection;
+        // event.data中的index和__page分别表示当前要把表单数据提交到的行索引和用于标定下一页页码的当前页页码
+        // 一般来说__page = index + 1，但是可以让event.data中传入__page和index值不是这种联系。
+        // 比如__page设置为3，index设置为0表示把当前表单数据提交到第一页，但是跳转到第4页，弹出的表单中底下的新增和复制按钮依赖了此功能
+        // let currentPage = currentIndex + 1;
         let currentPage = event.data.__page;
         let currentIndex = event.data.index;
-
-        // 翻页到下一页之前需要先把当前页改动的内容保存到中间变量changedItems中
+        // 翻页到下一页之前需要先把当前页改动的内容保存到中间变量__tableItems中
         let currentFormValues = scope.getComponentById(__formId).getValues();
         fieldValue[currentIndex] = currentFormValues;
-        // // 因为翻页form中用的是event.data.changedItems中的数据，所以不需要像下面这样doAction setValue变更中间变量changedItems值
-        // doAction({
-        //     "componentId": __wrapperServiceId,
-        //     "actionType": "setValue",
-        //     "args": {
-        //         "value": {
-        //             "__changedItems": fieldValue
-        //         }
-        //     }
-        // });
-        // 如果翻页到下一页前需要同时把改动的内容保存到最终正式的表单字段中，需要额外给正式表单字段执行一次setValue
-        // 但是同时保存到正式表单字段中会造成翻页后点击取消无法取消翻页之前的改动内容
-        // doAction({
-        //     "componentId": "${props.id}",
-        //     "actionType": "setValue",
-        //     "args": {
-        //         "value": fieldValue
-        //     }
-        // });
+        // 翻页到下一页前需要同时把改动的内容保存到最终正式的表单字段中，所以额外给正式表单字段执行一次setValue
+        doAction({
+            "componentId": "${props.id}",
+            "actionType": "setValue",
+            "args": {
+                "value": fieldValue
+            }
+        });
 
         // 以下是翻页逻辑，翻到下一页并把下一页内容显示到表单上
         let targetPage;
@@ -12552,7 +12606,7 @@ function getFormPagination(props) {
             targetPage = currentPage - 1;
         }
         let targetIndex = targetPage - 1;//input-table组件行索引，从0开始的索引
-        // let targetFormData = __changedItems[targetIndex];
+        // let targetFormData = __tableItems[targetIndex];
         doAction({
             "actionType": "setValue",
             "componentId": __paginationServiceId,
@@ -12575,7 +12629,8 @@ function getFormPagination(props) {
     `;
     return {
         "type": "wrapper",
-        "className": "py-2",
+        "size": "none",
+        "className": "mr-1",
         "body": [
             {
                 "type": "button",
@@ -12583,8 +12638,9 @@ function getFormPagination(props) {
                 "icon": `fa fa-angle-left`,
                 "level": "link",
                 "pageChangeDirection": "prev",
-                "disabledOn": "${__page <= 1}",
+                "disabledOn": showPagination ? "${__page <= 1}" : "true",
                 "size": "sm",
+                "id": buttonPrevId,
                 "onEvent": {
                     "click": {
                         "actions": [
@@ -12598,7 +12654,7 @@ function getFormPagination(props) {
             },
             {
                 "type": "tpl",
-                "tpl": "${__page}/${__total}"
+                "tpl": "${__page}/${__tableItems.length}"
             },
             {
                 "type": "button",
@@ -12606,8 +12662,9 @@ function getFormPagination(props) {
                 "icon": `fa fa-angle-right`,
                 "level": "link",
                 "pageChangeDirection": "next",
-                "disabledOn": "${__page >= __total}",
+                "disabledOn": showPagination ? "${__page >= __tableItems.length}" : "true",
                 "size": "sm",
+                "id": buttonNextId,
                 "onEvent": {
                     "click": {
                         "actions": [
@@ -12627,30 +12684,27 @@ function getFormPagination(props) {
  * 传入formSchema输出带翻页容器的wrapper
  * @param {*} props input-table组件props
  * @param {*} form formSchema
- * @param {*} mode edit/readonly
+ * @param {*} mode edit/new/readonly
  * @returns 带翻页容器的wrapper
  */
 function getFormPaginationWrapper(props, form, mode) {
-    let serviceId = `service_popup_pagination_wrapper__${props.id}`;
-    // 这里加__super前缀是因为__parentForm变量（即主表单）中可能会正好有名为index的字段
-    // 比如“对象字段”对象options字段是一个子表字段，但是主表（即“对象字段”对象）中正好有一个名为index的字段
-    // 只读的时候不可以走中间变量__changedItems，比如工作流规则详细页面修改了子表字段”时间触发器“值后，在只读界面点击查看按钮弹出的表单中__changedItems值是修改前的值
-    let formValues = mode === "readonly" ? `\${${props.name}[__super.index]}` : "${__changedItems[__super.index]}";
-    // 这时用__readonlyItemsLength是因为`\${${props.name}.length}`拿不到值
-    let totalValue = mode === "readonly" ? "${__readonlyItemsLength}" : "${__changedItems.length}";
+    console.log("==getFormPaginationWrapper===", props, mode);
+    let serviceId = getComponentId("form_pagination", props.id);
+    let tableServiceId = getComponentId("table_service", props.id);
     let innerForm = Object.assign({}, form, {
         "data": {
-            // "&": "${__changedItems[__super.index]}"
-            "&": formValues,
+            // 这里加__super前缀是因为__parentForm变量（即主表单）中可能会正好有名为index的字段
+            // 比如“对象字段”对象options字段是一个子表字段，但是主表（即“对象字段”对象）中正好有一个名为index的字段
+            "&": "${__tableItems[__super.index]}"
         }
     });
     let formBody = [
         {
             "type": "wrapper",
             "size": "none",
-            "className": "flex justify-end border-y border-gray-200 -mx-6 shadow-inner sticky top-0 right-0 left-0 z-20 bg-white mb-4",
+            "className": "flex justify-end sticky top-0 right-0 left-0 z-20 bg-white -mt-2",
             "body": [
-                getFormPagination(props)
+                getFormPagination(props, mode)
             ]
         },
         {
@@ -12664,49 +12718,45 @@ function getFormPaginationWrapper(props, form, mode) {
         }
     ];
     let onServiceInitedScript = `
-        // 以下脚本在inlineEditMode模式时才有必要执行（不过执行了也没有坏处，纯粹是没必要），是为了解决：
-        // inlineEditMode模式时，用户在表格单元格中直接修改数据，然后弹出的表单form中并没有包含单元格中修改的内容
-        // 思路是每次弹出form之前先把其changedItems同步更新为最新值，这样就能在弹出form中包含单元格中做的修改
+        // 以下脚本是为了解决有时弹出编辑表单时，表单中的值比最后一次编辑保存的值会延迟一拍。
+        // 比如：inlineEditMode模式时，用户在表格单元格中直接修改数据，然后弹出的表单form中并没有包含单元格中修改的内容
+        // 另外有的地方在非inlineEditMode模式时也会有这种延迟一拍问题，比如对象字段中下拉框类型字段的”选择项“属性
+        // 再比如工作流规则详细页面修改了子表字段”时间触发器“值后，在只读界面点击查看按钮弹出的表单中__tableItems值是修改前的值
+        // 处理思路是每次弹出form之前先把其__tableItems同步更新为最新值，这样就能在弹出form中包含单元格中做的修改
         // 注意：service init事件只会在每次弹出窗口时才执行，在触发翻页时并不会触发service init事件
-        let inlineEditMode = ${props.inlineEditMode};
-        if(!inlineEditMode){
-            return;
-        }
         let scope = event.context.scoped;
-        let __wrapperServiceId = event.data.__wrapperServiceId;
+        let __wrapperServiceId = "${tableServiceId}";
         let wrapperService = scope.getComponentById(__wrapperServiceId);
         let wrapperServiceData = wrapperService.getData();
         let lastestFieldValue = wrapperServiceData["${props.name}"];//这里不可以用event.data["${props.name}"]因为amis input talbe有一层单独的作用域，其值会延迟一拍
-        //不可以直接像event.data.__changedItems = originalFieldValue; 这样整个赋值，否则作用域会断
-        event.data.__changedItems.forEach(function(n,i){
-            event.data.__changedItems[i] = lastestFieldValue[i];
+        //不可以直接像event.data.__tableItems = lastestFieldValue; 这样整个赋值，否则作用域会断
+        event.data.__tableItems.forEach(function(n,i){
+            event.data.__tableItems[i] = lastestFieldValue[i];
         });
     `;
     let schema = {
         "type": "service",
         "id": serviceId,
         "schemaApi": {
-            "url": "${context.rootUrl}/graphql?rebuildOn=${index}",
-            // "url": "${context.rootUrl}/graphql",
-            "method": "post",
-            "headers": {
-                "Authorization": "Bearer ${context.tenantId},${context.authToken}"
-            },
-            "requestAdaptor": "api.data={query: '{spaces__findOne(id: \"none\"){_id,name}}'};return api;",
+            // "url": "${context.rootUrl}/graphql?rebuildOn=${index}",
+            "url": "${context.rootUrl}/api/v1/spaces/none",
+            "trackExpression": "${index}",
+            "method": "get",
             "adaptor": `
                 const formBody = ${JSON.stringify(formBody)};
                 return {
                     "body": formBody
                 }
-            `
+            `,
+            "cache": 600000
         },
         // "body": formBody,
         "data": {
             "__page": "${index + 1}",
             // "__total": `\${${props.name}.length}`,
-            "__total": totalValue,
-            "__paginationServiceId": serviceId,
-            "__formId": form.id
+            // "__total": "${__tableItems.length}",
+            // "__paginationServiceId": serviceId,
+            // "__formId": form.id
         },
         "onEvent": {
             "init": {
@@ -12726,13 +12776,15 @@ function getFormPaginationWrapper(props, form, mode) {
  * @param {*} props 
  * @param {*} mode edit/new/readonly
  */
-async function getForm(props, mode = "edit") {
+async function getForm(props, mode = "edit", formId) {
     let formFields = getFormFields(props, mode);
     let body = await getFormBody(null, formFields);
-    let forId = `form_popup__${props.id}`;
+    if (!formId) {
+        formId = getComponentId("form", props.id);
+    }
     let schema = {
         "type": "form",
-        "id": forId,
+        "id": formId,
         "title": "表单",
         "debug": false,
         "mode": "normal",
@@ -12744,8 +12796,7 @@ async function getForm(props, mode = "edit") {
     if (mode === "edit") {
         let onEditItemSubmitScript = `
             // let fieldValue = _.cloneDeep(event.data["${props.name}"]);
-            let fieldValue = event.data.__changedItems;//这里不可以_.cloneDeep，因为翻页form中用的是event.data.changedItems，直接变更其值即可改变表单中的值
-
+            let fieldValue = event.data.__tableItems;//这里不可以_.cloneDeep，因为翻页form中用的是event.data.__tableItems，直接变更其值即可改变表单中的值
             //这里加__super.__super前缀是因为__parentForm变量（即主表单）中可能会正好有名为index的字段
             // 比如“对象字段”对象options字段是一个子表字段，但是主表（即“对象字段”对象）中正好有一个名为index的字段
             fieldValue[event.data.__super.__super.index] = JSON.parse(JSON.stringify(event.data));
@@ -12756,16 +12807,6 @@ async function getForm(props, mode = "edit") {
                     "value": fieldValue
                 }
             });
-            // // 因为翻页form中用的是event.data.changedItems中的数据，所以不需要像下面这样doAction setValue变更中间变量changedItems值
-            // doAction({
-            //     "componentId": event.data.__wrapperServiceId,
-            //     "actionType": "setValue",
-            //     "args": {
-            //         "value": {
-            //             "__changedItems": fieldValue
-            //         }
-            //     }
-            // });
         `;
         Object.assign(schema, {
             "onEvent": {
@@ -12793,29 +12834,30 @@ async function getForm(props, mode = "edit") {
     }
     else if (mode === "new") {
         let onNewItemSubmitScript = `
-            // let fieldValue = _.cloneDeep(event.data["${props.name}"]);
-            if(!event.data.__changedItems){
-                event.data.__changedItems = [];
+            let newItem = JSON.parse(JSON.stringify(event.data));
+            if(event.data["${props.name}"]){
+                // let fieldValue = event.data.__tableItems;
+                // 这里不用__tableItems是因为新建的时候没有翻页，里面没有也不需要走__tableItems变量
+                let fieldValue = event.data["${props.name}"];
+                fieldValue.push(newItem);
+                doAction({
+                    "componentId": "${props.id}",
+                    "actionType": "setValue",
+                    "args": {
+                        "value": fieldValue
+                    }
+                });
+            }
+            else{
+                // 这里不可以执行event.data["${props.name}"]=[newItem]，数据域会断掉
+                doAction({
+                    "componentId": "${props.id}",
+                    "actionType": "setValue",
+                    "args": {
+                        "value": [newItem]
+                    }
+                });
             }
-            let fieldValue = event.data.__changedItems;
-            fieldValue.push(JSON.parse(JSON.stringify(event.data)));
-            doAction({
-                "componentId": "${props.id}",
-                "actionType": "setValue",
-                "args": {
-                    "value": fieldValue
-                }
-            });
-            // // 因为翻页form中用的是event.data.changedItems中的数据，所以不需要像下面这样doAction setValue变更中间变量changedItems值
-            // doAction({
-            //     "componentId": event.data.__wrapperServiceId,
-            //     "actionType": "setValue",
-            //     "args": {
-            //         "value": {
-            //             "__changedItems": fieldValue
-            //         }
-            //     }
-            // });
         `;
         Object.assign(schema, {
             "onEvent": {
@@ -12841,12 +12883,271 @@ async function getForm(props, mode = "edit") {
             }
         });
     }
-    if (mode === "edit" || mode === "readonly") {
-        schema = getFormPaginationWrapper(props, schema, mode);
-    }
+    schema = getFormPaginationWrapper(props, schema, mode);
     return schema;
 }
 
+
+/**
+ * 编辑、新增和查看按钮actions
+ * @param {*} props 
+ * @param {*} mode edit/new/readonly
+ */
+async function getButtonActions(props, mode) {
+    let actions = [];
+    let formId = getComponentId("form", props.id);
+    let dialogId = getComponentId("dialog", props.id);
+    let buttonNextId = getComponentId("button_next", props.id);
+    let formPaginationId = getComponentId("form_pagination", props.id);
+    if (mode == "new" || mode == "edit") {
+        // let actionShowNewDialog = {
+        //     "actionType": "dialog",
+        //     "dialog": {
+        //         "type": "dialog",
+        //         "title": "新增行",
+        //         "body": [
+        //             await getForm(props, "new", formId)
+        //         ],
+        //         "size": "lg",
+        //         "showCloseButton": true,
+        //         "showErrorMsg": true,
+        //         "showLoading": true,
+        //         "className": "app-popover",
+        //         "closeOnEsc": false,
+        //         "onEvent": {
+        //             "confirm": {
+        //                 "actions": [
+        //                     {
+        //                         "actionType": "validate",
+        //                         "componentId": formId
+        //                     },
+        //                     {
+        //                         "preventDefault": true,
+        //                         "expression": "${event.data.validateResult.error}" //触发表单校验结果会存入validateResult，amis 3.2不支持，高版本比如 3.5.3支持
+        //                     }
+        //                 ]
+        //             }
+        //         }
+        //     }
+        // };
+        let onSaveAndNewItemScript = `
+            let scope = event.context.scoped;
+            let fieldValue = event.data.__tableItems;//这里不可以_.cloneDeep，因为翻页form中用的是event.data.__tableItems，直接变更其值即可改变表单中的值
+            // 新建一条空白行并保存到子表组件
+            fieldValue.push({});
+            doAction({
+                "componentId": "${props.id}",
+                "actionType": "setValue",
+                "args": {
+                    "value": fieldValue
+                }
+            });
+            let buttonNextId = "${buttonNextId}";
+            let __paginationServiceId = "${formPaginationId}";
+            let __paginationData = scope.getComponentById(__paginationServiceId).getData();
+            event.data.index = __paginationData.index;
+            event.data.__page = fieldValue.length - 1;//这里不可以用Object.assign否则，event.data中上层作用域数据会丢失
+            // 触发翻页按钮事件，实现保存当前页数据并跳转到最后一行
+            scope.getComponentById(buttonNextId).props.dispatchEvent("click", event.data);
+        `;
+        let onSaveAndCopyItemScript = `
+            let scope = event.context.scoped;
+            let __formId = "${formId}";
+            // let newItem = JSON.parse(JSON.stringify(event.data));
+            let newItem = scope.getComponentById(__formId).getValues();//这里不可以用event.data，因为其拿到的是弹出表单时的初始值，不是用户实时填写的数据
+            let fieldValue = event.data.__tableItems;//这里不可以_.cloneDeep，因为翻页form中用的是event.data.__tableItems，直接变更其值即可改变表单中的值
+            // 复制当前页数据到新建行并保存到子表组件
+            fieldValue.push(newItem);
+            doAction({
+                "componentId": "${props.id}",
+                "actionType": "setValue",
+                "args": {
+                    "value": fieldValue
+                }
+            });
+            let buttonNextId = "${buttonNextId}";
+            let __paginationServiceId = "${formPaginationId}";
+            let __paginationData = scope.getComponentById(__paginationServiceId).getData();
+            event.data.index = __paginationData.index;
+            event.data.__page = fieldValue.length - 1;//这里不可以用Object.assign否则，event.data中上层作用域数据会丢失
+            // 触发翻页按钮事件，实现保存当前页数据并跳转到最后一行
+            scope.getComponentById(buttonNextId).props.dispatchEvent("click", event.data);
+        `;
+        let dialogButtons = [
+            {
+            "type": "button",
+            "label": "完成",
+            "actionType": "confirm",
+            "level": "primary"
+            }
+        ];
+        if(props.addable){
+            dialogButtons = [
+                {
+                    "type": "button",
+                    "label": "新增",
+                    "tooltip": "保存并新增一行，即保存当前行数据并新增一条空白行",
+                    "onEvent": {
+                        "click": {
+                            "actions": [
+                                {
+                                    "actionType": "custom",
+                                    "script": onSaveAndNewItemScript
+                                }
+                            ]
+                        }
+                    }
+                },
+                {
+                    "type": "button",
+                    "label": "复制",
+                    "tooltip": "复制并新增一行，即保存当前行数据并复制当前行数据到新增行",
+                    "onEvent": {
+                        "click": {
+                            "actions": [
+                                {
+                                    "actionType": "custom",
+                                    "script": onSaveAndCopyItemScript
+                                }
+                            ]
+                        }
+                    }
+                },
+                dialogButtons[0]
+            ];
+        }
+        let actionShowEditDialog = {
+            "actionType": "dialog",
+            "dialog": {
+                "type": "dialog",
+                "id": dialogId,
+                "title": `\${uiSchema.fields.${props.name}.label} 明细`,
+                "body": [
+                    await getForm(props, mode, formId)
+                ],
+                "size": "lg",
+                "showCloseButton": true,
+                "showErrorMsg": true,
+                "showLoading": true,
+                "className": "app-popover",
+                "closeOnEsc": false,
+                "data": {
+                    // 这里必须加data数据映射，否则翻页功能中取__tableItems值时会乱，比如翻页编辑后会把上一页中没改过的字段值带过去
+                    // 额外把华炎魔方主表记录ObjectForm中的字段值从record变量中映射到子表form中，因为子表lookup字段filtersFunction中可能依赖了主表记录中的字段值，比如“工作流规则”对象“时间触发器”字段中的“日期字段”字段
+                    // 额外把global、uiSchema也映射过去，有可能要用，后续需要用到其他变更可以这里加映射
+                    // "&": "${record || {}}",
+                    // 换成从__super来映射上级表单数据是因为对象列表视图界面中每行下拉菜单中的编辑按钮弹出的表单中的子表所在作用域中没有record变量
+                    // 映射到中间变量__parentForm而不是直接用&展开映射是为了避免表单中字段名与作用域中变量重名
+                    // "__parentForm": "${__super.__super || {}}",
+                    "__parentForm": mode == "new" ? "$$" : "${__super.__super || {}}",
+                    "global": "${global}",
+                    "uiSchema": "${uiSchema}",
+                    "index": "${index}",
+                    // "__tableItems": `\${${props.name}}`
+                    // 为了解决"弹出的dialog窗口中子表组件会影响页面布局界面中父作用域字段值"，比如设计字段布局微页面中的设置分组功能，弹出的就是子表dialog
+                    // 所以这里使用json|toJson转一次，断掉event.data.__tableItems与上层任用域中props.name的联系
+                    "__tableItems": `\${${props.name}|json|toJson}`
+                },
+                "actions": dialogButtons,
+                "onEvent": {
+                    "confirm": {
+                        "actions": [
+                            {
+                                "actionType": "validate",
+                                "componentId": formId
+                            },
+                            {
+                                "preventDefault": true,
+                                "expression": "${event.data.validateResult.error}" //触发表单校验结果会存入validateResult，amis 3.2不支持，高版本比如 3.5.3支持
+                            }
+                        ]
+                    }
+                }
+            }
+        };
+        if (props.dialog) {
+            Object.assign(actionShowEditDialog.dialog, props.dialog);
+        }
+        if (mode == "new") {
+            let onNewLineScript = `
+                let newItem = {};
+                if(event.data["${props.name}"]){
+                    // let fieldValue = event.data.__tableItems;
+                    // 这里不用__tableItems是因为新建的时候没有翻页，里面没有也不需要走__tableItems变量
+                    let fieldValue = event.data["${props.name}"];
+                    fieldValue.push(newItem);
+                    doAction({
+                        "componentId": "${props.id}",
+                        "actionType": "setValue",
+                        "args": {
+                            "value": fieldValue
+                        }
+                    });
+                    event.data.index = fieldValue.length - 1;
+                }
+                else{
+                    // 这里不可以执行event.data["${props.name}"]=[newItem]，数据域会断掉
+                    doAction({
+                        "componentId": "${props.id}",
+                        "actionType": "setValue",
+                        "args": {
+                            "value": [newItem]
+                        }
+                    });
+                    event.data.index = 1;
+                }
+            `;
+            let actionNewLine = {
+                "actionType": "custom",
+                "script": onNewLineScript
+            };
+            actions = [actionNewLine, actionShowEditDialog];
+        }
+        else if (mode == "edit") {
+            actions = [actionShowEditDialog];
+        }
+    }
+    else if (mode == "readonly") {
+        actions = [
+            {
+                "actionType": "dialog",
+                "dialog": {
+                    "type": "dialog",
+                    "title": `\${uiSchema.fields.${props.name}.label} 明细`,
+                    "body": [
+                        await getForm(props, "readonly")
+                    ],
+                    "size": "lg",
+                    "showCloseButton": true,
+                    "showErrorMsg": true,
+                    "showLoading": true,
+                    "className": "app-popover",
+                    "closeOnEsc": false,
+                    "actions": [],
+                    "data": {
+                        // 这里必须加data数据映射，否则翻页功能中取__tableItems值时会乱，比如翻页编辑后会把上一页中没改过的字段值带过去
+                        // 额外把华炎魔方主表记录ObjectForm中的字段值从record变量中映射到子表form中，因为子表lookup字段filtersFunction中可能依赖了主表记录中的字段值，比如“工作流规则”对象“时间触发器”字段中的“日期字段”字段
+                        // 额外把global、uiSchema也映射过去，有可能要用，后续需要用到其他变更可以这里加映射
+                        // "&": "${record || {}}",
+                        // 换成从__super来映射上级表单数据是因为对象列表视图界面中每行下拉菜单中的编辑按钮弹出的表单中的子表所在作用域中没有record变量
+                        // 映射到中间变量__parentForm而不是直接用&展开映射是为了避免表单中字段名与作用域中变量重名
+                        // "__parentForm": "${__super.__super || {}}",
+                        "__parentForm": "${__super.__super || {}}",
+                        "global": "${global}",
+                        "uiSchema": "${uiSchema}",
+                        "index": "${index}",
+                        // "__tableItems": `\${${props.name}}`
+                        // 为了解决"弹出的dialog窗口中子表组件会影响页面布局界面中父作用域字段值"，比如设计字段布局微页面中的设置分组功能，弹出的就是子表dialog
+                        // 所以这里使用json|toJson转一次，断掉event.data.__tableItems与上层任用域中props.name的联系
+                        "__tableItems": `\${${props.name}|json|toJson}`
+                    },
+                }
+            }
+        ];
+    }
+    return actions;
+}
+
 async function getButtonNew(props) {
     return {
         "label": "新增",
@@ -12854,24 +13155,7 @@ async function getButtonNew(props) {
         "icon": "fa fa-plus",
         "onEvent": {
             "click": {
-                "actions": [
-                    {
-                        "actionType": "dialog",
-                        "dialog": {
-                            "type": "dialog",
-                            "title": "新增行",
-                            "body": [
-                                await getForm(props, "new")
-                            ],
-                            "size": "lg",
-                            "showCloseButton": true,
-                            "showErrorMsg": true,
-                            "showLoading": true,
-                            "className": "app-popover",
-                            "closeOnEsc": false
-                        }
-                    }
-                ]
+                "actions": await getButtonActions(props, "new")
             }
         },
         "level": "primary"
@@ -12879,76 +13163,14 @@ async function getButtonNew(props) {
 }
 
 async function getButtonEdit(props, showAsInlineEditMode) {
-    let onCancelScript = `
-        let scope = event.context.scoped;
-        let __wrapperServiceId = event.data.__wrapperServiceId;
-        let wrapperService = scope.getComponentById(__wrapperServiceId);
-        let wrapperServiceData = wrapperService.getData();
-        let originalFieldValue = wrapperServiceData["${props.name}"];//这里不可以用event.data["${props.name}"]因为amis input talbe有一层单独的作用域，其值会延迟一拍
-        //不可以直接像event.data.__changedItems = originalFieldValue; 这样整个赋值，否则作用域会断，造成无法还原
-        event.data.__changedItems.forEach(function(n,i){
-            event.data.__changedItems[i] = originalFieldValue[i];
-        });
-        // 因为翻页form中用的是event.data.changedItems中的数据，所以像下面这样doAction setValue无法实现还原
-        // doAction({
-        //     "componentId": __wrapperServiceId,
-        //     "actionType": "setValue",
-        //     "args": {
-        //         "value": {
-        //             "__changedItems": originalFieldValue
-        //         }
-        //     }
-        // });
-    `;
     return {
         "type": "button",
         "label": "",
-        "icon": `fa fa-${showAsInlineEditMode ? "expand" : "pencil"}`,//inline edit模式时显示为放开按钮，只读时显示为笔按钮
+        "icon": `fa fa-${showAsInlineEditMode ? "expand-alt" : "pencil"}`,//inline edit模式时显示为放开按钮，只读时显示为笔按钮
         "level": "link",
         "onEvent": {
             "click": {
-                "actions": [
-                    {
-                        "actionType": "dialog",
-                        "dialog": {
-                            "type": "dialog",
-                            "title": "编辑行",
-                            "body": [
-                                await getForm(props, "edit")
-                            ],
-                            "size": "lg",
-                            "showCloseButton": true,
-                            "showErrorMsg": true,
-                            "showLoading": true,
-                            "className": "app-popover",
-                            "closeOnEsc": false,
-                            "data": {
-                                // 这里必须加data数据映射，否则翻页功能中取changedItems值时会乱，比如翻页编辑后会把上一页中没改过的字段值带过去
-                                // 额外把华炎魔方主表记录ObjectForm中的字段值从record变量中映射到子表form中，因为子表lookup字段filtersFunction中可能依赖了主表记录中的字段值，比如“工作流规则”对象“时间触发器”字段中的“日期字段”字段
-                                // 额外把global、uiSchema也映射过去，有可能要用，后续需要用到其他变更可以这里加映射
-                                // "&": "${record || {}}",
-                                // 换成从__super来映射上级表单数据是因为对象列表视图界面中每行下拉菜单中的编辑按钮弹出的表单中的子表所在作用域中没有record变量
-                                // 映射到中间变量__parentForm而不是直接用&展开映射是为了避免表单中字段名与作用域中变量重名
-                                "__parentForm": "${__super.__super || {}}",
-                                "global": "${global}",
-                                "uiSchema": "${uiSchema}",
-                                "index": "${index}",
-                                "__changedItems": "${__changedItems}",
-                                "__wrapperServiceId": "${__wrapperServiceId}"
-                            },
-                            "onEvent": {
-                                "cancel": {
-                                    "actions": [
-                                        {
-                                            "actionType": "custom",
-                                            "script": onCancelScript
-                                        }
-                                    ]
-                                }
-                            }
-                        }
-                    }
-                ]
+                "actions": await getButtonActions(props, "edit")
             }
         }
     };
@@ -12958,78 +13180,38 @@ async function getButtonView(props) {
     return {
         "type": "button",
         "label": "",
-        "icon": "fa fa-expand",//fa-external-link
+        "icon": "fa fa-expand-alt",//fa-external-link
         "level": "link",
         "onEvent": {
             "click": {
-                "actions": [
-                    {
-                        "actionType": "dialog",
-                        "dialog": {
-                            "type": "dialog",
-                            "title": "查看行",
-                            "body": [
-                                await getForm(props, "readonly")
-                            ],
-                            "size": "lg",
-                            "showCloseButton": true,
-                            "showErrorMsg": true,
-                            "showLoading": true,
-                            "className": "app-popover",
-                            "closeOnEsc": false,
-                            "actions": [],
-                            "data": {
-                                // 这里必须加data数据映射，否则翻页功能中取changedItems值时会乱，比如翻页编辑后会把上一页中没改过的字段值带过去
-                                // 额外把华炎魔方主表记录ObjectForm中的字段值从formData变量中映射到子表form中，因为子表lookup字段filtersFunction中可能依赖了主表记录中的字段值，比如“工作流规则”对象“时间触发器”字段中的“日期字段”字段
-                                // global、uiSchema等常用变量本来就在formData变量已经存在了，无需另外映射
-                                // "&": "${formData || {}}",
-                                // 换成从__super来映射上级表单数据是因为对象列表视图界面中每行下拉菜单中的编辑按钮弹出的表单中的子表所在作用域中没有formData变量
-                                // 映射到中间变量__parentForm而不是直接用&展开映射是为了避免表单中字段名与作用域中变量重名
-                                "__parentForm": "${__super.__super || {}}",
-                                "index": "${index}",
-                                "__changedItems": "${__changedItems}",
-                                "__wrapperServiceId": "${__wrapperServiceId}",
-                                "__readonlyItemsLength": `\${${props.name}.length}`
-                            }
-                        }
-                    }
-                ]
+                "actions": await getButtonActions(props, "readonly")
             }
         }
     };
 }
 
 function getButtonDelete(props) {
+    let tableServiceId = getComponentId("table_service", props.id);
     let onDeleteItemScript = `
-        // let fieldValue = _.cloneDeep(event.data["${props.name}"]);
-        if(!event.data.__changedItems){
-            event.data.__changedItems = [];
-        }
-        let fieldValue = event.data.__changedItems;
-        // fieldValue.push(JSON.parse(JSON.stringify(event.data)));
-        fieldValue.splice(event.data.index, 1)
+        // let fieldValue = event.data["${props.name}"];
+        let scope = event.context.scoped;
+        let __wrapperServiceId = "${tableServiceId}";
+        let wrapperService = scope.getComponentById(__wrapperServiceId);
+        let wrapperServiceData = wrapperService.getData();
+        let lastestFieldValue = wrapperServiceData["${props.name}"];//这里不可以用event.data["${props.name}"]因为amis input talbe有一层单独的作用域，其值会延迟一拍
+        lastestFieldValue.splice(event.data.index, 1);
         doAction({
             "componentId": "${props.id}",
             "actionType": "setValue",
             "args": {
-                "value": fieldValue
+                "value": lastestFieldValue
             }
         });
-        // // 因为翻页form中用的是event.data.changedItems中的数据，所以不需要像下面这样doAction setValue变更中间变量changedItems值
-        // doAction({
-        //     "componentId": event.data.__wrapperServiceId,
-        //     "actionType": "setValue",
-        //     "args": {
-        //         "value": {
-        //             "__changedItems": fieldValue
-        //         }
-        //     }
-        // });
     `;
     return {
         "type": "button",
         "label": "",
-        "icon": "fa fa-minus",
+        "icon": "fa fa-trash-alt",//不可以用fa-trash-o，因为设计字段布局界面中弹出的设置分组列表中显示不了这个图标
         "level": "link",
         "onEvent": {
             "click": {
@@ -13055,20 +13237,22 @@ const getAmisInputTableSchema = async (props) => {
     if (!props.id) {
         props.id = "steedos_input_table_" + props.name + "_" + Math.random().toString(36).substr(2, 9);
     }
-    let serviceId = `service_wrapper__${props.id}`;
+    let serviceId = getComponentId("table_service", props.id);
     let buttonsForColumnOperations = [];
     let inlineEditMode = props.inlineEditMode;
     let showAsInlineEditMode = inlineEditMode && props.editable;
     if (props.editable) {
         let showEditButton = true;
         if (showAsInlineEditMode) {
-            // inline edit模式下只在有列被隐藏时才需要显示编辑按钮
-            if (props.columns && props.columns.length > 0 && props.columns.length < props.fields.length) {
-                showEditButton = true;
-            }
-            else {
-                showEditButton = false;
-            }
+            // 始终显示弹出子表表单按钮，如果需要判断只在有列被隐藏时才需要显示弹出表单按钮放开下面的if逻辑就好
+            showEditButton = true;
+            // // inline edit模式下只在有列被隐藏时才需要显示编辑按钮
+            // if (props.columns && props.columns.length > 0 && props.columns.length < props.fields.length) {
+            //     showEditButton = true;
+            // }
+            // else {
+            //     showEditButton = false;
+            // }
         }
         // 编辑时显示编辑按钮
         if (showEditButton) {
@@ -13078,11 +13262,9 @@ const getAmisInputTableSchema = async (props) => {
     }
     else {
         // 只读时显示查看按钮
-        if (props.columns && props.columns.length > 0 && props.columns.length < props.fields.length) {
-            // 只在有列被隐藏时才需要显示查看按钮
-            let buttonViewSchema = await getButtonView(props);
-            buttonsForColumnOperations.push(buttonViewSchema);
-        }
+        // 如果想只在有列被隐藏时才需要显示查看按钮可以加上判断：if (props.columns && props.columns.length > 0 && props.columns.length < props.fields.length)
+        let buttonViewSchema = await getButtonView(props);
+        buttonsForColumnOperations.push(buttonViewSchema);
     }
     if (props.removable) {
         let buttonDeleteSchema = getButtonDelete(props);
@@ -13118,85 +13300,51 @@ const getAmisInputTableSchema = async (props) => {
     if (showAsInlineEditMode) {
         inputTableSchema.needConfirm = false;
     }
-    let dataProviderInited = `
-        // 单独维护一份中间变量changedItems，因为原变量在input-table组件有单独的作用域，翻页功能中无法维护此作用域中的行记录值
-        setData({ __changedItems: _.cloneDeep(data["${props.name}"]) || []});
-    `;
-    let onInitScript = `
-        // 上面dataProviderInited中setData有时不生效，没有成功给service组件设置__changedItems变量值
-        // 比如设计字段布局界面中的设置分组功能就因为__changedItems变量值不存在而报错，应该是因为把steedos-input-table组件单独放到弹出窗口中会有这个问题
-        // 所以额外在service init事件中手动设置一次__changedItems值
-        let __wrapperServiceId = event.data.__wrapperServiceId;
-        let fieldValue = _.cloneDeep(event.data["${props.name}"]) || [];
-        doAction({
-            "componentId": __wrapperServiceId,
-            "actionType": "setValue",
-            "args": {
-                "value": {
-                    "__changedItems": fieldValue
-                }
-            }
+    let amis = props["input-table"] || props.amis;//额外支持"input-table"代替amis属性，是因为在字段yml文件中用amis作为key不好理解
+    if (amis) {
+        // 支持配置amis属性重写或添加最终生成的input-table中任何属性。
+        delete amis.id;//如果steedos-input-table组件配置了amis.id属性，会造成新建编辑行功能不生效
+        Object.assign(inputTableSchema, amis);
+    }
+    const isAnyFieldHasDependOn = (props.fields || []).find(function (item) {
+        return item.depend_on;
+    });
+    if (isAnyFieldHasDependOn) {
+        // 有任意一个子字段有depend_on属性时，强制设置禁用静态模式
+        Object.assign(inputTableSchema, {
+            strictMode: false
         });
-        // 下面的doAction好像不是必须的
-        // doAction({
-        //     "componentId": "${props.id}",
-        //     "actionType": "setValue",
-        //     "args": {
-        //         "value": fieldValue
-        //     }
-        // });
-    `;
-    let schema = {
-        "type": "service",
-        "body": [
-            inputTableSchema
-        ],
-        "className": props.className,
-        "id": serviceId,
-        "data": {
-            "__wrapperServiceId": serviceId
-        },
-        "dataProvider": {
-            "inited": dataProviderInited
-        },
-        "onEvent": {
-          "init": {
-            "actions": [
-              {
-                "actionType": "custom",
-                "script": onInitScript
-              }
-            ]
-          }
-        }
-    };
+    }
+    let schemaBody = [inputTableSchema];
     let footerToolbar = _$1.clone(props.footerToolbar || []); //这里不clone的话，会造成死循环，应该是因为props属性变更会让组件重新渲染
     if (props.addable) {
         let buttonNewSchema = await getButtonNew(props);
         footerToolbar.unshift(buttonNewSchema);
     }
     if (footerToolbar.length) {
-        schema.body.push({
+        schemaBody.push({
             "type": "wrapper",
             "size": "none",
             "body": footerToolbar
         });
     }
-    let amis = props["input-table"] || props.amis;//额外支持"input-table"代替amis属性，是因为在字段yml文件中用amis作为key不好理解
-    if (amis) {
-        // 支持配置amis属性重写或添加最终生成的input-table中任何属性。
-        delete amis.id;//如果steedos-input-table组件配置了amis.id属性，会造成新建编辑行功能不生效
-        Object.assign(schema.body[0], amis);
-    }
-    const isAnyFieldHasDependOn = (props.fields || []).find(function (item) {
-        return item.depend_on;
-    });
-    if(isAnyFieldHasDependOn){
-        // 有任意一个子字段有depend_on属性时，强制设置禁用静态模式
-        Object.assign(schema.body[0], {
-            strictMode: false
+    // 直接把headerToolbar unshift进schemaBody，不会显示在label下面，而是显示在上面了，这个暂时没有解决办法，只能等amis 升级
+    // 看起来amis官方后续会支持给input-table组件配置headerToolbar，见：https://github.com/baidu/amis/issues/7246
+    // 不过依然放开此功能的意义在于有的场景字段label本来就不需要显示出来，此时headerToolbar就有意义
+    let headerToolbar = _$1.clone(props.headerToolbar || []); //这里不clone的话，会造成死循环，应该是因为props属性变更会让组件重新渲染
+    if (headerToolbar.length) {
+        schemaBody.unshift({
+            "type": "wrapper",
+            "size": "none",
+            "body": headerToolbar
         });
     }
+    let schema = {
+        "type": "service",
+        "body": schemaBody,
+        "className": props.className,
+        "id": serviceId
+    };
     // console.log("===schema===", schema);
     return schema;
 };