cd-work-flow-web/src/views/activiti/form/demoForm2.vue

<template>
  <div class="form-main">
    <a-card :body-style="{padding: '24px 32px'}" :bordered="false">
      <!-- <a-form @submit="handleSubmit" :form="form">
        <a-form-item
          label="标题"
          :labelCol="{lg: {span: 7}, sm: {span: 7}}"
          :wrapperCol="{lg: {span: 10}, sm: {span: 17} }">
          <a-input :disabled="disabled"
                   v-decorator="[
            'name',
            {rules: [{ required: true, message: '请输入标题' }]}
          ]"
                   name="name"
                   placeholder="给目标起个名字" />
        </a-form-item>
        <a-form-item v-if="!disabled"
                     :wrapperCol="{ span: 24 }"
                     style="text-align: center"
        >
          <a-button htmlType="submit" type="primary" :disabled="disabled||btndisabled" @click="handleSubmit">保存</a-button>
          <a-button style="margin-left: 8px" :disabled="disabled" @click="close">取消</a-button>
        </a-form-item>
      </a-form>-->
      <k-form-build
        :value="jsonData"
        @change="handleChange"
        :dynamicData="dynamicData"
        ref="KFB"
        @submit="handleSubmit"
      />
      <div style="text-align:center">
        <a-button
          htmlType="submit"
          type="primary"
          :disabled="disabled||btndisabled"
          @click="handleSubmit"
        >保存</a-button>
        <todoManageOperation
          v-if="processData.operationType&&processData.operationType=='1'"
          :processData="processData"
          :todoManageOperationObject="todoManageOperationObject"
          :disabled="disabled"
          :btndisabled="btndisabled"
          @refreshToDo="refreshToDo"
          @handleSubmit2="handleSubmit2"
        ></todoManageOperation>
        <a-button style="margin-left: 8px;" :disabled="disabled||disabled2" @click="close">取消</a-button>
      </div>
    </a-card>
  </div>
</template>

<script>
import pick from 'lodash.pick'
import todoManageOperation from '../operation/todoManageOperation'
import { postAction, postFormDataAction } from '@/api/manage'
export default {
  name: 'demoForm',
  props: {
    /*全局禁用，可表示查看*/
    disabled: {
      type: Boolean,
      default: false,
      required: false
    },
    /*流程数据*/
    processData: {
      type: Object,
      default: () => {
        return {}
      },
      required: false
    },
    /*是否新增*/
    isNew: { type: Boolean, default: false, required: false }
  },
  components: {
    todoManageOperation
  },
  data() {
    return {
      isSJ: false,
      todoManageOperationObject: {
        isSave: false,
        formData: {},
        jsonData: {}
      },
      disabled2: false, //用来取决于表单时不同流程节点填写不同表单信息使用
      jsonData: {},
      url: {
        getForm: '/actBusiness/getForm',
        addApply: '/actBusiness/add',
        editForm: '/actBusiness/editForm',
        leaveType: '/sys/dict/getDictItems'
      },
      description: '流程表单demo，按例开发表单。需在 activitiMixin.js 中加入写好的表单',
      // form
      form: this.$form.createForm(this),
      /*表单回显数据*/
      data: {},
      btndisabled: false,
      ceshi_file: null,
      dynamicData: {
        jsonData: {},
        typeData: [], //请假类型下拉数据
        reimbursementTypeList: [], //报销类型下拉数据
        invoiceTypeList: [], //发票类型下拉数据
        add: this.add
      },
      itemModelNameList: [] //子表字段名
    }
  },
  watch: {
    // 'dynamicData.jsonData'(){
    //   console.log("发生改变了")
    // },
    dynamicData: {
      handler(newName, oldName) {
        console.log('obj.a changed')
        console.log(newName)
        console.log(oldName)
      },
      immediate: true,
      deep: true
    }
  },
  created() {
    window.deleteRow = this.deleteRow
    console.log('流程数据', this.processData)
    //加载一些下拉选择数据等
    // this.getDataList()
    let businessTable = ''
    //如果没有值则在另一个属性上有值
    if (!this.processData.businessTable) {
      this.processData.businessTable = this.processData.tableName
    }
    this.getAction('/tbTableInfo/query', {
      businessTable: this.processData.businessTable,
      taskNodeId: this.processData.key,
      tableId: this.processData.tableId
    }).then(res => {
      // this.$refs.KFB.setData({aaa:null,bbb:null,name:"123"})
      // this.$refs.KFB.getData().then(res => {
      //   console.log('aaa',res)
      // })

      var jsonString = JSON.stringify(res.result.jsonContent)
      // var jsonString='123d"dynamicKey":"666"'
      var index = 1

      var dynamicKeyValueList = []
      for (var index = 1; index !== -1; ) {
        //动态字符位置
        index = jsonString.indexOf('"dynamicKey"', index)
        if (index !== -1) {
          //从指定字符的周后一个字符后开始找(")
          var ihStart = jsonString.indexOf('"', index + 12)
          //再从 (") 后面位置还是找下一个 (")
          var ihEnd = jsonString.indexOf('"', ihStart + 1)
          //获取引号之间的字符
          var dynamicKeyValue = jsonString.substring(ihStart + 1, ihEnd)
          //如果动态表示不为空则获取
          if (dynamicKeyValue != '') {
            dynamicKeyValueList.push(dynamicKeyValue)
          }
          index = ihEnd + 1
        }
      }
      //循环动态数据源表示获取数据
      // if(dynamicKeyValueList.length>0){
      //   dynamicKeyValueList.forEach(async element => {
      //      await this.getDataListByName(element);
      //   });
      // }
      console.log(dynamicKeyValueList)
      if (dynamicKeyValueList.length > 0) {
        //获取数据字典数据源
        postAction('/sys/dict/getDictItems/getDictList', dynamicKeyValueList).then(dictData => {
          if (dictData.success) {
            this.dynamicData = dictData.result.dicList
            //获取用户下拉数据
            this.getAction('/sys/user/list2', { pageSize: 20000 }).then(userData => {
              if (res.success) {
                userData.result.records.forEach(user => {
                  user.label = user.realname
                  user.value = user.username
                })
                //存到动态数据源中
                this.dynamicData.userList = userData.result.records
                this.dynamicData.add = this.add //新增按钮
                //获取json
                this.jsonData = res.result.jsonContent
                //如果是手机端子表初始化子表model
                this.listUpdateModel()
                if (!this.isNew) {
                  this.init()
                }
              } else {
                this.$message.error(userData.message)
              }
            })
          } else {
            this.$message.error(dictData.message)
          }
        })
      } else {
        //获取json
        this.jsonData = res.result.jsonContent
        //如果是手机端子表初始化子表model
        this.listUpdateModel()
        // window.jsonData=this.jsonData;
        if (!this.isNew) {
          this.init()
        }
      }

      //后台检测到流程节点有关联表单且前台处于我的待办界面打开表单详情
      if (res.result.isSave && this.processData.isSuspended != undefined) {
        this.disabled = false
        this.btndisabled = false
      }
    })
  },
  methods: {
    //根据字典名字获取数据源
    getDataListByName(name) {
      this.getAction(this.url.leaveType + '/' + name).then(res => {
        if (res.success) {
          this.dynamicData[name] = res.result
          console.log(111)
        } else {
          this.$message.error(res.message)
        }
      })
    },
    //获取获取下拉数据等
    getDataList() {
      //获取请假类型下拉数据
      this.getAction(this.url.leaveType + '/leave_type').then(res => {
        if (res.success) {
          this.dynamicData.typeData = res.result
        } else {
          this.$message.error(res.message)
        }
      })
      //获取报销类型下拉数据
      this.getAction(this.url.leaveType + '/reimbursement_type').then(res => {
        if (res.success) {
          this.dynamicData.reimbursementTypeList = res.result
        } else {
          this.$message.error(res.message)
        }
      })
      //获取发票类型下拉数据
      this.getAction(this.url.leaveType + '/invoice_type').then(res => {
        if (res.success) {
          this.dynamicData.invoiceTypeList = res.result
        } else {
          this.$message.error(res.message)
        }
      })
    },
    /*回显数据*/
    init() {
      this.btndisabled = true
      var r = this.processData

      this.getAction(this.url.getForm, {
        tableId: r.tableId,
        tableName: r.tableName
      }).then(res => {
        if (res.success) {
          let formData = res.result
          formData.tableName = r.tableName
          this.data = formData
          //如果表单是手机端的子表则
          if (this.isSJ) {
            var formModelList = _.keys(this.data)
              .join(',')
              .split(',')
            var itemList = []
            formModelList.forEach(element => {
              if (element.indexOf('child&') != -1) {
                itemList = JSON.parse(JSON.stringify(this.data[element]))
                delete this.data[element]
              }
            })
            //子表字段名
            //子表数据model和值组装
            itemList.forEach((item, index) => {
              this.itemModelNameList.forEach(itemModelName => {
                this.data[itemModelName + '@' + (index + 1)] = item[itemModelName]
              })
            })
          }
          //赋值
          this.$refs.KFB.setData(this.data)
          this.btndisabled = false
        } else {
          this.$message.error(res.message)
        }
      })
    },
    //表单字段数值发生改变事件
    handleChange(value, key) {
      // 数据变化时触发
      //如果开始时间发生变化
      if (key == 'start_time') {
        //判断结束时间是否存在
        if (this.$refs.KFB.form.getFieldValue('end_time')) {
          //获取时间差
          let duration = startEndFun(value, this.$refs.KFB.form.getFieldValue('end_time'))
          if (duration) {
            // 使用k-form-design组件的form属性修改表单数据
            this.$refs.KFB.setData({
              duration: duration
            })
          }
        }
      }
      //如果结束时间发生变化
      if (key == 'end_time') {
        //判断结束时间是否存在
        if (this.$refs.KFB.form.getFieldValue('start_time')) {
          //获取时间差
          let duration = startEndFun(this.$refs.KFB.form.getFieldValue('start_time'), value)
          if (duration) {
            // 使用k-form-design组件的form属性修改表单数据
            this.$refs.KFB.setData({
              duration: duration
            })
          }
        }
      }
    },
    // handler
    handleSubmit(e) {
      // return new Promise((resolve)=>{
      //通过函数获取数据
      this.$refs.KFB.getData()
        .then(res => {
          //处理手机端子表数据
          if (this.isSJ) {
            this.itemData(res)
          }
          //清除为空的表单数据
          _.keys(res).forEach(r => {
            if (!res[r]) {
              delete res[r]
            }
          })
          // 获取数据成功
          let formData = JSON.parse(JSON.stringify(res))
          console.log(formData)
          formData.id = this.data.id
          formData.procDefId = this.processData.id
          formData.procDeTitle = this.processData.name

          if (!formData.tableName) formData.tableName = this.processData.businessTable
          formData.filedNames = _.keys(res).join(',')
          formData.filedNames = getFiledNames(formData) //获取主表字段，排除子表标识
          var url = this.url.addApply
          if (!this.isNew) {
            url = this.url.editForm
          }
          //是否存在子表
          let ischild = false
          //循环表单字段属性判断是否属性中包含数组对象
          let i = 0 //子表数量
          _.keys(res)
            .join(',')
            .split(',')
            .forEach(element => {
              if (formData[element] instanceof Array) {
                //判断是否符合子表命名规则
                if (element.indexOf('&') != -1) {
                  let tableChildNameList = element.split('&')
                  //判断是否能拆分两个字符，子表标识和子表数据库名称
                  if (tableChildNameList.length == 2) {
                    i++
                    let childName = tableChildNameList[1] //子表数据库名称
                    if (!formData.table_name_children) {
                      //第一次拼接
                      formData.table_name_children = childName //表名
                    } else {
                      //后面的表明拼接用“,”隔开
                      formData.table_name_children = formData.table_name_children + ',' + childName //表名
                    }
                    //定义属性名和值
                    formData['childFiledNames' + i] = _.keys(formData[element][0]).join(',') //子表字段名
                    formData['childList' + i] = JSON.stringify(formData[element]) //子表数据
                    ischild = true
                  }
                } else {
                  //如果不是子表则是上传文件，则转字符串
                  formData[element] = JSON.stringify(formData[element])
                }
              }
              // formData[element];
            })
          //判断需不需要存子表
          if (ischild) {
            formData.filedNames = formData.filedNames + ',table_name_children'
          }

          console.log(formData)
          //子表数据
          //调用保存接口
          this.btndisabled = true
          this.todoManageOperationObject.formData = formData
          this.todoManageOperationObject.url = url
          // formData.jsonContent=JSON.stringify(this.jsonData).toString()
          //获取是否部门负责人
          formData.filedNames = formData.filedNames + ',is_leaders'
          formData.is_leaders = this.$store.getters.userInfo.identity
          //清除子表规则的属性
          _.keys(formData).forEach(r => {
            if (r.indexOf('child&') != -1) {
              delete formData[r]
            }
          })
          //如果手机端子表得则需要修改json
          var jsonPamats = JSON.parse(JSON.stringify(this.jsonData))
          if (!this.isSJ && this.isNew) {
            jsonPamats = null
          }
          this.todoManageOperationObject.jsonData = jsonPamats
          //非我的待办节点打卡表单界面
          postFormDataAction(url, formData, { jsonContent: jsonPamats })
            .then(res => {
              if (res.success) {
                this.todoManageOperationObject.isSave = true
                this.$message.success('保存成功！')
                console.log('123')
                this.$emit('afterSubmit', formData)
                this.$emit('close')
                // resolve(true);
              } else {
                this.$message.error(res.message)
                // resolve(false);
              }
            })
            .finally(() => {
              this.btndisabled = false
              // resolve(false);
            })
        })
        .catch(err => {
          console.log(err, '校验失败')
          // resolve(false);
        })
      // })
    },
    //我的待办点击通过保存专用
    handleSubmit2(e) {
      // return new Promise((resolve)=>{
      //通过函数获取数据
      this.$refs.KFB.getData()
        .then(res => {
          //处理手机端子表数据
          if (this.isSJ) {
            this.itemData(res)
          }
          //清除为空的表单数据
          _.keys(res).forEach(r => {
            if (!res[r]) {
              delete res[r]
            }
          })
          // 获取数据成功
          let formData = JSON.parse(JSON.stringify(res))
          console.log(formData)
          formData.id = this.data.id
          formData.procDefId = this.processData.id
          formData.procDeTitle = this.processData.name
          // formData.jsonContent=JSON.stringify(this.jsonData)
          if (!formData.tableName) formData.tableName = this.processData.businessTable
          formData.filedNames = _.keys(res).join(',')
          formData.filedNames = getFiledNames(formData) //获取主表字段，排除子表标识
          var url = this.url.addApply
          if (!this.isNew) {
            url = this.url.editForm
          }
          //是否存在子表
          let ischild = false
          //循环表单字段属性判断是否属性中包含数组对象
          let i = 0 //子表数量
          _.keys(res)
            .join(',')
            .split(',')
            .forEach(element => {
              if (formData[element] instanceof Array) {
                //判断是否符合子表命名规则
                if (element.indexOf('&') != -1) {
                  let tableChildNameList = element.split('&')
                  //判断是否能拆分两个字符，子表标识和子表数据库名称
                  if (tableChildNameList.length == 2) {
                    i++
                    let childName = tableChildNameList[1] //子表数据库名称
                    if (!formData.table_name_children) {
                      //第一次拼接
                      formData.table_name_children = childName //表名
                    } else {
                      //后面的表明拼接用“,”隔开
                      formData.table_name_children = formData.table_name_children + ',' + childName //表名
                    }
                    //定义属性名和值
                    formData['childFiledNames' + i] = _.keys(formData[element][0]).join(',') //子表字段名
                    formData['childList' + i] = JSON.stringify(formData[element]) //子表数据
                    ischild = true
                  }
                } else {
                  //如果不是子表则是上传文件，则转字符串
                  formData[element] = JSON.stringify(formData[element])
                }
              }
              // formData[element];
            })
          //判断需不需要存子表
          if (ischild) {
            formData.filedNames = formData.filedNames + ',table_name_children'
          }

          console.log(formData)
          //子表数据
          //调用保存接口
          this.btndisabled = true
          this.todoManageOperationObject.formData = formData
          this.todoManageOperationObject.url = url
          //获取是否部门负责人
          formData.filedNames = formData.filedNames + ',is_leaders'
          formData.is_leaders = this.$store.getters.userInfo.identity
          //清除子表规则的属性
          _.keys(formData).forEach(r => {
            if (r.indexOf('child&') != -1) {
              delete formData[r]
            }
          })
          //如果手机端子表得则需要修改json
          var jsonPamats = JSON.parse(JSON.stringify(this.jsonData))
          if (!this.isSJ && this.isNew) {
            jsonPamats = null
          }
          this.todoManageOperationObject.jsonData = jsonPamats
        })
        .catch(err => {
          console.log(err, '校验失败')
          // resolve(false);
        })
      // })
    },
    close() {
      this.$emit('close')
    },
    getData() {
      // 通过函数获取数据
      this.$refs.KFB.getData()
        .then(res => {
          // 获取数据成功
          alert(JSON.stringify(res))
        })
        .catch(err => {
          console.log(err, '校验失败')
        })
    },
    //刷新待办列表
    refreshToDo() {
      this.close()
      this.$emit('getDataList')
    },
    itemData(res) {
      var childName = '' //子表规则名称
      var itemIndex = 0
      this.jsonData.list.forEach((element, index) => {
        if (element.label.indexOf('child&') != -1) {
          childName = element.label //获取规则名
          itemIndex = itemIndex + 1
        }
      })
      var itemList = [] //封装子表数据
      for (var i = 1; i <= itemIndex; i++) {
        var itemObject = {} //子表对象
        this.itemModelNameList.forEach(name => {
          //获取子表得值和封装对象
          itemObject[name] = res[name + '@' + i]
          delete res[name + '@' + i]
        })
        itemList.push(itemObject)
      }
      res[childName] = itemList //完成子表数据封装
      console.log(res)
    },
    deleteRow(idIndex) {
      //删除
      this.jsonData.list.splice(idIndex, 1)
      //删除掉得json之后 重新处理model 和value
      let childIndex = 0
      this.jsonData.list.forEach((element, index) => {
        if (element.label.indexOf('child&') != -1) {
          childIndex = childIndex + 1
          //只有当前删除的对象json的后面对象json才进行修改
          if (index >= idIndex) {
            //修改删除按钮的index
            element.columns[0].list[1].options.defaultValue =
              '<a href="javascript:void(0);" \n onclick="deleteRow(' + childIndex + ')">删除</a>'
            //修改model
            updateModel(element, childIndex)
            //需要调整的子表值
            var updateModelObject = {}
            //修改value
            this.$refs.KFB.getData().then(res => {
              //根据原始字段名拼接带规则的
              this.itemModelNameList.forEach(modelName => {
                updateModelObject[modelName + '@' + childIndex] = res[modelName + '@' + (childIndex + 1)]
              })
              this.$refs.KFB.setData(updateModelObject)
            })
          }
        }
      })
      console.log(JSON.stringify(this.jsonData.list))
    },
    add() {
      let childLable = '' //子表json标题
      let childValue = {} //新增子表json
      let isReturn = false
      let childIndex = 0
      var itemList = []
      this.jsonData.list.forEach((element, index) => {
        if (element.label.indexOf('child&') != -1) {
          childValue = JSON.parse(JSON.stringify(element))
          childLable = element.label
          //处理删除按钮
          childIndex = childIndex + 1
          // element.columns[0].list[1].options.dynamicFun = 'delete' + childIndex
          console.log(element.columns[0].list[1].options)
          element.columns[0].list[1].options.defaultValue =
            '<a href="javascript:void(0);" \n onclick="deleteRow(' + childIndex + ')">删除</a>'
          updateModel(childValue, childIndex)
        }

        if (!isReturn && childLable != '' && element.label != childLable) {
          isReturn = true
          //处理删除按钮
          childIndex = childIndex + 1
          // childValue.columns[0].list[1].options.dynamicFun = 'delete' + childIndex
          childValue.columns[0].list[1].options.defaultValue =
            '<a href="javascript:void(0);" \n onclick="deleteRow(' + childIndex + ')">删除</a>'
          updateModel(childValue, childIndex)
          // this.jsonData.list.splice(index, 0, childValue)
          itemList.push(childValue)
        }
        itemList.push(element)
      })
      this.jsonData.list = itemList
      console.log(JSON.stringify(this.jsonData.list))
    },
    //把整个子表json的model进行规则修改
    async listUpdateModel() {
      let modelIndex = 0 //子表model自增
      //循环整个json的表单
      this.jsonData.list.forEach((element, index) => {
        //找到为子表的json
        if (element.label.indexOf('child&') != -1) {
          this.isSJ = true
          //获取子表原始得model字段名
          if (modelIndex == 0) {
            var i = 1
            var itemString = JSON.stringify(element)
            var itemModelNameList = [] //储存子表字段名
            for (var i = 1; i !== -1; ) {
              //动态字符位置
              i = itemString.indexOf('"model"', i)
              if (i !== -1) {
                //从指定字符的周后一个字符后开始找(")
                var ihStart = itemString.indexOf('"', i + 7)
                //再从 (") 后面位置还是找下一个 (")
                var ihEnd = itemString.indexOf('"', ihStart + 1)
                //获取引号之间的字符
                var model = itemString.substring(ihStart + 1, ihEnd)
                //如果动态表示不为空则获取
                if (model != '') {
                  if (model.indexOf('@') != -1) {
                    model = model.substring(0, model.length - 2)
                  }
                  itemModelNameList.push(model)
                }
                i = ihEnd + 1
              }
            }
            this.itemModelNameList = itemModelNameList
          }
          modelIndex = modelIndex + 1
          //修改model
          updateModel(element, modelIndex)
        }
      })
    }
  }
}

//获取主表字段，排除子表标识
function getFiledNames(formData) {
  let filedNames = ''
  let list = formData.filedNames.split(',') //获取表单属性名集合
  list.forEach(element => {
    if (element.indexOf('&') == -1) {
      //查询是否有这个字段
      if (filedNames == '') {
        //第一次则直接等于
        filedNames = element
      } else {
        //后面用逗号隔开
        filedNames = filedNames + ',' + element
      }
    }
  })
  return filedNames
}

//根据开始时间 结束时间计算天数
function startEndFun(start, end) {
  let startTime = new Date(start)
  let endTime = new Date(end)
  if (startTime >= endTime) return 0
  //1,分钟取整
  startTime = carryTime(startTime)
  endTime = carryTime(endTime)
  //2，计算总天数
  var totalTime = 0 //工时，天数
  if (startTime.getDay() == 6 || startTime.getDay() == 0) {
    totalTime = endTime.getDate() - startTime.getDate()
  } else {
    totalTime = Math.floor((endTime - startTime) / (3600 * 1000) / 24)
  }
  //3,拿初始值赋值给一个临时变量
  var tempStartTime = new Date()
  tempStartTime.setTime(startTime.getTime())
  //4,计算出总天数
  while (tempStartTime.getDate() < endTime.getDate()) {
    if (tempStartTime.getDay() == 6 || tempStartTime.getDay() == 0) {
      //周六或者周日减去
      totalTime--
    }
    tempStartTime.setDate(tempStartTime.getDate() + 1)
  }

  //5,计算出总小时数
  var temp = 0 //工时，小时
  do {
    if (startTime.getDay() == 6 || startTime.getDay() == 0) {
      //周六周日
      startTime.setDate(startTime.getDate() + 1)
      //*********周六周日直接跳过，初始化为早晨9点
      startTime.setHours(9)
      startTime.setMinutes(0)
      continue
    }

    if (endTime.getDay() == 6 || endTime.getDay() == 0) {
      //周六周日
      endTime.setDate(endTime.getDate() + 1)
      //*********周六周日直接跳过，初始化为早晨9点
      endTime.setHours(9)
      endTime.setMinutes(0)
      continue
    }

    let tempMinutes = startTime.getHours() * 60 + startTime.getMinutes()
    //上午9点到12点半，算工时
    if (tempMinutes >= 9 * 60 && tempMinutes < 12 * 60) {
      temp += 0.05
    }
    //上午14点到18点半，算工时
    if (tempMinutes >= 13 * 60 && tempMinutes < 18 * 60) {
      temp += 0.05
    }
    startTime.setTime(startTime.getTime() + 0.5 * 3600 * 1000) //每次增加半个小时
  } while (startTime.getHours() * 60 + startTime.getMinutes() != endTime.getHours() * 60 + endTime.getMinutes())
  {
    totalTime += Math.floor(temp / 0.8)
    totalTime += temp % 0.8
    totalTime = Math.round(totalTime * 100) / 100
  }
  var days = Math.floor(totalTime)
  var hours = Math.round((totalTime - days) * 100) / 10
  console.log(days + '天', hours + '小时')

  return days * 8 + hours

  // if (start && end) {
  //   let startTime = new Date(start) // 开始时间
  //   let endTime = new Date(end) // 结束时间
  //   let usedTime = endTime - startTime // 相差的毫秒数
  //   let days = (usedTime / 1000 / 60 / 60).toFixed(2) // 计算出天数
  //   return days
  // } else {
  //   return null
  // }
}

//格式化时间
function formatDate(date, fmt) {
  if (/(y+)/.test(fmt)) {
    fmt = fmt.replace(RegExp.$1, (date.getFullYear() + '').substr(4 - RegExp.$1.length))
  }
  let o = {
    'M+': date.getMonth() + 1,
    'd+': date.getDate(),
    'h+': date.getHours(),
    'm+': date.getMinutes(),
    's+': date.getSeconds()
  }
  for (let k in o) {
    if (new RegExp(`(${k})`).test(fmt)) {
      let str = o[k] + ''
      fmt = fmt.replace(RegExp.$1, RegExp.$1.length === 1 ? str : padLeftZero(str))
    }
  }
  return fmt
}

function padLeftZero(str) {
  return ('00' + str).substr(str.length)
}

/*
 * 0-15分不算工时
 * 15-45算半个小时
 * 45-60算一个小时
 * */
function carryTime(date) {
  if (date.getMinutes() > 0 && date.getMinutes() < 15) {
    date.setMinutes(0)
  }
  if (date.getMinutes() >= 15 && date.getMinutes() < 30) {
    date.setMinutes(30)
  }
  if (date.getMinutes() > 30 && date.getMinutes() < 45) {
    date.setMinutes(30)
  }
  if (date.getMinutes() >= 45) {
    date.setHours(date.getHours() + 1)
    date.setMinutes(0)
  }
  return date
}

// function

/**
 * 修改model绑定值
 */
function updateModel(object, childIndex) {
  let keyString = _.keys(object).join(',')
  if (keyString.indexOf('model') != -1) {
    //如果没有修改过则直接修改
    if (object['model'].indexOf('@') == -1) {
      object['model'] = object['model'] + '@' + childIndex
    } else {
      //修改过则截取修改前的再进行修改
      var m = object['model'].substring(0, object['model'].length - 2)
      object['model'] = m + '@' + childIndex
    }
  }
  //递归
  _.keys(object)
    .join(',')
    .split(',')
    .forEach(l => {
      if (object[l] instanceof Array) {
        object[l].forEach(element => {
          updateModel(element, childIndex)
        })
      }
    })
}
</script>
<style lang="less" scoped>
.form-main {
}
</style>