2020-05-05

king

2020-05-05 92108e6c93de657838bbd766a9eb4f27d85e1c2d

 src/templates/comtableconfig/index.jsx

@@ -4,7 +4,7 @@
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, Tooltip } from 'antd'
import { Button, Card, Modal, Collapse, notification, Spin, Icon, Switch, Tooltip, Col } from 'antd'
import moment from 'moment'

import Api from '@/api'
@@ -16,19 +16,16 @@
import asyncComponent from '@/utils/asyncComponent'
import TableComponent from '@/templates/sharecomponent/tablecomponent'
import FieldsComponent from '@/templates/sharecomponent/fieldscomponent'
// import ChartGroupComponent from '@/templates/sharecomponent/chartgroupcomponent'
import ChartGroupComponent from '@/templates/sharecomponent/chartgroupcomponent'
import SearchComponent from '@/templates/sharecomponent/searchcomponent'
import ActionComponent from '@/templates/sharecomponent/actioncomponent'
import ColumnComponent from '@/templates/sharecomponent/columncomponent'
import TabsComponent from '@/templates/sharecomponent/tabscomponent'
import ChartComponent from '@/templates/sharecomponent/chartcomponent'

// import SettingForm from './settingform'
import TabForm from '@/templates/zshare/tabform'
import MenuForm from '@/templates/zshare/menuform'
import TabDragElement from '@/templates/zshare/tabdragelement'
import EditComponent from '@/templates/zshare/editcomponent'
import SourceElement from '@/templates/zshare/dragsource'
// import CreateFunc from '@/templates/zshare/createfunc'
// import CreateInterface from '@/templates/zshare/createinterface'
import Source from './source'
import './index.scss'

@@ -52,7 +49,6 @@
    fields: null,            // 搜索条件及显示列，可选字段
    menuformlist: null,      // 基本信息表单字段
    formlist: null,          // 搜索条件、按钮、显示列表单字段
    modaltype: '',           // 模态框类型，控制模态框显示
    card: null,              // 编辑元素
    menuloading: false,      // 菜单保存中
    menucloseloading: false, // 菜单关闭时，选择保存
@@ -67,7 +63,7 @@
    optionLibs: null,        // 自定义下拉选项库
    thawButtons: [],         // 已选择要解冻的按钮
    activeKey: '0',          // 默认展开基本信息
    sqlVerifing: false,      // sql验证
    chartview: null,         // 当前视图
    pasteContent: null       // 粘贴配置信息
  }

@@ -109,10 +105,40 @@

    // 配置默认值，兼容
    _config.tabs = _config.tabs || []
    _config.tabgroups = _config.tabgroups || ['tabs']
    _config.setting.subtabs = _config.setting.subtabs || []
    _config.Template = 'CommonTable'
    _config.easyCode = _config.easyCode || ''

    if (!_config.tabgroups) {
      _config.tabgroups = [{ uuid: 'tabs', sublist: [] }]
    } else if (typeof(_config.tabgroups[0]) === 'string') {
      let _tabgroups = []
      _config.tabgroups.forEach(groupId => {
        let _group = {
          uuid: groupId,
          sublist: fromJS(_config[groupId]).toJS()
        }

        delete _config[groupId]

        _tabgroups.push(_group)
      })

      _config.tabgroups = _tabgroups
    }

    // 兼容图表
    if (!_config.charts) {
      _config.expand = false
      _config.charts = [{
        uuid: Utils.getuuid(),
        label: '',
        title: '',
        chartType: 'table',
        icon: 'table',
        Hide: 'false',
        blacklist: []
      }]
    }
    
    let _oriActions = []
    if (_config.type === 'user') {
@@ -143,7 +169,7 @@

      // 重置标签ID
      _config.tabgroups.forEach(group => {
        _config[group] = _config[group].map(tab => {
        group.sublist = group.sublist.map(tab => {
          tab.uuid = Utils.getuuid()
          
          if (tab.linkTab) {
@@ -156,6 +182,7 @@
    }

    this.setState({
      chartview: _config.charts[0].uuid,
      config: _config,
      activeKey: menu.activeKey || '0',
      optionLibs: optionLibs,
@@ -225,246 +252,6 @@
  }

  /**
   * @description 元素添加或拖动时顺序变化
   */
  handleList = (type, list, card) => {
    const { config } = this.state

    if (list.length > config[card.groupId].length) {
      list = list.filter(item => !item.origin)
      this.handleTab(card)
    }

    this.setState({config: {...config, [card.groupId]: list}})
  }
  
  /**
   * @description 标签编辑，筛选可选的下级标签与已关联的下级标签
   */
  handleTab = (card) => {
    const { config } = this.state

    let menus = [
      {value: '', text: '空'},
      {value: 'mainTable', text: '主表'}
    ]
    let equalTabs = []
    let supMenu = card.supMenu || ''
    let equalTab = card.equalTab || []
    let isuptab = true
    let equalTabIds = []

    config.tabgroups.forEach((groupId, i) => {
      if (groupId === card.groupId) {
        isuptab = false
        config[card.groupId].forEach(tab => { // 可关联的同级标签
          if (tab.uuid === card.uuid) return

          equalTabIds.push(tab.uuid)
          equalTabs.push(tab)
        })
      } else if (isuptab) {
        config[groupId].forEach(tab => {
          menus.push({
            value: tab.uuid,
            text: tab.label
          })
        })
      }
    })

    if (supMenu && menus.filter(menu => menu.value === supMenu).length === 0) {
      supMenu = ''
    }

    if (equalTab.length > 0) {
      equalTab = equalTab.filter(tabId => equalTabIds.includes(tabId))
    }


    this.setState({
      modaltype: 'tabs',
      card: card,
      formlist: [
        {
          type: 'text',
          key: 'label',
          label: this.state.dict['header.menu.tabName'],
          initVal: card.label || '',
          required: true
        },
        {
          type: 'select',
          key: 'type',
          label: this.state.dict['header.form.tabType'],
          initVal: card.type || 'SubTable',
          required: true,
          options: [{
            value: 'SubTable',
            text: this.state.dict['header.menu.tab.subtable']
          }]
        },
        {
          type: 'select',
          key: 'linkTab',
          label: this.state.dict['header.form.linkTab'],
          initVal: card.linkTab || '',
          required: false,
          options: []
        },
        {
          type: 'select',
          key: 'icon',
          label: this.state.dict['header.menu.icon'],
          initVal: card.icon || '',
          required: false,
          options: [{
            value: '',
            text: this.state.dict['header.form.empty']
          }, {
            value: 'table',
            text: 'table'
          }, {
            value: 'bar-chart',
            text: 'bar-chart'
          }, {
            value: 'pie-chart',
            text: 'pie-chart'
          }, {
            value: 'line-chart',
            text: 'line-chart'
          }]
        },
        {
          type: 'select',
          key: 'supMenu',
          label: this.state.dict['header.form.supTab'],
          initVal: supMenu,
          required: false,
          options: menus
        },
        {
          type: 'mutilselect',
          key: 'equalTab',
          label: this.state.dict['header.form.equalTab'],
          tooltip: '如果子标签中含有刷新同级标签的按钮，在此处添加需要刷新的标签。',
          initVal: equalTab,
          required: false,
          options: equalTabs
        },
        {
          type: 'text',
          key: 'foreignKey',
          label: '外键',
          tooltip: '外键旨在标签页中执行默认函数（添加）时，替换BID字段',
          initVal: card.foreignKey || '',
          required: false
        },
        {
          type: 'radio',
          key: 'searchPass',
          label: '主表搜索',
          initVal: card.searchPass || 'false',
          tooltip: '使用主表搜索条件时，主表的搜索条件会传入子表中。',
          required: false,
          options: [{
            value: 'true',
            text: '使用'
          }, {
            value: 'false',
            text: '不使用'
          }]
        }
      ]
    })
  }

  /**
   * @description 标签修改后提交保存
   */
  handleSubmit = () => {
    const { config } = this.state
    this.tabsFormRef.handleConfirm().then(res => {
      let _tabgroup = config[res.groupId].map(item => {
        if (item.uuid === res.uuid) {
          return res
        } else {
          return item
        }
      })
      _tabgroup = _tabgroup.filter(item => !item.origin)

      this.setState({
        config: {...config, [res.groupId]: _tabgroup},
        modaltype: ''
      })
    })
  }

  /**
   * @description 取消保存，如果元素为新添元素，则从序列中删除
   */
  editModalCancel = () => {
    const { config, card } = this.state

    if (card && card.focus) {
      let _config = null

      let _tabgroup = config[card.groupId].filter(item => item.uuid !== card.uuid)
      _config = {...config, [card.groupId]: _tabgroup}

      this.setState({
        card: null,
        config: _config,
        modaltype: ''
      })
    } else {
      this.setState({
        card: null,
        modaltype: ''
      })
    }
  }

  deleteElement = (element) => {
    const { config, thawButtons } = this.state
    let _this = this

    confirm({
      content: `确定删除<<${element.card.label}>>吗？`,
      okText: this.state.dict['model.confirm'],
      cancelText: this.state.dict['header.cancel'],
      onOk() {
        let _config = null

        if (element.type === 'tabs') {
          let _tabgroup = config[element.card.groupId].filter(item => {
            if (item.uuid === element.card.uuid) {
              return false
            } else {
              return true
            }
          })
          _config = {...config, [element.card.groupId]: _tabgroup}
        }

        // 删除按钮元素
        let _delActions = _this.state.delActions
        if (element.type === 'action' || element.type === 'tabs') {
          _delActions.push(element)
        }

        _this.setState({
          config: _config,
          delActions: _delActions,
          thawButtons: thawButtons.filter(key => key !== element.card.uuid)
        })
      },
      onCancel() {}
    })
  }

  /**
   * @description 三级菜单切换模板
   */
  changeTemplate = () => {
@@ -506,48 +293,10 @@

    this.menuformRef.handleConfirm().then(res => {
      if (config.isAdd) {
        if (config.search[0] && config.search[0].origin) {
          config.search = config.search.filter(item => !item.origin)
        }
        if (config.action[0] && config.action[0].origin) {
          config.action = config.action.filter(item => !item.origin)
        }
        if (config.columns[0] && config.columns[0].origin) {
          config.columns = config.columns.filter(item => !item.origin)
        }
        if (config.tabs[0] && config.tabs[0].origin) {
          config.tabs = config.tabs.filter(item => !item.origin)
        }
      }

      let btnNames = config.action.map(item => item.label)
      btnNames = Array.from(new Set(btnNames))
      if (btnNames.length < config.action.length) {
        notification.warning({
          top: 92,
          message: '按钮名称不可相同！',
          duration: 5
        })
        return
      }

      let tabNames = []
      let tablength = 0
      config.tabgroups.forEach(group => {
        config[group].forEach(tab => {
          tabNames.push(tab.label)
        })
        tablength += config[group].length
      })
      tabNames = Array.from(new Set(tabNames))

      if (tabNames.length < tablength) {
        notification.warning({
          top: 92,
          message: '标签名称不可相同！',
          duration: 5
        })
        return
        config.search = config.search.filter(item => !item.origin)
        config.action = config.action.filter(item => !item.origin)
        config.columns = config.columns.filter(item => !item.origin)
        config.tabgroups[0].sublist = config.tabgroups[0].sublist.filter(item => !item.origin)
      }

      if (config.type === 'user') { // 使用已有菜单时，默认添加关联标签id
@@ -559,11 +308,10 @@
        })
    
        config.tabgroups.forEach(group => {
          config[group] = config[group].map(tab => {
          group.sublist = group.sublist.map(tab => {
            if (!tab.linkTab) {
              tab.linkTab = Utils.getuuid()
            }
  
            return tab
          })
        })
@@ -574,16 +322,9 @@
      let _pageParam = {...menu.PageParam, OpenType: res.opentype}

      // 未设置数据源或标签不合法时，启用状态为false
      if (_config.setting.interType === 'inner' && !_config.setting.innerFunc && !_config.setting.dataresource) {
      let vresult = this.verifyconfig(_config)
      if (vresult !== true) {
        _config.enabled = false
      } else if (!_config.setting.primaryKey) {
        _config.enabled = false
      } else if (_config.tabgroups.length > 1) {
        _config.tabgroups.forEach(group => {
          if (_config[group].length === 0) {
            _config.enabled = false
          }
        })
      }

      _config.funcs = [] // 页面及子页面存储过程集
@@ -638,10 +379,8 @@
        }
      })

      _config.tabgroups.forEach(groupId => {
        if (_config[groupId].length === 0) return

        _config[groupId].forEach(tab => {
      _config.tabgroups.forEach(group => {
        group.sublist.forEach(tab => {
          _config.funcs.push({
            type: 'tab',
            subtype: 'tab',
@@ -766,8 +505,8 @@
        btntabs.forEach(item => {
          _LText.push(`select '${item.uuid}' as MenuID ,'${item.linkTab}' as Tabid,'${item.label}' as TabName ,'${item.sort * 10}' as Sort`)
        })
        _config.tabgroups.forEach(groupId => {
          _config[groupId].forEach(item => {
        _config.tabgroups.forEach(group => {
          group.sublist.forEach(item => {
            _sort++
            _LText.push(`select '${menu.MenuID}' as MenuID ,'${item.linkTab}' as Tabid,'${item.label}' as TabName ,'${_sort * 10}' as Sort`)
          })
@@ -1071,13 +810,27 @@

                    return _btn
                  })
                  _subconfig.tabgroups.forEach(_groupId => {
                    _subconfig[_groupId] = _subconfig[_groupId].map(_tab => {
                      _tab.uuid = Utils.getuuid()
  
                      if (_tab.linkTab) {
                        _tab.linkTab = ''

                  // 兼容已有结构
                  if (!_subconfig.tabgroups) {
                    _subconfig.tabgroups = [{ uuid: 'tabs', sublist: [] }]
                  } else if (typeof(_subconfig.tabgroups[0]) === 'string') {
                    let _tabgroups = []
                    _subconfig.tabgroups.forEach(groupId => {
                      let _group = {
                        uuid: groupId,
                        sublist: fromJS(_subconfig[groupId]).toJS()
                      }
                      delete _subconfig[groupId]
                      _tabgroups.push(_group)
                    })
                    _subconfig.tabgroups = _tabgroups
                  }

                  _subconfig.tabgroups.forEach(group => {
                    group.sublist = group.sublist.map(_tab => {
                      _tab.uuid = Utils.getuuid()
                      _tab.linkTab = Utils.getuuid()

                      return _tab
                    })
@@ -1316,107 +1069,44 @@
  onEnabledChange = () => {
    const { config } = this.state

    let _enabled = !config.enabled
    let result = this.verifyconfig(config)
    if (_enabled && result !== true) {
      notification.warning({
        top: 92,
        message: result,
        duration: 5
      })
      return
    }

    this.setState({
      config: {...config, enabled: _enabled}
    })
  }

  /**
   * @description 校验配置信息的合法性
   */
  verifyconfig = (config) => {
    let tabinvalid = true
    if (config.tabgroups.length > 1) {
      config.tabgroups.forEach(group => {
        if (config[group].length === 0) {
        if (group.sublist.length === 0) {
          tabinvalid = false
        }
      })
    }

    if (config.setting.interType === 'inner' && !config.setting.innerFunc && !config.setting.dataresource) {
      notification.warning({
        top: 92,
        message: '菜单尚未设置数据源，不可启用！',
        duration: 5
      })
      return '菜单尚未设置数据源，不可启用！'
    } else if (!config.setting.primaryKey) {
      notification.warning({
        top: 92,
        message: '菜单尚未设置主键，不可启用！',
        duration: 5
      })
      return '菜单尚未设置主键，不可启用！'
    } else if (!tabinvalid) {
      notification.warning({
        top: 92,
        message: '菜单标签页设置错误（多行标签内，行标签不可为空），不可启用！',
        duration: 5
      })
      return '菜单标签页设置错误（存在多行标签时，行标签不可为空）！'
    } else {
      this.setState({
        config: {...config, enabled: !config.enabled}
      })
      return true
    }
  }

  /**
   * @description 增加标签页分组
   */
  addTabGroup = () => {
    let _this = this
    let _config = fromJS(this.state.config).toJS()

    confirm({
      content: `确定新建标签组吗？`,
      okText: this.state.dict['model.confirm'],
      cancelText: this.state.dict['header.cancel'],
      onOk() {
        let newgroup = 'tabs' + Utils.getuuid()

        _config.tabgroups.push(newgroup)
        _config[newgroup] = []

        _this.setState({
          config: _config
        })
      },
      onCancel() {}
    })
  }

  /**
   * @description 删除标签页分组
   */
  delTabGroup = (groupId) => {
    let _this = this
    let _config = fromJS(this.state.config).toJS()

    confirm({
      content: `确定删除标签组吗？`,
      okText: this.state.dict['model.confirm'],
      cancelText: this.state.dict['header.cancel'],
      onOk() {

        _config.tabgroups = _config.tabgroups.filter(group => group !== groupId)
        delete _config[groupId]

        _this.setState({
          config: _config
        })
      },
      onCancel() {}
    })
  }

  handleGroup = (index, type) => {
    let config = fromJS(this.state.config).toJS()
    
    if (type === 'up') {
      config.tabgroups.splice(index, 0, config.tabgroups.splice(index - 1, 1)[0])
    } else {
      config.tabgroups.splice(index, 0, config.tabgroups.splice(index + 1, 1)[0])
    }

    this.setState({
      config: config
    })

    notification.success({
      top: 92,
      message: '调整成功',
      duration: 2
    })
  }

  /**
@@ -1501,6 +1191,18 @@
  }

  /**
   * @description 更新标签配置信息
   */
  updatetabs = (config, delcards) => {
    const { delActions } = this.state

    this.setState({
      config: config,
      delActions: delcards ? [...delActions, ...delcards] : delActions
    })
  }

  /**
   * @description 更新配置信息
   */
  updateconfig = (config) => {
@@ -1510,13 +1212,13 @@
  }

  render () {
    const { modaltype, activeKey, config } = this.state
    const { activeKey, config, chartview } = this.state

    const confActions = config.action.filter(_action => !_action.origin && ['pop', 'popview', 'blank', 'tab'].includes(_action.OpenType))

    let configTabs = []
    config.tabgroups.forEach(group => {
      configTabs.push(...config[group])
      configTabs.push(...group.sublist)
    })

    return (
@@ -1660,73 +1362,64 @@
                optionLibs={this.state.optionLibs}
                updatesearch={this.updatesearch}
              />
              <ActionComponent
              <div className="chart-view" style={{position: 'relative'}}>
                {/* 视图组 */}
                <ChartGroupComponent
                  config={config}
                  sysRoles={this.props.sysRoles}
                  updatechartgroup={this.updatechartgroup}
                />
                {config.charts.map(item => {
                  if (!config.expand && chartview !== item.uuid) return ''

                  if (item.chartType === 'table') {
                    return (
                      <Col span={item.width || 24} key={item.uuid}>
                        {config.charts.length > 1 ? <p className="chart-title">{item.title}</p> : null}
                        <ActionComponent
                          type="main"
                          menu={{ MenuID: this.props.menu.MenuID, MenuName: this.props.menu.MenuName, MenuNo: this.props.menu.MenuNo }}
                          config={config}
                          tabs={this.state.tabviews}
                          menuformRef={this.menuformRef}
                          pasteContent={this.state.pasteContent}
                          usefulFields={this.props.permFuncField}
                          setSubConfig={(_btn) => this.setSubConfig(_btn, 'button')}
                          updateaction={this.updateaction}
                        />
                        <ColumnComponent
                          config={config}
                          menu={this.props.menu}
                          sysRoles={this.props.sysRoles}
                          pasteContent={this.state.pasteContent}
                          updatecolumn={this.updateconfig}
                        />
                      </Col>
                    )
                  } else {
                    return (
                      <Col span={item.width} key={item.uuid}>
                        <ChartComponent
                          plot={item}
                          config={config}
                          plotchange={this.updateconfig}
                        />
                      </Col>
                    )
                  }
                })}
              </div>
              {/* 标签组 */}
              <TabsComponent
                type="main"
                menu={{ MenuID: this.props.menu.MenuID, MenuName: this.props.menu.MenuName, MenuNo: this.props.menu.MenuNo }}
                config={config}
                tabs={this.state.tabviews}
                menuformRef={this.menuformRef}
                pasteContent={this.state.pasteContent}
                usefulFields={this.props.permFuncField}
                setSubConfig={(_btn) => this.setSubConfig(_btn, 'button')}
                updateaction={this.updateaction}
                setSubConfig={(item) => this.setSubConfig(item, 'tab')}
                updatetabs={this.updatetabs}
              />
              {/* 显示列 */}
              <ColumnComponent
                config={config}
                menu={this.props.menu}
                sysRoles={this.props.sysRoles}
                pasteContent={this.state.pasteContent}
                updatecolumn={this.updateconfig}
              />
              {/* 标签组 */}
              {config.tabgroups.map((groupId, index) => {
                return (
                  <div key={index} className="tab-list">
                    {index === 0 ? <Tooltip placement="bottomLeft" overlayClassName="middle" title="在左侧工具栏《标签页》中，选择对应类型的标签页拖至此处添加。">
                      <Icon type="question-circle" />
                    </Tooltip> : null}
                    {index !== (config.tabgroups.length - 1) ?
                      <Icon type="arrow-down" onClick={() => {this.handleGroup(index, 'down')}} /> : null
                    }
                    {index !== 0 ? <Icon type="arrow-up" onClick={() => {this.handleGroup(index, 'up')}} /> : null}
                    {index === 0 ? <Icon type="plus" onClick={this.addTabGroup} /> : null}
                    {index !== 0 ? <Icon type="delete" onClick={() => {this.delTabGroup(groupId)}} /> : null}
                    <TabDragElement
                      type="tabs"
                      groupId={groupId}
                      list={config[groupId]}
                      handleList={this.handleList}
                      handleMenu={this.handleTab}
                      deleteMenu={this.deleteElement}
                      doubleClickCard={(tab) => this.setSubConfig(tab, 'tab')}
                      placeholder={this.state.dict['header.form.tab.placeholder']}
                    />
                  </div>)
              })}
            </Card>
          </div>
        </DndProvider>
        {/* 标签编辑 */}
        <Modal
          title={this.state.dict['header.modal.tabs.edit']}
          visible={modaltype === 'tabs'}
          width={750}
          maskClosable={false}
          onOk={this.handleSubmit}
          onCancel={this.editModalCancel}
          destroyOnClose
        >
          <TabForm
            type="tabs"
            dict={this.state.dict}
            card={this.state.card}
            tabs={this.state.tabviews}
            formlist={this.state.formlist}
            inputSubmit={this.handleSubmit}
            wrappedComponentRef={(inst) => this.tabsFormRef = inst}
          />
        </Modal>
        {/* 返回时未保存提示 */}
        <Modal
          bodyStyle={{textAlign: 'center', color: '#000000', fontSize: '16px'}}