@steedos-widgets/amis-lib 3.6.2-beta.10 → 3.6.2-beta.12

package/dist/index.esm.js

@@ -354,6 +354,9 @@ const Router = {
         if(uiSchema.enable_split){
             defaultDisplay = "split";
         }
+        if(window.innerWidth <= 768){
+            return "grid";
+        }
         return value ? value : defaultDisplay;
     },
   
@@ -1281,6 +1284,7 @@ var frontend_notifications$1 = "Notifications";
 var frontend_notifications_allread$1 = "Mark all as read";
 var frontend_notifications_allread_message$1 = "All marked as read";
 var frontend_profile$1 = "Profile";
+var switch_space$1 = "Switch Space";
 var frontend_about$1 = "About";
 var frontend_log_out$1 = "Log out";
 var frontend_listview_warning_start$1 = "The current ";
@@ -1368,6 +1372,7 @@ var en_us = {
 	frontend_notifications_allread: frontend_notifications_allread$1,
 	frontend_notifications_allread_message: frontend_notifications_allread_message$1,
 	frontend_profile: frontend_profile$1,
+	switch_space: switch_space$1,
 	frontend_about: frontend_about$1,
 	frontend_log_out: frontend_log_out$1,
 	frontend_listview_warning_start: frontend_listview_warning_start$1,
@@ -1457,6 +1462,7 @@ var frontend_notifications = "通知";
 var frontend_notifications_allread = "全部标记为已读";
 var frontend_notifications_allread_message = "已全部标记为已读";
 var frontend_profile = "个人资料";
+var switch_space = "切换工作区";
 var frontend_about = "关于";
 var frontend_log_out = "注销";
 var frontend_listview_warning_start = "当前";
@@ -1545,6 +1551,7 @@ var zh_cn = {
 	frontend_notifications_allread: frontend_notifications_allread,
 	frontend_notifications_allread_message: frontend_notifications_allread_message,
 	frontend_profile: frontend_profile,
+	switch_space: switch_space,
 	frontend_about: frontend_about,
 	frontend_log_out: frontend_log_out,
 	frontend_listview_warning_start: frontend_listview_warning_start,
@@ -2033,7 +2040,7 @@ async function getQuickEditSchema(field, options){
 }
 
 function getFieldWidth(width){
-    const defaultWidth = "unset";//用于使table内的td标签下生成div，实现将快速编辑按钮固定在右侧的效果，并不是为了unset效果
+    const defaultWidth = null;
     if(typeof width == 'string'){
         if(isNaN(width)){
             return width || defaultWidth;
@@ -2063,14 +2070,14 @@ async function getTableColumns(fields, options){
         //增加quickEdit属性，实现快速编辑
         const quickEditSchema = allowEdit ? await getQuickEditSchema(field, options) : allowEdit;
         let className = "";
-        if(field.wrap != true){
-            if(field.wrap != false && field.is_wide){
-                className += " break-words ";
-            }else {
+        if(/Safari/.test(navigator.userAgent)){
+            className += " whitespace-nowrap ";
+        }else {
+            if(field.wrap != true){
                 className += " whitespace-nowrap ";
+            }else {
+                className += " break-words ";
             }
-        }else {
-            className += " break-words ";
         }
         let columnItem;
         if((field.is_name || field.name === options.labelFieldName) && options.objectName === 'cms_files'){
@@ -10628,17 +10635,13 @@ function getReferenceToSync(field) {
 
 function getLookupSapceUserTreeSchema(isMobile){
     let apiAdaptor = `
-        // console.log("===getLookupSapceUserTreeSchema===", JSON.stringify(payload));
         const records = payload.data.options;
-        let isTreeOptionsComputed = false;
-        if(records.length === 1 && records[0].children){
-            isTreeOptionsComputed = true;
-        }
-        if(isTreeOptionsComputed){
-            return payload;
-        }
         const treeRecords = [];
-        const getChildren = (records, childrenIds) => {
+        const getChildren = (currentRecord, records, childrenIds) => {
+            if (currentRecord.children && typeof currentRecord.children[0] === "object") {
+                // 考虑api配置了cache缓存的话，不会请求接口但是会重新进这个接收适配器脚本且payload.data.options返回的会是上一次计算结果，这里直接返回计算过的children
+                return currentRecord.children;
+            }
             if (!childrenIds) {
                 return;
             }
@@ -10647,7 +10650,7 @@ function getLookupSapceUserTreeSchema(isMobile){
             });
             _.each(children, (item) => {
                 if (item.children) {
-                    item.children = getChildren(records, item.children)
+                    item.children = getChildren(item, records, item.children)
                 }else{
                     item.children = [];
                 }
@@ -10673,7 +10676,7 @@ function getLookupSapceUserTreeSchema(isMobile){
         
         _.each(records, (record) => {
             if (record.noParent == 1) {
-                treeRecords.push(Object.assign({}, record, { children: getChildren(records, record.children) }));
+                treeRecords.push(Object.assign({}, record, { children: getChildren(record, records, record.children) }));
             }
         });
         console.log(treeRecords)
@@ -12519,7 +12522,7 @@ async function convertSFieldToAmisField(field, readonly, ctx) {
         }else {
             convertData.className = 'm-0';
         }
-        if(readonly){
+        if(readonly && ctx.mode !== 'edit'){
             convertData.className = `${convertData.className} border-b`;
         }
         if(readonly){
@@ -12801,6 +12804,13 @@ const getSection = async (formFields, permissionFields, fieldSchemaArray, sectio
     }
   }
 
+  fieldSetBody.forEach((field)=>{
+    //判断label是否存在，不存在时将label的空占位元素隐藏
+    if(!field.label){
+      field.labelClassName = "none";
+    }
+  });
+
   // fieldSet 已支持显隐控制
   const sectionFieldsVisibleOn = _$1.map(_$1.compact(_$1.map(fieldSetBody, 'visibleOn')), (visibleOn) => {
     let visible = visibleOn;
@@ -12923,13 +12933,83 @@ async function getFormBody(permissionFields, formFields, ctx){
     return await getSections(permissionFields, formFields, ctx);
 }
 
+/*
+ * @Author: 殷亮辉 yinlianghui@hotoa.com
+ * @Date: 2024-01-18 15:12:41
+ * @LastEditors: 殷亮辉 yinlianghui@hotoa.com
+ * @LastEditTime: 2024-01-18 15:12:49
+ */
+/**
+ * 生成符合标准uuid格式的36位满足唯一性的随机串
+ * @returns uuid
+ */
+function uuidv4() {
+    return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, c =>
+        (c ^ window.crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16)
+    );
+}
+
 /*
  * @Author: 殷亮辉 yinlianghui@hotoa.com
  * @Date: 2023-11-15 09:50:22
  * @LastEditors: 殷亮辉 yinlianghui@hotoa.com
- * @LastEditTime: 2024-01-18 10:29:57
+ * @LastEditTime: 2024-01-22 15:59:32
  */
 
+function getTablePrimaryKey(props){
+    return props.primaryKey || "_id";
+}
+
+/**
+ * 子表组件字段值中每行数据的补上唯一标识字段值，其值为随机uuid
+ * @param {*} value 子表组件字段值，数组
+ * @param {*} primaryKey 主键字段名，一般为_id
+ * @returns 转换后的子表组件字段值
+ */
+function getTableValueWithPrimaryKeyValue(value, primaryKey){
+    if(!primaryKey){
+        return value;
+    }
+    return (value || []).map((itemValue)=>{
+        //这里不clone的话，会造成在pipeIn函数执行该函数后像pipeOut一样最终输出到表单项中，即库里把primaryKey字段值保存了
+        const newItemValue = clone(itemValue);
+        if(newItemValue[primaryKey]){
+            if(newItemValue.children){
+                newItemValue.children = getTableValueWithPrimaryKeyValue(newItemValue.children, primaryKey);
+            }
+            return newItemValue;
+        }
+        else {
+            newItemValue[primaryKey] = uuidv4();
+            if(newItemValue.children){
+                newItemValue.children = getTableValueWithPrimaryKeyValue(newItemValue.children, primaryKey);
+            }
+            return newItemValue;
+        }
+    });
+}
+
+/**
+ * 子表组件字段值中每行数据的移除唯一标识字段值，因为该字段值一般只作临时标记，不存库
+ * @param {*} value 子表组件字段值，数组
+ * @param {*} primaryKey 主键字段名，一般为_id
+ * @returns 转换后的子表组件字段值
+ */
+function getTableValueWithoutPrimaryKeyValue(value, primaryKey){
+    if(!primaryKey){
+        return value;
+    }
+    return (value || []).map((itemValue)=>{
+        //这里clone只是为了保险，不是必须的，每次修改子表数据是否都会生成新的primaryKey字段值是由pipeOut中识别autoGeneratePrimaryKeyValue决定的，跟这里没关系
+        const newItemValue = clone(itemValue);
+        if(newItemValue.children){
+            newItemValue.children = getTableValueWithoutPrimaryKeyValue(newItemValue.children, primaryKey);
+        }
+        delete newItemValue[primaryKey];
+        return newItemValue;
+    });
+}
+
 /**
  * 子表组件字段值中每行数据的键值key移除指定前缀
  * @param {*} value 子表组件字段值，数组
@@ -12941,7 +13021,9 @@ function getTableValueWithoutFieldPrefix(value, fieldPrefix){
     (value || []).forEach((itemValue)=>{
         var newItemValue = {};
         for(let n in itemValue){
-            newItemValue[n.replace(new RegExp(`^${fieldPrefix}`), "")] = itemValue[n];
+            if(itemValue.hasOwnProperty(n)){
+                newItemValue[n.replace(new RegExp(`^${fieldPrefix}`), "")] = itemValue[n];
+            }
         }
         convertedValue.push(newItemValue);
     });
@@ -12954,15 +13036,18 @@ function getTableValueWithoutFieldPrefix(value, fieldPrefix){
  * @param {*} fieldPrefix 字段前缀
  * @returns 转换后的子表组件字段值
  */
-function getTableValuePrependFieldPrefix(value, fieldPrefix){
+function getTableValuePrependFieldPrefix(value, fieldPrefix, primaryKey){
     let convertedValue = [];
     (value || []).forEach((itemValue)=>{
         var newItemValue = {};
         for(let n in itemValue){
-            if(typeof itemValue[n] !== undefined){
+            if(itemValue.hasOwnProperty(n) && typeof itemValue[n] !== undefined && n !== primaryKey){
                 newItemValue[`${fieldPrefix}${n}`] = itemValue[n];
             }
         }
+        if(primaryKey && itemValue[primaryKey]){
+            newItemValue[primaryKey] = itemValue[primaryKey];
+        }
         convertedValue.push(newItemValue);
     });
     return convertedValue;
@@ -12987,7 +13072,12 @@ function getTableFieldsWithoutFieldPrefix(fields, fieldPrefix){
  * @param {*} mode edit/new/readonly
  */
 function getFormFields(props, mode = "edit") {
-    return (props.fields || []).map(function (item) {
+    let fieldPrefix = props.fieldPrefix;
+    let fields = props.fields || [];
+    if (fieldPrefix) {
+        fields = getTableFieldsWithoutFieldPrefix(fields, fieldPrefix);
+    }
+    return (fields || []).map(function (item) {
         let formItem = {
             "type": "steedos-field",
             "name": item.name,
@@ -13059,7 +13149,12 @@ async function getInputTableColumns(props) {
     let inlineEditMode = props.inlineEditMode;
     let showAsInlineEditMode = inlineEditMode && props.editable;
     // 实测过，直接不生成对应的隐藏column并不会对input-table值造成丢失问题，隐藏的列字段值能正常维护
-    let fields = props.fields;
+
+    let fieldPrefix = props.fieldPrefix;
+    let fields = props.fields || [];
+    if (fieldPrefix) {
+        fields = getTableFieldsWithoutFieldPrefix(fields, fieldPrefix);
+    }
     if (columns && columns.length) {
         return columns.map(function (column) {
             let field, extendColumnProps = {};
@@ -13120,35 +13215,41 @@ function getFormPagination(props, mode) {
         let __formId = "${formId}";
         let fieldValue = event.data.__tableItems;//这里不可以_.cloneDeep，因为翻页form中用的是event.data.__tableItems，直接变更其值即可改变表单中的值
         let pageChangeDirection = context.props.pageChangeDirection;
+        let mode = "${mode}";
         // 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;
-        // 翻页到下一页之前需要先把当前页改动的内容保存到中间变量__tableItems中
-        let currentFormValues = scope.getComponentById(__formId).getValues();
-        var parent = event.data.parent;
-        var __parentIndex = event.data.__parentIndex;
-        if(parent){
-            fieldValue[__parentIndex].children[currentIndex] = currentFormValues;
-            // 重写父节点，并且改变其某个属性以让子节点修改的内容回显到界面上
-            fieldValue[__parentIndex] = Object.assign({}, fieldValue[__parentIndex], {
-                children: fieldValue[__parentIndex].children,
-                __fix_rerender_after_children_modified_tag: new Date().getTime()
+        if(mode !== "readonly"){
+            // 新建编辑时，翻页才需要把当前页表单保存，只读时直接翻页即可
+            // 翻页到下一页之前需要先把当前页改动的内容保存到中间变量__tableItems中
+            let currentFormValues = scope.getComponentById(__formId).getValues();
+            // 这里不clone的话，其值会带上__super属性
+            currentFormValues = _.clone(currentFormValues);
+            var parent = event.data.parent;
+            var __parentIndex = event.data.__parentIndex;
+            if(parent){
+                fieldValue[__parentIndex].children[currentIndex] = currentFormValues;
+                // 重写父节点，并且改变其某个属性以让子节点修改的内容回显到界面上
+                fieldValue[__parentIndex] = Object.assign({}, fieldValue[__parentIndex], {
+                    children: fieldValue[__parentIndex].children,
+                    __fix_rerender_after_children_modified_tag: new Date().getTime()
+                });
+            }
+            else{
+                fieldValue[currentIndex] = currentFormValues;
+            }
+            // 翻页到下一页前需要同时把改动的内容保存到最终正式的表单字段中，所以额外给正式表单字段执行一次setValue
+            doAction({
+                "componentId": "${props.id}",
+                "actionType": "setValue",
+                "args": {
+                    "value": fieldValue
+                }
             });
         }
-        else{
-            fieldValue[currentIndex] = currentFormValues;
-        }
-        // 翻页到下一页前需要同时把改动的内容保存到最终正式的表单字段中，所以额外给正式表单字段执行一次setValue
-        doAction({
-            "componentId": "${props.id}",
-            "actionType": "setValue",
-            "args": {
-                "value": fieldValue
-            }
-        });
 
         // 以下是翻页逻辑，翻到下一页并把下一页内容显示到表单上
         let targetPage;
@@ -13208,7 +13309,7 @@ function getFormPagination(props, mode) {
             {
                 "type": "tpl",
                 // 这里用__super.parent，加__super是为了防止当前记录有字段名为parent的重名变量
-                "tpl": "${__page}/${__super.parent ? __tableItems[__parentIndex]['children'].length : __tableItems.length}"
+                "tpl": "${__page}/${__super.parent ? COMPACT(__tableItems[__parentIndex]['children']).length : COMPACT(__tableItems).length}"
             },
             {
                 "type": "button",
@@ -13218,7 +13319,7 @@ function getFormPagination(props, mode) {
                 "pageChangeDirection": "next",
                 // "disabledOn": showPagination ? "${__page >= __tableItems.length}" : "true",
                 // 这里用__super.parent，加__super是为了防止当前记录有字段名为parent的重名变量
-                "disabledOn": showPagination ? "${__page >= (__super.parent ? __tableItems[__parentIndex]['children'].length : __tableItems.length)}" : "true",
+                "disabledOn": showPagination ? "${__page >= (__super.parent ? COMPACT(__tableItems[__parentIndex]['children']).length : COMPACT(__tableItems).length)}" : "true",
                 "size": "sm",
                 "id": buttonNextId,
                 "onEvent": {
@@ -13247,6 +13348,7 @@ function getFormPaginationWrapper(props, form, mode) {
     // console.log("==getFormPaginationWrapper===", props, mode);
     let serviceId = getComponentId("form_pagination", props.id);
     let tableServiceId = getComponentId("table_service", props.id);
+    let primaryKey = getTablePrimaryKey(props);
     let innerForm = Object.assign({}, form, {
         "data": {
             // 这里加__super前缀是因为__parentForm变量（即主表单）中可能会正好有名为index的字段
@@ -13274,7 +13376,6 @@ function getFormPaginationWrapper(props, form, mode) {
         }
     ];
     let onServiceInitedScript = `
-
         // 以下脚本解决了有时弹出编辑表单时，表单中的值比最后一次编辑保存的值会延迟一拍。
         // 比如：inlineEditMode模式时，用户在表格单元格中直接修改数据，然后弹出的表单form中并没有包含单元格中修改的内容
         // 另外有的地方在非inlineEditMode模式时也会有这种延迟一拍问题，比如对象字段中下拉框类型字段的”选择项“属性
@@ -13288,13 +13389,13 @@ function getFormPaginationWrapper(props, form, mode) {
         // 这里不可以用event.data["${props.name}"]因为amis input talbe有一层单独的作用域，其值会延迟一拍
         // 这里如果不.clone的话，在弹出窗口中显示的子表组件，添加行后点窗口的取消按钮关闭窗口后无法把之前的操作还原，即把之前添加的行自动移除
         let lastestFieldValue = _.clone(wrapperServiceData["${props.name}"] || []);
-        let fieldPrefix = "${props.fieldPrefix}";
+        let fieldPrefix = "${props.fieldPrefix || ''}";
         if(fieldPrefix){
             let getTableValueWithoutFieldPrefix = new Function('v', 'f', "return (" + ${getTableValueWithoutFieldPrefix.toString()} + ")(v, f)");
             lastestFieldValue = getTableValueWithoutFieldPrefix(lastestFieldValue, fieldPrefix);
         }
         //不可以直接像event.data.__tableItems = lastestFieldValue; 这样整个赋值，否则作用域会断
-        let mode = "${mode}";
+        let mode = "${mode || ''}";
         if(mode === "new"){
             // 点击子表组件底部新增按钮时新增一条空白行并自动翻页到新增行
             // 注意点击弹出的子表行详细表单中的新增按钮不会进此service init事件函数中
@@ -13320,10 +13421,20 @@ function getFormPaginationWrapper(props, form, mode) {
         var fieldValue = event.data.__tableItems;
         if(parent){
             // 如果是子行，即在节点嵌套情况下，当前节点如果是children属性下的子节点时，则算出其所属父行的索引值
-            var primaryKey = "${props.primaryKey}";
+            var primaryKey = "${primaryKey}";
             event.data.__parentIndex = _.findIndex(fieldValue, function(item){
                 return item[primaryKey] == parent[primaryKey];
             });
+            if(event.data.__parentIndex < 0){
+                let tableId = "${props.id}";
+                let table = scope.getComponentById(tableId)
+                // autoGeneratePrimaryKeyValue不为true的情况下，即子表组件input-table的pipeOut函数中会移除表单了子表字段的primaryKey字段值，
+                // 此时行primaryKey字段值为空，但是pipeIn函数中已经为input-table自动生成过primaryKey字段值了，只是没有输出到表单字段值中而已
+                // 所以上面从表单字段值中没找到__parentIndex，是因为此时行primaryKey字段值只经过pipeIn保存到table组件内而没有保存到tableService
+                event.data.__parentIndex = _.findIndex(table.props.value, function(item){
+                    return item[primaryKey] == parent[primaryKey];
+                });
+            }
         }
     `;
     let schema = {
@@ -13372,6 +13483,7 @@ function getFormPaginationWrapper(props, form, mode) {
 async function getForm(props, mode = "edit", formId) {
     let formFields = getFormFields(props, mode);
     let body = await getFormBody(null, formFields);
+    let primaryKey = getTablePrimaryKey(props);
     if (!formId) {
         formId = getComponentId("form", props.id);
     }
@@ -13390,6 +13502,18 @@ async function getForm(props, mode = "edit", formId) {
         // 新增行弹出编辑行表单，在弹出之前已经不用先增加一行，因为在翻页service初始化的时候会判断mode为new时自动新增一行
         let onEditItemSubmitScript = `
             // let fieldValue = _.cloneDeep(event.data["${props.name}"]);
+            let removeEmptyItems = function(items){
+                let i = _.findIndex(items, function(item){
+                    return item === undefined
+                });
+                if(i > -1){
+                    items.splice(i, 1);
+                    removeEmptyItems(items);
+                }
+            }
+            // 因为删除时只是把input-table组件中的行数据删除了，并没有把父层service中的行删除，所以__tableItems会有值为undefined的数据，需要移除掉
+            // 不用event.data.__tableItems = _.compact(event.data.__tableItems)是因为会把__tableItems变量保存到表单中
+            removeEmptyItems(event.data.__tableItems);
             let fieldValue = event.data.__tableItems;//这里不可以_.cloneDeep，因为翻页form中用的是event.data.__tableItems，直接变更其值即可改变表单中的值
             //这里加__super.__super前缀是因为__parentForm变量（即主表单）中可能会正好有名为index的字段
             // 比如“对象字段”对象options字段是一个子表字段，但是主表（即“对象字段”对象）中正好有一个名为index的字段
@@ -13398,6 +13522,8 @@ async function getForm(props, mode = "edit", formId) {
             var currentFormValues = JSON.parse(JSON.stringify(event.data));
             var parent = event.data.__super.__super.parent;
             var __parentIndex = event.data.__super.__super.__parentIndex;
+            let uuidv4 = new Function("return (" + ${uuidv4.toString()} + ")()");
+            var primaryKey = "${primaryKey}";
             if(parent){
                 fieldValue[__parentIndex].children[currentIndex] = currentFormValues;
                 // 重写父节点，并且改变其某个属性以让子节点修改的内容回显到界面上
@@ -13407,6 +13533,8 @@ async function getForm(props, mode = "edit", formId) {
                 });
             }
             else{
+                // 这里currentFormValues中如果没有primaryKey字段值不用处理，因为组件的pipeIn/pipeOut中会为每行自动生成
+                // 也不用担心复制行时_id会重复，因为点击复制按钮时已经处理过了
                 fieldValue[currentIndex] = currentFormValues;
             }
             doAction({
@@ -13504,6 +13632,7 @@ async function getForm(props, mode = "edit", formId) {
  */
 async function getButtonActions(props, mode) {
     let actions = [];
+    let primaryKey = getTablePrimaryKey(props);
     let formId = getComponentId("form", props.id);
     let dialogId = getComponentId("dialog", props.id);
     let buttonNextId = getComponentId("button_next", props.id);
@@ -13546,13 +13675,35 @@ async function getButtonActions(props, mode) {
         // };
         let onSaveAndNewItemScript = `
             let scope = event.context.scoped;
+            let removeEmptyItems = function(items){
+                let i = _.findIndex(items, function(item){
+                    return item === undefined
+                });
+                if(i > -1){
+                    items.splice(i, 1);
+                    removeEmptyItems(items);
+                }
+            }
+            // 因为删除时只是把input-table组件中的行数据删除了，并没有把父层service中的行删除，所以__tableItems会有值为undefined的数据，需要移除掉
+            // 不用event.data.__tableItems = _.compact(event.data.__tableItems)是因为会把__tableItems变量保存到表单中
+            removeEmptyItems(event.data.__tableItems);
             let fieldValue = event.data.__tableItems;//这里不可以_.cloneDeep，因为翻页form中用的是event.data.__tableItems，直接变更其值即可改变表单中的值
             // 新建一条空白行并保存到子表组件
             var parent = event.data.__super.parent;
-            var primaryKey = "${props.primaryKey}";
+            var primaryKey = "${primaryKey}";
             var __parentIndex = parent && _.findIndex(fieldValue, function(item){
                 return item[primaryKey] == parent[primaryKey];
             });
+            if(parent && __parentIndex < 0){
+                let tableId = "${props.id}";
+                let table = scope.getComponentById(tableId)
+                // autoGeneratePrimaryKeyValue不为true的情况下，即子表组件input-table的pipeOut函数中会移除表单了子表字段的primaryKey字段值，
+                // 此时行primaryKey字段值为空，但是pipeIn函数中已经为input-table自动生成过primaryKey字段值了，只是没有输出到表单字段值中而已
+                // 所以上面从表单字段值中没找到__parentIndex，是因为此时行primaryKey字段值只经过pipeIn保存到table组件内而没有保存到tableService
+                __parentIndex = _.findIndex(table.props.value, function(item){
+                    return item[primaryKey] == parent[primaryKey];
+                });
+            }
             if(parent){
                 fieldValue[__parentIndex].children.push({});
                 // 这里实测不需要fieldValue[__parentIndex] = ... 来重写整个父行让子表回显，所以没加相关代码
@@ -13586,14 +13737,42 @@ async function getButtonActions(props, mode) {
             let __formId = "${formId}";
             // let newItem = JSON.parse(JSON.stringify(event.data));
             let newItem = scope.getComponentById(__formId).getValues();//这里不可以用event.data，因为其拿到的是弹出表单时的初始值，不是用户实时填写的数据
+            newItem = _.clone(newItem);
+            let removeEmptyItems = function(items){
+                let i = _.findIndex(items, function(item){
+                    return item === undefined
+                });
+                if(i > -1){
+                    items.splice(i, 1);
+                    removeEmptyItems(items);
+                }
+            }
+            // 因为删除时只是把input-table组件中的行数据删除了，并没有把父层service中的行删除，所以__tableItems会有值为undefined的数据，需要移除掉
+            // 不用event.data.__tableItems = _.compact(event.data.__tableItems)是因为会把__tableItems变量保存到表单中
+            removeEmptyItems(event.data.__tableItems);
             let fieldValue = event.data.__tableItems;//这里不可以_.cloneDeep，因为翻页form中用的是event.data.__tableItems，直接变更其值即可改变表单中的值
             // 复制当前页数据到新建行并保存到子表组件
             // fieldValue.push(newItem);
             var parent = event.data.__super.parent;
-            var primaryKey = "${props.primaryKey}";
+            var primaryKey = "${primaryKey}";
             var __parentIndex = parent && _.findIndex(fieldValue, function(item){
                 return item[primaryKey] == parent[primaryKey];
             });
+            if(parent && __parentIndex < 0){
+                let tableId = "${props.id}";
+                let table = scope.getComponentById(tableId)
+                // autoGeneratePrimaryKeyValue不为true的情况下，即子表组件input-table的pipeOut函数中会移除表单了子表字段的primaryKey字段值，
+                // 此时行primaryKey字段值为空，但是pipeIn函数中已经为input-table自动生成过primaryKey字段值了，只是没有输出到表单字段值中而已
+                // 所以上面从表单字段值中没找到__parentIndex，是因为此时行primaryKey字段值只经过pipeIn保存到table组件内而没有保存到tableService
+                __parentIndex = _.findIndex(table.props.value, function(item){
+                    return item[primaryKey] == parent[primaryKey];
+                });
+            }
+            if(newItem[primaryKey]){
+                // 如果newItem已经有主键字段值，则重新生成新的主键值，否则会重复。
+                let uuidv4 = new Function("return (" + ${uuidv4.toString()} + ")()");
+                newItem[primaryKey] = uuidv4();
+            }
             if(parent){
                 fieldValue[__parentIndex].children.push(newItem);
                 // 这里实测不需要fieldValue[__parentIndex] = ... 来重写整个父行让子表回显，所以没加相关代码
@@ -13801,7 +13980,10 @@ async function getButtonActions(props, mode) {
                         // 为了解决"弹出的dialog窗口中子表组件会影响页面布局界面中父作用域字段值"，比如设计字段布局微页面中的设置分组功能，弹出的就是子表dialog
                         // 所以这里使用json|toJson转一次，断掉event.data.__tableItems与上层任用域中props.name的联系
                         // "__tableItems": `\${${props.name}|json|toJson}`
-                        "__tableItems": `\${((__super.parent ? __super.__super.${props.name} : __super.${props.name}) || [])|json|toJson}`
+                        // "__tableItems": `\${((__super.parent ? __super.__super.${props.name} : __super.${props.name}) || [])|json|toJson}`
+                        // 在节点嵌套情况下，当前节点正好是带children属性的节点的话，这里弹出的dialog映射到的会是children数组，这是amis目前的规则，
+                        // 所以这里加判断有children时，用__super.__super让映射到正确的作用域层，如果不加，则__tableItems取到的会是children数组，而不是整个子表组件的值
+                        "__tableItems": `\${((children ? __super.__super.${props.name} : __super.${props.name}) || [])|json|toJson}`
                     },
                 }
             }
@@ -13817,13 +13999,24 @@ async function getButtonActions(props, mode) {
             let wrapperServiceData = wrapperService.getData();
             // 这里不可以用event.data["${props.name}"]因为amis input talbe有一层单独的作用域，其值会延迟一拍
             // 这里_.clone是因为字段设计布局设置分组这种弹出窗口中的子表组件，直接删除后，点取消无法还原
+            // 也因为这里clone没有直接删除，所以弹出编辑表单提交事件中event.data.__tableItems中取到的值会有被删除的行数据为undefined
             let lastestFieldValue = _.clone(wrapperServiceData["${props.name}"]);
             var currentIndex = event.data.index;
             var parent = event.data.__super.parent;
-            var primaryKey = "${props.primaryKey}";
+            var primaryKey = "${primaryKey}";
             var __parentIndex = parent && _.findIndex(lastestFieldValue, function(item){
                 return item[primaryKey] == parent[primaryKey];
             });
+            if(parent && __parentIndex < 0){
+                let tableId = "${props.id}";
+                let table = scope.getComponentById(tableId)
+                // autoGeneratePrimaryKeyValue不为true的情况下，即子表组件input-table的pipeOut函数中会移除表单了子表字段的primaryKey字段值，
+                // 此时行primaryKey字段值为空，但是pipeIn函数中已经为input-table自动生成过primaryKey字段值了，只是没有输出到表单字段值中而已
+                // 所以上面从表单字段值中没找到__parentIndex，是因为此时行primaryKey字段值只经过pipeIn保存到table组件内而没有保存到tableService
+                __parentIndex = _.findIndex(table.props.value, function(item){
+                    return item[primaryKey] == parent[primaryKey];
+                });
+            }
             if(parent){
                 lastestFieldValue[__parentIndex].children.splice(currentIndex, 1);
                 // 重写父节点，并且改变其某个属性以让子节点修改的内容回显到界面上
@@ -13835,6 +14028,11 @@ async function getButtonActions(props, mode) {
             else{
                 lastestFieldValue.splice(currentIndex, 1);
             }
+            let fieldPrefix = "${props.fieldPrefix || ''}";
+            if(fieldPrefix){
+                let getTableValueWithoutFieldPrefix = new Function('v', 'f', "return (" + ${getTableValueWithoutFieldPrefix.toString()} + ")(v, f)");
+                lastestFieldValue = getTableValueWithoutFieldPrefix(lastestFieldValue, fieldPrefix);
+            }
             doAction({
                 "componentId": "${props.id}",
                 "actionType": "setValue",
@@ -13920,16 +14118,15 @@ const getAmisInputTableSchema = async (props) => {
     if (!props.id) {
         props.id = "steedos_input_table_" + props.name + "_" + Math.random().toString(36).substr(2, 9);
     }
-    if (!props.primaryKey) {
-        props.primaryKey = "_id";
-    }
+    let primaryKey = getTablePrimaryKey(props);
     let showOperation = props.showOperation;
     if(showOperation !== false){
         showOperation = true;
     }
-    // props.fieldPrefix = "project_milestone_";
-    if (props.fieldPrefix) {
-        props.fields = getTableFieldsWithoutFieldPrefix(props.fields, props.fieldPrefix);
+    let fieldPrefix = props.fieldPrefix;
+    let fields = props.fields || [];
+    if (fieldPrefix) {
+        fields = getTableFieldsWithoutFieldPrefix(fields, fieldPrefix);
     }
     let serviceId = getComponentId("table_service", props.id);
     let buttonsForColumnOperations = [];
@@ -13942,7 +14139,7 @@ const getAmisInputTableSchema = async (props) => {
                 // 始终显示弹出子表表单按钮，如果需要判断只在有列被隐藏时才需要显示弹出表单按钮放开下面的if逻辑就好
                 showEditButton = true;
                 // // inline edit模式下只在有列被隐藏时才需要显示编辑按钮
-                // if (props.columns && props.columns.length > 0 && props.columns.length < props.fields.length) {
+                // if (props.columns && props.columns.length > 0 && props.columns.length < fields.length) {
                 //     showEditButton = true;
                 // }
                 // else {
@@ -13957,7 +14154,7 @@ const getAmisInputTableSchema = async (props) => {
         }
         else {
             // 只读时显示查看按钮
-            // 如果想只在有列被隐藏时才需要显示查看按钮可以加上判断：if (props.columns && props.columns.length > 0 && props.columns.length < props.fields.length)
+            // 如果想只在有列被隐藏时才需要显示查看按钮可以加上判断：if (props.columns && props.columns.length > 0 && props.columns.length < fields.length)
             let buttonViewSchema = await getButtonView(props);
             buttonsForColumnOperations.push(buttonViewSchema);
         }
@@ -13966,10 +14163,10 @@ const getAmisInputTableSchema = async (props) => {
             buttonsForColumnOperations.push(buttonDeleteSchema);
         }
     }
-    let amis = props["input-table"] || props.amis;//额外支持"input-table"代替amis属性，是因为在字段yml文件中用amis作为key不好理解
+    let amis = props["input-table"] || props.amis || {};//额外支持"input-table"代替amis属性，是因为在字段yml文件中用amis作为key不好理解
     let inputTableSchema = {
         "type": "input-table",
-        "label": props.label,
+        "mode": "normal",
         "name": props.name,
         //不可以addable/editable/removable设置为true，因为会在原生的操作列显示操作按钮图标，此开关实测只控制这个按钮显示不会影响功能
         // "addable": props.addable,
@@ -13985,13 +14182,42 @@ const getAmisInputTableSchema = async (props) => {
         "showTableAddBtn": false,
         "showFooterAddBtn": false,
         "className": props.tableClassName,
+        "pipeIn": (value, data) => {
+            if(fieldPrefix){
+                value = getTableValueWithoutFieldPrefix(value, fieldPrefix);
+            }
+            if(primaryKey){
+                // 这里临时给每行数据补上primaryKey字段值，如果库里不需要保存这里补上的字段值，pipeOut中会识别autoGeneratePrimaryKeyValue属性选择最终移除这里补上的字段值
+                // 这里始终自动生成primaryKey字段值，而不是只在pipeOut输出整个子表字段值时才生成，是因为要支持当数据库里保存的子表字段行数据没有primaryKey字段值时的行嵌套模式（即节点的children属性）功能
+                // 这里要注意，流程详细设置界面的字段设置功能中的子表组件中，数据库里保存的子表字段行数据是有primaryKey字段值的，它不依赖这里自动生成行primaryKey值功能
+                value = getTableValueWithPrimaryKeyValue(value, primaryKey);
+            }
+            if(amis.pipeIn){
+                if(typeof amis.pipeIn === 'function'){
+                    return amis.pipeIn(value, data);
+                }
+            }
+            return value;
+        },
         "pipeOut": (value, data) => {
             value = (value || []).map(function(item){
                 delete item.__fix_rerender_after_children_modified_tag;
                 return item;
             });
-            if(props.fieldPrefix){
-                value = getTableValuePrependFieldPrefix(value, props.fieldPrefix);
+            if(fieldPrefix){
+                value = getTableValuePrependFieldPrefix(value, fieldPrefix, primaryKey);
+            }
+            if(props.autoGeneratePrimaryKeyValue === true){
+                // 如果需要把自动生成的primaryKey值输出保存的库中，则补全所有行中的primaryKey值
+                // 这里如果不全部补全的话，初始从库里返回的字段值中拿到的行没primaryKey值的话就不会自动补上
+                value = getTableValueWithPrimaryKeyValue(value, primaryKey);
+            }
+            else {
+                // 默认情况下，也就是没有配置autoGeneratePrimaryKey时，最终输出的字段值要移除行中的primaryKey值
+                // 需要注意如果没有配置autoGeneratePrimaryKey时，因为每次弹出行编辑窗口保存后都会先后进入pipeOut和pipeIn，
+                // 这里删除掉了primaryKey值，所以primaryKey值每次弹出编辑窗口保存后都会给每行重新生成新的primaryKey值
+                // 只有autoGeneratePrimaryKey配置为true时，每行的primaryKey字段值才会始终保持不变
+                value = getTableValueWithoutPrimaryKeyValue(value, primaryKey);
             }
             if(amis.pipeOut){
                 if(typeof amis.pipeOut === 'function'){
@@ -14001,20 +14227,6 @@ const getAmisInputTableSchema = async (props) => {
             return value;
         }
     };
-    if(amis.pipeIn){
-        inputTableSchema.pipeIn = amis.pipeIn;
-    }
-    if(props.fieldPrefix){
-        inputTableSchema.pipeIn = (value, data) => {
-            value = getTableValueWithoutFieldPrefix(value, props.fieldPrefix);
-            if(amis.pipeIn){
-                if(typeof amis.pipeIn === 'function'){
-                    return amis.pipeIn(value, data);
-                }
-            }
-            return value;
-        };
-    }
     if (buttonsForColumnOperations.length) {
         inputTableSchema.columns.push({
             "name": "__op__",
@@ -14033,7 +14245,7 @@ const getAmisInputTableSchema = async (props) => {
         delete amis.pipeOut;//该属性在上面合并过了
         Object.assign(inputTableSchema, amis);
     }
-    const isAnyFieldHasDependOn = (props.fields || []).find(function (item) {
+    const isAnyFieldHasDependOn = (fields || []).find(function (item) {
         return item.depend_on;
     });
     if (isAnyFieldHasDependOn) {
@@ -14068,7 +14280,16 @@ const getAmisInputTableSchema = async (props) => {
     }
     let schema = {
         "type": "service",
-        "body": schemaBody,
+        "body": [
+            {
+                "type": "control",
+                "body": schemaBody,
+                "label": props.label,
+                "labelClassName": props.label ? props.labelClassName : "none",
+                "labelRemark": props.labelRemark,
+                "labelAlign": props.labelAlign
+            }
+        ],
         "className": props.className,
         "id": serviceId
     };