2021-12-22

king

2021-12-22 bd1dfc9e6c9b9f8076ca2783ce598e0936b4c664

 src/templates/calendarconfig/index.jsx

@@ -4,20 +4,20 @@
import { is, fromJS } from 'immutable'
import { DndProvider } from 'react-dnd'
import HTML5Backend from 'react-dnd-html5-backend'
import { Button, Card, Modal, Collapse, notification, Spin, Icon, Switch } from 'antd'
import { Button, Card, Modal, Collapse, notification, Spin, Switch } from 'antd'
import { RedoOutlined } from '@ant-design/icons'
import moment from 'moment'

import Api from '@/api'
import zhCN from '@/locales/zh-CN/model.js'
import enUS from '@/locales/en-US/model.js'
import MKEmitter from '@/utils/events.js'
import Utils from '@/utils/utils.js'
import { getMainMenuForm } from '@/templates/zshare/formconfig'

import asyncComponent from '@/utils/asyncComponent'
import SearchComponent from '@/templates/sharecomponent/searchcomponent'

import MenuForm from '@/templates/zshare/menuform'
// import EditComponent from '@/templates/zshare/editcomponent'
import MenuForm from '@/templates/comtableconfig/menuform'
import SourceElement from '@/templates/zshare/dragsource'
import Source from './source'
import './index.scss'
@@ -25,7 +25,9 @@
const { Panel } = Collapse
const { confirm } = Modal

const SettingComponent = asyncComponent(() => import('@/templates/sharecomponent/datasourcecomponent'))
const UrlFieldComponent = asyncComponent(() => import('@/menu/urlfieldcomponent'))
const EditComponent = asyncComponent(() => import('@/templates/zshare/editcomponent'))
const SettingComponent = asyncComponent(() => import('@/templates/sharecomponent/settingcalcomponent'))
const TabComponent = asyncComponent(() => import('./tabcomponent'))
const CalComponent = asyncComponent(() => import('./calcomponent'))
const TableComponent = asyncComponent(() => import('@/templates/sharecomponent/tablecomponent'))
@@ -35,18 +37,15 @@
class SubTableConfig extends Component {
  static propTpyes = {
    menu: PropTypes.any,
    optionLibs: PropTypes.any,
    reloadmenu: PropTypes.func,
    handleView: PropTypes.func
  }

  state = {
    dict: localStorage.getItem('lang') !== 'en-US' ? zhCN : enUS,        // 字典
    dict: sessionStorage.getItem('lang') !== 'en-US' ? zhCN : enUS,        // 字典
    config: null,            // 页面配置
    visible: false,          // 搜索条件、按钮、显示列，模态框显示控制
    tableFields: [],         // 已选表字段集
    fields: null,            // 搜索条件及显示列，可选字段
    menuformlist: null,      // 基本信息表单字段
    formlist: null,          // 搜索条件、按钮、显示列表单字段
    menuloading: false,      // 菜单保存中
    menucloseloading: false, // 菜单关闭时，选择保存
@@ -54,12 +53,9 @@
    closeVisible: false,     // 关闭模态框
    originConfig: null,      // 原配置
    tabviews: [],            // 所有标签页
    optionLibs: null,        // 自定义下拉选项库
    activeKey: '0',          // 默认展开基本信息
    pasteContent: null,      // 粘贴内容
    openEdition: '',         // 编辑版本标记，防止多人操作
    mockdata: [],            // 测试数据
    mockloading: false       // 数据加载中
  }

  /**
@@ -68,7 +64,7 @@
   * 2、设置操作类型、原始菜单信息（每次保存后重置）、已使用表及基本信息表单
   */
  UNSAFE_componentWillMount () {
    const { menu, optionLibs } = this.props
    const { menu } = this.props
    let _LongParam = menu.LongParam
    let _config = ''

@@ -77,30 +73,32 @@
      _config.isAdd = true
    } else {
      _config = _LongParam
      _config.search.forEach(item => {
        if (
          (item.type === 'select' || item.type === 'multiselect' || item.type === 'link') &&
          item.resourceType === '0' &&
          item.options && item.options.length > 0
        ) {
          optionLibs.set(menu.MenuID + item.uuid, {
            uuid: menu.MenuID + item.uuid,
            label: item.label,
            parname: menu.MenuName,
            type: 'search',
            options: item.options
          })
        }
      })
    }

    if (_config.type === 'user') {
      if (_config.tab) {
        _config.tab.linkTab = ''
      }
    }

    // 页面配置中保留菜单信息，只用于数据传递
    _config.ParentId = menu.ParentId
    _config.fstMenuId = menu.fstMenuId
    _config.MenuName = menu.MenuName || ''
    _config.MenuNo = menu.MenuNo || ''
    _config.OpenType = menu.PageParam ? menu.PageParam.OpenType : ''
    _config.easyCode = _config.easyCode || ''

    // 数据源
    if (_config.setting.interType === 'inner' && !_config.setting.innerFunc) {
      _config.setting.interType = 'system'
    }

    this.setState({
      openEdition: menu.open_edition || '',
      optionLibs: optionLibs,
      activeKey: menu.activeKey || '0',
      config: _config,
      originMenu: fromJS(menu).toJS(),
      menuformlist: getMainMenuForm(menu, _config),
      originMenu: fromJS(_config).toJS(),
      mockdata: this.getMockData(moment().format('YYYY'))
    })
  }
@@ -116,14 +114,14 @@

  getMockData = (year) => {
    let msgs = [
      {color: 'red', remark: '服务器异常，请联系运维人员！'},
      {color: 'orange', remark: '系统异常，请及时处理！'},
      {color: 'yellow', remark: '您的订单异常，请联系客服！'},
      {color: 'green', remark: '您的订单已完成。'},
      {color: 'lightgreen', remark: '消息已发送，请及时查收。'},
      {color: 'red', remark: '您有一条新的消息！'},
      {color: 'orange', remark: '您有一条新的消息！'},
      {color: 'yellow', remark: '您有一条新的消息！'},
      {color: 'green', remark: '您有一条新的消息。'},
      {color: 'cyan', remark: '您有一条新的消息。'},
      {color: 'blue', remark: '任务未完成，请注意后续工作。'},
      {color: 'purple', remark: '您有新的任务等待处理！'}
      {color: 'blue', remark: '您有一条新的消息！'},
      {color: 'purple', remark: '您有一条新的消息。'},
      {color: 'gray', remark: '您有一条新的消息。'}
    ]
    let mockdata = []

@@ -219,7 +217,6 @@
  handleViewBack = () => {
    let param = {
      editMenu: null,
      optionLibs: null,
      editTab: null,
      tabConfig: null,
      subTabConfig: null,
@@ -235,19 +232,20 @@

  getFuncNames = (data, funcNames, tableNames) => {
    data.forEach(item => {
      if (item.subfuncs) {
        this.getFuncNames(item.subfuncs, funcNames, tableNames)
      } else {
        if (item.tableName) {
          tableNames.push(item.tableName)
        }
        if (item.innerFunc) {
          funcNames.push({func: item.innerFunc, label: item.label || ''})
        }
      // if (item.subfuncs) {
      //   this.getFuncNames(item.subfuncs, funcNames, tableNames)
      //   return
      // }

        if (item.callbackFunc) {
          funcNames.push({func: item.callbackFunc, label: item.label || ''})
        }
      if (item.tableName) {
        tableNames.push(item.tableName)
      }
      if (item.innerFunc) {
        funcNames.push({func: item.innerFunc, label: item.label || ''})
      }

      if (item.callbackFunc) {
        funcNames.push({func: item.callbackFunc, label: item.label || ''})
      }
    })

@@ -262,284 +260,259 @@
   */
  submitConfig = () => {
    const { menu } = this.props
    const { originMenu, openEdition } = this.state
    const { openEdition } = this.state

    let config = fromJS(this.state.config).toJS()
    let _config = fromJS(this.state.config).toJS()

    this.menuformRef.handleConfirm().then(res => {
      if (config.isAdd) {
        config.search = config.search.filter(item => !item.origin)
      }

      let _LongParam = ''
      let _config = {...config, easyCode: res.easyCode}
      let _pageParam = {...menu.PageParam, OpenType: res.opentype}

      // 未设置数据源或标签不合法时，启用状态为false
      let vresult = this.verifyconfig(_config)
      if (vresult !== true) {
        _config.enabled = false
      }

      _config.funcs = [] // 页面及子页面存储过程集

      _config.funcs.push({
        type: 'view',
        subtype: 'view',
        uuid: menu.MenuID,
        intertype: _config.setting.interType || 'inner',
        interface: _config.setting.interface || '',
        tableName: _config.setting.tableName || '',
        innerFunc: _config.setting.innerFunc || '',
        outerFunc: _config.setting.outerFunc || ''
      })

      if (_config.tab) {
        _config.funcs.push({
          type: 'tab',
          subtype: 'tab',
          uuid: _config.tab.uuid,
          label: _config.tab.label,
          linkTab: _config.tab.linkTab
        })
      }

      if (this.state.closeVisible) { // 显示关闭对话框时，模态框中保存按钮，显示保存中状态
        this.setState({
          menucloseloading: true
        })
      } else {
        this.setState({
          menuloading: true
        })
      }

      new Promise(resolve => {
        if (_config.tab) {
          Api.getSystemConfig({
            func: 'sPC_Get_LongParam',
            MenuID: _config.tab.linkTab
          }).then(result => {
            if (result.status && result.LongParam) {
              let _LongParam = ''
    
              if (result.LongParam) {
                try {
                  _LongParam = JSON.parse(window.decodeURIComponent(window.atob(result.LongParam)))
                } catch (e) {
                  console.warn('Parse Failure')
                  _LongParam = ''
                }
              }
  
              if (_LongParam) {
                _config.funcs[1].menuNo = _LongParam.tabNo || ''
                _config.funcs[1].subfuncs = _LongParam.funcs || []
              }
            }
            resolve()
          })
        } else {
          resolve()
        }
      }).then(() => {
        // 保存时删除配置类型，system 、user
        delete _config.type
        delete _config.isAdd
  
        try {
          _LongParam = window.btoa(window.encodeURIComponent(JSON.stringify(_config)))
        } catch (e) {
          notification.warning({
            top: 92,
            message: '编译错误',
            duration: 5
          })
          this.setState({
            menucloseloading: false,
            menuloading: false
          })
          return
        }
  
        let tabParam = { // 添加菜单tab页
          func: 'sPC_sMenusTab_AddUpt',
          MenuID: menu.MenuID
        }

        if (_config.tab) {
          tabParam.LText = Utils.formatOptions(`select '${menu.MenuID}' as MenuID ,'${_config.tab.linkTab}' as Tabid,'${_config.tab.label}' as TabName ,'0' as Sort`)
        } else {
          tabParam.LText = Utils.formatOptions(`select '${menu.MenuID}' as MenuID ,'' as Tabid,'' as TabName ,'0' as Sort`)
        }

        tabParam.timestamp = moment().format('YYYY-MM-DD HH:mm:ss') + '.000'
        tabParam.secretkey = Utils.encrypt(tabParam.LText, tabParam.timestamp)
  
        let _vals = this.getFuncNames(_config.funcs, [], [])
        let _tables = Array.from(new Set(_vals.table))

        let param = {
          func: 'sPC_TrdMenu_AddUpt',
          FstID: res.fstMenuId,
          SndID: res.parentId,
          ParentID: res.parentId,
          MenuID: menu.MenuID,
          MenuNo: res.MenuNo,
          EasyCode: res.easyCode,
          Template: menu.PageParam.Template || '',
          MenuName: res.MenuName,
          PageParam: JSON.stringify(_pageParam),
          LongParam: _LongParam,
          LText: _vals.func.map(item => `select '${menu.MenuID}' as MenuID,'${item.func}' as ProcName,'${item.label}' as MenuName`),
          LTexttb: _tables.map(item => `select '${menu.MenuID}' as MenuID,'${item}' as tbName`)
        }

        if (menu.menuSort) { // 菜单新建时设置排序
          param.Sort = menu.menuSort
        }

        param.LText = param.LText.join(' union all ')
        param.LText = Utils.formatOptions(param.LText)
        param.LTexttb = param.LTexttb.join(' union all ')
        param.LTexttb = Utils.formatOptions(param.LTexttb)
        param.timestamp = moment().format('YYYY-MM-DD HH:mm:ss') + '.000'
        param.secretkey = Utils.encrypt(param.LText, param.timestamp)

        if (openEdition) { // 版本管理
          param.open_edition = openEdition
        }

        // 保存本地
        let localParam = fromJS(param).toJS()

        Api.getSystemConfig(param).then(response => {
          if (response.status) {
            let _FMenu = originMenu.fstMenuList.filter(fstM => fstM.MenuID === res.fstMenuId)[0]
            let _supMenuList = []
            if (_FMenu) {
              _supMenuList = _FMenu.options
            }

            this.setState({
              config: _config,
              openEdition: response.open_edition || '',
              originMenu: {
                ...originMenu,
                LongParam: _config,
                PageParam: _pageParam,
                MenuName: res.MenuName,
                MenuNo: res.MenuNo,
                ParentID: res.parentId,
                fstMenuId: res.fstMenuId,
                supMenuList: _supMenuList
              }
            })

            this.props.reloadmenu()

            // 标签信息保存
            Api.getSystemConfig(tabParam).then(result => {
              if (result.status) {
                notification.success({
                  top: 92,
                  message: '保存成功',
                  duration: 2
                })
                if (this.state.closeVisible) {
                  this.handleViewBack()
                } else {
                  this.setState({
                    menuloading: false,
                    menucloseloading: false
                  })
                }
              } else {
                notification.warning({
                  top: 92,
                  message: result.message,
                  duration: 5
                })
                this.setState({
                  menuloading: false,
                  menucloseloading: false
                })
              }
            })

            localParam.func = 'sPC_TrdMenu_AddUpt_For_Local'
            delete localParam.LongParam
            delete localParam.PageParam
            delete localParam.Template
            delete localParam.Sort
            delete localParam.EasyCode
            delete localParam.open_edition

            Api.getLocalConfig(localParam)
          } else {
            this.setState({
              menuloading: false,
              menucloseloading: false
            })
            notification.warning({
              top: 92,
              message: response.message,
              duration: 5
            })
          }
        })
      })
    }, () => {
    // 基本信息验证
    if (!_config.fstMenuId || !_config.ParentId || !_config.MenuName || !_config.MenuNo) {
      notification.warning({
        top: 92,
        message: this.state.dict['model.menu.basemsg'],
        duration: 5
      })
      this.setState({activeKey: '0'})
      return
    }

    if (_config.isAdd) {
      _config.search = _config.search.filter(item => !item.origin)
    }

    if (_config.type === 'user') { // 使用已有菜单时，默认添加关联标签id
      if (_config.tab && !_config.tab.linkTab) {
        _config.tab.linkTab = Utils.getuuid()
      }
    }

    // 未设置数据源或标签不合法时，启用状态为false
    let vresult = this.verifyconfig(_config)
    if (vresult !== true) {
      _config.enabled = false
    }

    _config.funcs = [] // 页面及子页面存储过程集

    _config.funcs.push({
      type: 'view',
      subtype: 'view',
      uuid: menu.MenuID,
      intertype: _config.setting.interType || 'system',
      interface: _config.setting.interface || '',
      tableName: _config.setting.tableName || '',
      innerFunc: _config.setting.innerFunc || '',
      outerFunc: _config.setting.outerFunc || ''
    })

    if (_config.tab) {
      _config.funcs.push({
        type: 'tab',
        subtype: 'tab',
        uuid: _config.tab.uuid,
        label: _config.tab.label,
        linkTab: _config.tab.linkTab
      })
    }

    if (this.state.closeVisible) { // 显示关闭对话框时，模态框中保存按钮，显示保存中状态
      this.setState({
        menucloseloading: true
      })
    } else {
      this.setState({
        menuloading: true
      })
    }

    new Promise(resolve => {
      // if (_config.tab) {
      //   Api.getSystemConfig({
      //     func: 'sPC_Get_LongParam',
      //     MenuID: _config.tab.linkTab
      //   }).then(result => {
      //     if (result.status && result.LongParam) {
      //       let _LongParam = ''
  
      //       if (result.LongParam) {
      //         try {
      //           _LongParam = JSON.parse(window.decodeURIComponent(window.atob(result.LongParam)))
      //         } catch (e) {
      //           console.warn('Parse Failure')
      //           _LongParam = ''
      //         }
      //       }

      //       if (_LongParam) {
      //         _config.funcs[1].menuNo = _LongParam.tabNo || ''
      //         _config.funcs[1].subfuncs = _LongParam.funcs || []
      //       }
      //     }
      //     resolve()
      //   })
      // } else {
      //   resolve()
      // }
      resolve()
    }).then(() => {
      let reload = _config.isAdd

      // 保存时删除配置类型，system 、user
      delete _config.type
      delete _config.isAdd

      let _LongParam = ''

      try {
        _LongParam = window.btoa(window.encodeURIComponent(JSON.stringify(_config)))
      } catch (e) {
        notification.warning({
          top: 92,
          message: '编译错误',
          duration: 5
        })
        this.setState({
          menucloseloading: false,
          menuloading: false
        })
        return
      }

      let tabParam = { // 添加菜单tab页
        func: 'sPC_sMenusTab_AddUpt',
        MenuID: menu.MenuID
      }

      if (_config.tab) {
        tabParam.LText = Utils.formatOptions(`select '${menu.MenuID}' as MenuID ,'${_config.tab.linkTab}' as Tabid,'${_config.tab.label}' as TabName ,'0' as Sort`)
      } else {
        tabParam.LText = Utils.formatOptions(`select '${menu.MenuID}' as MenuID ,'' as Tabid,'' as TabName ,'0' as Sort`)
      }

      tabParam.timestamp = moment().format('YYYY-MM-DD HH:mm:ss')
      tabParam.secretkey = Utils.encrypt(tabParam.LText, tabParam.timestamp)

      let _vals = this.getFuncNames(_config.funcs, [], [])
      let _tables = Array.from(new Set(_vals.table))

      let param = {
        func: 'sPC_TrdMenu_AddUpt',
        FstID: _config.fstMenuId,
        SndID: _config.ParentId,
        ParentID: _config.ParentId,
        MenuID: menu.MenuID,
        MenuNo: _config.MenuNo,
        EasyCode: _config.easyCode || '',
        Template: _config.Template || '',
        MenuName: _config.MenuName,
        PageParam: JSON.stringify({...menu.PageParam, Template: _config.Template, OpenType: _config.OpenType}),
        LongParam: _LongParam,
        LText: _vals.func.map(item => `select '${menu.MenuID}' as MenuID,'${item.func}' as ProcName,'${item.label}' as MenuName`),
        LTexttb: _tables.map(item => `select '${menu.MenuID}' as MenuID,'${item}' as tbName`)
      }

      if (menu.menuSort) { // 菜单新建时设置排序
        param.Sort = menu.menuSort
      }

      param.LText = param.LText.join(' union all ')
      param.LText = Utils.formatOptions(param.LText)
      param.LTexttb = param.LTexttb.join(' union all ')
      param.LTexttb = Utils.formatOptions(param.LTexttb)
      param.timestamp = moment().format('YYYY-MM-DD HH:mm:ss')
      param.secretkey = Utils.encrypt(param.LText, param.timestamp)

      if (openEdition) { // 版本管理
        param.open_edition = openEdition
      }

      // 保存本地
      let localParam = fromJS(param).toJS()

      Api.getSystemConfig(param).then(response => {
        if (response.status) {
          this.setState({
            config: _config,
            openEdition: response.open_edition || '',
            originMenu: fromJS(_config).toJS()
          }, () => {
            reload && MKEmitter.emit('revert')
          })

          this.props.reloadmenu()

          // 标签信息保存
          Api.getSystemConfig(tabParam).then(result => {
            if (result.status) {
              notification.success({
                top: 92,
                message: '保存成功',
                duration: 2
              })
              if (this.state.closeVisible) {
                this.handleViewBack()
              } else {
                this.setState({
                  menuloading: false,
                  menucloseloading: false
                })
              }
            } else {
              notification.warning({
                top: 92,
                message: result.message,
                duration: 5
              })
              this.setState({
                menuloading: false,
                menucloseloading: false
              })
            }
          })

          localParam.func = 'sPC_TrdMenu_AddUpt_For_Local'
          delete localParam.LongParam
          delete localParam.PageParam
          delete localParam.Template
          delete localParam.Sort
          delete localParam.EasyCode
          delete localParam.open_edition

          Api.getLocalConfig(localParam)
        } else {
          this.setState({
            menuloading: false,
            menucloseloading: false
          })
          notification.warning({
            top: 92,
            message: response.message,
            duration: 5
          })
        }
      })
    })
  }

  cancelConfig = () => {
    const { menu } = this.props
    const { config, originMenu } = this.state

    let _this = this

    if (config.isAdd) {
      confirm({
        content: '菜单尚未提交，确定放弃保存吗？',
        okText: this.state.dict['model.confirm'],
        cancelText: this.state.dict['model.cancel'],
        onOk() {
          _this.props.handleView()
        },
        onCancel() {}
      })
    } else {
      this.menuformRef.handleConfirm().then(res => {
        let _config = {...config, easyCode: res.easyCode}
        let _pageParam = {...menu.PageParam, OpenType: res.opentype}
        let _originMenu = {
          ...originMenu,
          LongParam: _config,
          PageParam: _pageParam,
          MenuName: res.MenuName,
          MenuNo: res.MenuNo,
          ParentID: res.parentId,
          fstMenuId: res.fstMenuId
        }

        if (!is(fromJS(originMenu), fromJS(_originMenu))) {
          this.setState({
            closeVisible: true
          })
        } else {
          this.props.handleView()
        }
      }, () => {
      if (!is(fromJS(originMenu), fromJS(config))) {
        this.setState({
          closeVisible: true
        })
      })
      } else {
        this.props.handleView()
      }
    }
  }

@@ -548,7 +521,7 @@
   */
  setSubConfig = () => {
    const { menu } = this.props
    const { config, originMenu, optionLibs, activeKey, openEdition } = this.state
    const { config, originMenu, activeKey, openEdition } = this.state

    if (config.isAdd) { // 新建菜单，提示菜单尚未保存
      notification.warning({
@@ -557,99 +530,101 @@
        duration: 5
      })
    } else {
      this.menuformRef.handleConfirm().then(res => {
        let _config = {...config, easyCode: res.easyCode}
        let _pageParam = {...menu.PageParam, OpenType: res.opentype}
        let _originMenu = {
          ...originMenu,
          LongParam: _config,
          PageParam: _pageParam,
          MenuName: res.MenuName,
          MenuNo: res.MenuNo,
          ParentID: res.parentId,
          fstMenuId: res.fstMenuId
        }

        if (!is(fromJS(originMenu), fromJS(_originMenu))) { // 菜单信息变化时，提示保存
          notification.warning({
            top: 92,
            message: this.state.dict['header.menu.config.update'],
            duration: 5
          })
          return
        }

        // 菜单信息验证通过后，跳转子配置页面
        _originMenu.activeKey = activeKey       // 保存当前打开页签
        _originMenu.open_edition = openEdition  // 更新版本号

        let param = {
          optionLibs: optionLibs,
          editMenu: _originMenu,
          editTab: fromJS(config.tab).toJS(),
          tabConfig: null,
          editSubTab: null,
          subTabConfig: null,
          btnTab: null,
          btnTabConfig: null,
          editAction: '',
          subConfig: '',
          tabview: config.tab.type
        }
        
        // 当子表使用主页搜索条件时，将主页搜索向下传递
        if (param.editTab && param.editTab.searchPass === 'true') {
          param.editTab.mainsearch = fromJS(_config.search).toJS()
        }

        this.setState({
          loading: true
      // 基本信息验证
      if (!config.fstMenuId || !config.ParentId || !config.MenuName || !config.MenuNo) {
        notification.warning({
          top: 92,
          message: this.state.dict['model.menu.basemsg'],
          duration: 5
        })
        this.setState({activeKey: '0'})
        return
      }

        Api.getSystemConfig({
          func: 'sPC_Get_LongParam',
          MenuID: config.tab.linkTab
        }).then(res => {
          if (res.status) {
            this.setState({
              loading: false
            })
            let _LongParam = ''
            if (res.LongParam) {
              try {
                _LongParam = JSON.parse(window.decodeURIComponent(window.atob(res.LongParam)))
              } catch (e) {
                console.warn('Parse Failure')
                _LongParam = ''
              }
            }

            if (_LongParam && param.tabview === 'SubTable' && _LongParam.Template === 'SubTable') {
              param.subConfig = _LongParam
            }

            if (param.editTab) {
              param.editTab.open_edition = res.open_edition || ''
            }

            this.props.handleView(param)
          } else {
            this.setState({
              loading: false
            })
            notification.warning({
              top: 92,
              message: res.message,
              duration: 5
            })
          }
        })
      }, () => {
      if (!is(fromJS(originMenu), fromJS(config))) { // 菜单信息变化时，提示保存
        notification.warning({
          top: 92,
          message: this.state.dict['header.menu.config.update'],
          duration: 5
        })
        return
      }

      let submenu = menu.fstMenuList.filter(item => item.MenuID === config.fstMenuId)[0]
      let _Menu = {
        ...menu,
        LongParam: config,
        PageParam: {...menu.PageParam, Template: config.Template, OpenType: config.OpenType},
        MenuName: config.MenuName,
        MenuNo: config.MenuNo,
        ParentId: config.ParentId,
        fstMenuId: config.fstMenuId,
        supMenuList: submenu ? submenu.options : []
      }

      // 菜单信息验证通过后，跳转子配置页面
      _Menu.activeKey = activeKey       // 保存当前打开页签
      _Menu.open_edition = openEdition  // 更新版本号

      let param = {
        editMenu: _Menu,
        editTab: fromJS(config.tab).toJS(),
        tabConfig: null,
        editSubTab: null,
        subTabConfig: null,
        btnTab: null,
        btnTabConfig: null,
        editAction: '',
        subConfig: '',
        tabview: config.tab.type
      }
      
      // 当子表使用主页搜索条件时，将主页搜索向下传递
      if (param.editTab && param.editTab.searchPass === 'true') {
        param.editTab.mainsearch = fromJS(config.search).toJS()
      }

      this.setState({
        loading: true
      })

      Api.getSystemConfig({
        func: 'sPC_Get_LongParam',
        MenuID: config.tab.linkTab
      }).then(res => {
        if (res.status) {
          this.setState({
            loading: false
          })
          let _LongParam = ''
          if (res.LongParam) {
            try {
              _LongParam = JSON.parse(window.decodeURIComponent(window.atob(res.LongParam)))
            } catch (e) {
              console.warn('Parse Failure')
              _LongParam = ''
            }
          }

          if (_LongParam && param.tabview === 'SubTable' && _LongParam.Template === 'SubTable') {
            param.subConfig = _LongParam
          }

          if (param.editTab) {
            param.editTab.open_edition = res.open_edition || ''
          }

          this.props.handleView(param)
        } else {
          this.setState({
            loading: false
          })
          notification.warning({
            top: 92,
            message: res.message,
            duration: 5
          })
        }
      })
    }
  }
@@ -681,23 +656,27 @@
   * @description 校验配置信息的合法性
   */
  verifyconfig = (config) => {
    let hasKey = false
    let chartcols = []
    let cols = []
    config.columns.forEach(col => {
      if (col.field) {
        chartcols.push(col.field)
      }
      if (config.setting.primaryKey === col.field) {
        hasKey = true
        cols.push(col.field)
      }
    })

    if (config.setting.interType === 'inner' && !config.setting.innerFunc && config.setting.default !== 'false' && !config.setting.dataresource) {
    if (config.setting.interType === 'system' && config.setting.default !== 'false' && !config.setting.dataresource) {
      return '菜单尚未设置数据源，不可启用！'
    } else if (!config.setting.primaryKey) {
      return '菜单尚未设置主键，不可启用！'
    } else if (!hasKey) {
      return '显示列中不存在主键字段，不可启用！'
    } else if (config.columns.length === 0) {
      return '菜单尚未设置字段集，不可启用！'
    } else if (!config.calendar.startfield) {
      return '日历关联字段未设置，不可启用！'
    } else if (!cols.includes(config.calendar.startfield)) {
      return '开始时间字段已删除，不可启用！'
    } else if (!cols.includes(config.calendar.endfield)) {
      return '结束时间字段已删除，不可启用！'
    } else if (config.calendar.colorfield && !cols.includes(config.calendar.colorfield)) {
      return '颜色字段已删除，不可启用！'
    } else if (!cols.includes(config.calendar.remarkfield)) {
      return '信息字段已删除，不可启用！'
    } else {
      return true
    }
@@ -712,25 +691,17 @@
        config: res.config
      })
    } else if (res.type === 'paste') {
      this.setState({
        pasteContent: res.content
      }, () => {
        this.setState({
          pasteContent: null
        })
      })
      this.setState({config: res.config})
    }
  }

  /**
   * @description 更新搜索条件配置信息
   */
  updatesearch = (config, options) => {
    const { optionLibs } = this.state
  updatesearch = (config) => {

    this.setState({
      config: config,
      optionLibs: options || optionLibs
      config: config
    })
  }

@@ -742,60 +713,42 @@
      config: config
    })
  }
  
  /**
   * @description 更新常用表信息，快捷添加后更新配置信息
   */
  updatetable = (config, fields) => {
    const { tableFields } = this.state

    this.setState({
      config: config,
      tableFields: fields ? fields : tableFields
    })
  }

  /**
   * @description 批量添加，更新配置信息
   */
  updatefield = (config) => {
    this.setState({
      config: config
    })
  }

  // 年切换时重新生成数据
  changeDate = (year) => {
    this.setState({mockloading: true}, () => {
      this.setState({
        mockloading: false,
        mockdata: this.getMockData(year)
      })
    this.setState({
      mockdata: this.getMockData(year)
    })
  }

  render () {
    const { activeKey, config, tabviews, mockdata, mockloading } = this.state
    const { menu } = this.props
    const { activeKey, config, tabviews, mockdata } = this.state

    return (
      <div className="model-subtable-board">
      <div className="model-calendar-board">
        <DndProvider backend={HTML5Backend}>
          {/* 工具栏 */}
          <div className="tools">
            <Collapse accordion defaultActiveKey={activeKey} bordered={false} onChange={(key) => this.setState({activeKey: key})}>
            <Collapse accordion activeKey={activeKey} bordered={false} onChange={(key) => this.setState({activeKey: key})}>
              {/* 基本信息 */}
              <Panel forceRender={true} header={'标签基本信息'} key="0" id="subtable-basedata">
                {/* 菜单信息 */}
                <MenuForm
                  menu={menu}
                  config={config}
                  dict={this.state.dict}
                  formlist={this.state.menuformlist}
                  wrappedComponentRef={(inst) => this.menuformRef = inst}
                  updatemenu={this.updateconfig}
                />
                {config ? <UrlFieldComponent
                  config={config}
                  updateConfig={this.updateconfig}
                /> : null}
                {/* 表名添加 */}
                <TableComponent
                  config={config}
                  containerId="subtable-basedata"
                  updatetable={this.updatetable}
                  updatetable={this.updateconfig}
                />
              </Panel>
              {/* 搜索条件添加 */}
@@ -805,12 +758,7 @@
                    return (<SourceElement key={index} content={item}/>)
                  })}
                </div>
                <FieldsComponent
                  config={config}
                  type="search"
                  tableFields={this.state.tableFields}
                  updatefield={this.updatefield}
                />
                <FieldsComponent config={config} type="search" />
              </Panel>
            </Collapse>
          </div>
@@ -818,38 +766,32 @@
            <Card title={
              <div>
                日历页面配置 
                <Icon type="redo" style={{marginLeft: '10px'}} title="刷新标签列表" onClick={() => this.reloadTab(true)} />
                <RedoOutlined style={{marginLeft: '10px'}} title="刷新标签列表" onClick={() => this.reloadTab(true)} />
              </div>
            } bordered={false} extra={
              <div>
                {/* <EditComponent dict={this.state.dict} type="subtable" config={this.state.config} refresh={this.updateConfig}/> */}
                <EditComponent dict={this.state.dict} type="table" options={['search', 'form']} config={this.state.config}/>
                <Switch className="big" checkedChildren="启" unCheckedChildren="停" checked={this.state.config.enabled} onChange={this.onEnabledChange} />
                <Button type="primary" onClick={this.submitConfig} loading={this.state.menuloading}>{this.state.dict['model.save']}</Button>
                <Button onClick={this.cancelConfig}>{this.state.dict['model.back']}</Button>
              </div>
            } style={{ width: '100%' }}>
              <SettingComponent
                type="subtable"
                config={config}
                MenuID={config.uuid}
                menuformRef={this.menuformRef}
                permFuncField={this.props.permFuncField}
                MenuID={menu.MenuID}
                updateConfig={this.updateconfig}
              />
              <SearchComponent
                menu={{MenuID: config.uuid, MenuName: config.tabName}}
                menu={{MenuID: menu.MenuID, MenuName: config.MenuName}}
                config={config}
                pasteContent={this.state.pasteContent}
                sysRoles={this.props.sysRoles}
                optionLibs={this.state.optionLibs}
                updatesearch={this.updatesearch}
              />
              <div className="calendar-wrap">
                <TabComponent config={config} updateConfig={this.updateconfig} tabviews={tabviews} setSubConfig={this.setSubConfig} />
                <CalComponent config={config} updateConfig={this.updateconfig} />
                <CalendarComponent calendar={{
                  levels: config.calendar.levels, startfield: 'start', endfield: 'end', colorfield: 'color', remarkfield: 'remark'
                }} loading={mockloading} data={mockdata} changeDate={this.changeDate}/>
                  levels: config.calendar.levels, startfield: 'start', endfield: 'end', colorfield: 'color', remarkfield: 'remark', refresh: config.calendar.refresh
                }} data={mockdata} changeDate={this.changeDate}/>
              </div>
            </Card>
          </div>
@@ -877,8 +819,6 @@

const mapStateToProps = (state) => {
  return {
    sysRoles: state.sysRoles,
    permFuncField: state.permFuncField,
    memberLevel: state.memberLevel
  }
}