~jinfei/pc-plat.git

			@@ -4,68 +4,65 @@
			import { is, fromJS } from 'immutable'
			import { DndProvider } from 'react-dnd'
			import HTML5Backend from 'react-dnd-html5-backend'
			import { Button, Card, Modal, Collapse, notification, Spin, Select, List, Icon, Empty, 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'
			import ActionForm from './actionform'
			import SettingForm from './settingform'
			import SearchForm from '@/templates/tableshare/searchform'
			import ColumnForm from '@/templates/tableshare/columnform'
			import DragElement from '@/templates/tableshare/dragelement'
			import ColspanForm from '@/templates/tableshare/colspanform'
			import GridBtnForm from '@/templates/tableshare/gridbtnform'
			import EditCard from '@/templates/tableshare/editcard'
			import MenuForm from '@/templates/tableshare/menuform'
			import SourceElement from '@/templates/tableshare/dragelement/source'
			import zhCN from '@/locales/zh-CN/comtable.js'
			import enUS from '@/locales/en-US/comtable.js'
			import zhCN from '@/locales/zh-CN/model.js'
			import enUS from '@/locales/en-US/model.js'
			import Utils from '@/utils/utils.js'
			import { updateSubTable } from '@/utils/utils-update.js'

			import asyncComponent from '@/utils/asyncComponent'
			import SearchComponent from '@/templates/sharecomponent/searchcomponent'
			import ActionComponent from '@/templates/sharecomponent/actioncomponent'
			import ColumnComponent from '@/templates/sharecomponent/columncomponent'

			import MenuForm from './menuform'
			import SourceElement from '@/templates/zshare/dragsource'
			import Source from './source'
			import './index.scss'

			const { Panel } = Collapse
			const { Option } = Select
			const { confirm } = Modal
			const CommonDict = (!localStorage.getItem('lang') \|\| localStorage.getItem('lang') === 'zh-CN') ? zhCN : enUS

			const EditComponent = asyncComponent(() => import('@/templates/zshare/editcomponent'))
			const SettingComponent = asyncComponent(() => import('@/templates/sharecomponent/settingcomponent'))
			const TableComponent = asyncComponent(() => import('@/templates/sharecomponent/tablecomponent'))
			const FieldsComponent = asyncComponent(() => import('@/templates/sharecomponent/fieldscomponent'))
			const ChartGroupComponent = asyncComponent(() => import('@/templates/sharecomponent/chartgroupcomponent'))
			const ChartComponent = asyncComponent(() => import('@/templates/sharecomponent/chartcomponent'))
			const CardComponent = asyncComponent(() => import('@/templates/sharecomponent/cardcomponent'))

			class SubTableConfig extends Component {
			static propTpyes = {
			config: PropTypes.object,
			menu: PropTypes.any,
			handleConfig: PropTypes.func,
			handleSubConfig: PropTypes.func,
			supMenuList: PropTypes.array
			editTab: PropTypes.any,
			tabConfig: PropTypes.any,
			editSubTab: PropTypes.any,
			btnTab: PropTypes.any,
			btnTabConfig: PropTypes.any,
			config: PropTypes.any,
			handleView: PropTypes.func
			}

			state = {
			dict: CommonDict, // 字典
			dict: sessionStorage.getItem('lang') !== 'en-US' ? zhCN : enUS, // 字典
			config: null, // 页面配置
			visible: false, // 搜索条件、按钮、显示列，模态框显示控制
			modalTitle: '', // 模态框的标题
			tableVisible: false, // 数据表字段模态框
			addType: '', // 添加类型-搜索条件或显示列
			tableColumns: [], // 表格显示列
			fields: null, // 搜索条件及显示列，可选字段
			menuformlist: null, // 基本信息表单字段
			formlist: null, // 搜索条件、按钮、显示列表单字段
			formtemp: '', // 表单类型，显示列、按钮、搜索条件
			card: null, // 编辑元素
			searchloading: false, // 搜索条件加载中
			actionloading: false, // 按钮加载中
			columnsloading: false, // 显示列加载中
			menuloading: false, // 菜单保存中
			menucloseloading: false, // 菜单关闭时，选择保存
			loading: false, // 加载中，页面spin
			settingVisible: false, // 全局配置模态框
			closeVisible: false, // 关闭模态框
			tables: [], // 可用表名
			selectedTables: [], // 已选表名
			originConfig: null, // 原配置
			originActions: null, // 原始按钮信息，使用已有用户模板
			delActions: [], // 删除按钮列表
			funcLoading: false, // 存储过程创建中
			showColumnName: false, // 显示列字段名控制
			tabviews: [] // 所有标签页
			copyActions: [], // 复制按钮组
			tabviews: [], // 所有标签页
			thawButtons: [], // 已选择要解冻的按钮
			activeKey: '0', // 默认展开基本信息
			chartview: null, // 当前视图
			openEdition: '' // 编辑版本标记，防止多人操作
			}

			/**
			@@ -74,70 +71,54 @@
			* 2、设置操作类型、原始菜单信息（每次保存后重置）、已使用表及基本信息表单
			*/
			UNSAFE_componentWillMount () {
			const { config } = this.props
			const { config, editTab, editSubTab } = this.props

			let _config = null

			if (!config \|\| config.create) {
			_config = JSON.parse(JSON.stringify(Source.baseConfig))
			if (config.uuid) {
			_config.uuid = config.uuid
			_config.tabName = config.label
			}
			if (!config) {
			_config = fromJS(Source.baseConfig).toJS()
			_config.uuid = editSubTab ? editSubTab.linkTab : editTab.linkTab
			_config.tabName = editSubTab ? editSubTab.label : editTab.label
			_config.isAdd = true
			} else {
			_config = JSON.parse(JSON.stringify(config))
			_config = fromJS(config).toJS()
			}

			let _oriActions = []

			if (_config.type === 'user') {
			_config.action = _config.action.map(item => {
			let uuid = Utils.getuuid()

			if (item.linkTab) {
			item.linkTab = ''
			}

			if (item.OpenType === 'pop') { // 含有子配置项的按钮
			_oriActions.push({
			prebtn: JSON.parse(JSON.stringify(item)),
			prebtn: fromJS(item).toJS(),
			curuuid: uuid,
			Template: 'Modal'
			})
			}

			item.uuid = uuid

			return item
			})
			}

			let _activeKey = editSubTab ? editSubTab.activeKey : editTab.activeKey

			// 版本兼容
			_config = updateSubTable(_config)

			this.setState({
			openEdition: editSubTab ? (editSubTab.open_edition \|\| '') : (editTab.open_edition \|\| ''),
			chartview: _config.charts[0].uuid,
			originActions: _oriActions,
			config: _config,
			originConfig: _config,
			selectedTables: _config.tables \|\| [],
			menuformlist: [
			{
			type: 'text',
			key: 'tabName',
			label: this.state.dict['header.menu.tabName'],
			initVal: _config.tabName,
			required: true,
			readonly: false
			},
			{
			type: 'text',
			key: 'tabNo',
			label: this.state.dict['header.menu.menuNo'],
			initVal: _config.tabNo,
			required: true,
			readonly: false
			},
			{
			type: 'text',
			key: 'Remark',
			label: this.state.dict['header.menu.Remark'],
			initVal: _config.Remark,
			required: false,
			readonly: false
			}
			]
			activeKey: _activeKey \|\| '0',
			originConfig: fromJS(_config).toJS(),
			})
			}

			@@ -147,110 +128,54 @@
			* 2、根据配置信息中已使用表获取相关字段信息
			*/
			componentDidMount () {
			let param = {
			func: 'sPC_Get_SelectedList',
			LText: 'select TbName ,Remark from sDataDictionary where IsKey!=\'\' and Deleted =0',
			obj_name: 'data',
			arr_field: 'TbName,Remark'
			}
			this.reloadTab(false)
			}

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

			Api.getSystemConfig(param).then(res => {
			/**
			* @description 加载或刷新标签信息
			*/
			reloadTab = (type) => {
			this.setState({
			loading: type,
			tabviews: []
			})
			Api.getSystemConfig({func: 'sPC_Get_UserTemp', TypeCharTwo: 'tab'}).then(res => {
			if (res.status) {
			this.setState({
			tables: res.data
			let _tabviews = []
			res.UserTemp.forEach(temp => {
			let item = {
			uuid: temp.MenuID,
			value: temp.MenuID,
			text: temp.MenuName,
			type: temp.Template,
			MenuNo: temp.MenuNo
			}

			if (this.props.config && temp.MenuID === this.props.config.uuid) return

			_tabviews.push(item)
			})

			this.setState({
			loading: false,
			tabviews: _tabviews
			})

			if (type) {
			notification.success({
			top: 92,
			message: '刷新成功。',
			duration: 2
			})
			}
			} else {
			this.setState({
			loading: false
			})
			notification.warning({
			top: 92,
			message: res.message,
			duration: 10
			})
			}
			})

			let deffers = this.state.selectedTables.map(item => {
			return new Promise(resolve => {
			Api.getSystemConfig({func: 'sPC_Get_FieldName', TBName: item.TbName}).then(res => {
			res.TBName = item.TbName
			resolve(res)
			})
			})
			})
			Promise.all(deffers).then(response => {
			let _columns = []
			response.forEach(res => {
			if (res.status) {
			let tabmsg = {
			tableName: res.TBName,
			columns: res.FDName.map(item => {
			let _type = item.FieldType.toLowerCase()
			let _decimal = 0
			if (/^nvarchar/.test(_type)) {
			_type = 'text'
			} else if (/^int/.test(_type)) {
			_type = 'number'
			} else if (/^decimal/.test(_type)) {
			_decimal = _type.split(',')[1]
			_decimal = parseInt(_decimal)
			if (_decimal > 4) {
			_decimal = 4
			}
			_type = 'number'
			} else if (/^decimal/.test(_type)) {
			_decimal = _type.split(',')[1]
			_decimal = parseInt(_decimal)
			if (_decimal > 4) {
			_decimal = 4
			}
			_type = 'number'
			} else if (/^datetime/.test(_type)) {
			_type = 'datetime'
			} else if (/^date/.test(_type)) {
			_type = 'date'
			} else {
			_type = 'text'
			}

			return {
			field: item.FieldName,
			label: item.FieldDec,
			type: _type,
			datatype: _type,
			decimal: _decimal
			}
			})
			}
			_columns.push(tabmsg)
			} else {
			notification.warning({
			top: 92,
			message: res.message,
			duration: 10
			})
			}
			})

			this.setState({
			tableColumns: _columns
			})
			})

			Api.getSystemConfig({func: 'sPC_Get_UserTemp', TypeCharTwo: 'tab'}).then(res => {
			if (res.status) {
			this.setState({
			tabviews: res.UserTemp.map(temp => {
			return {
			uuid: temp.MenuID,
			value: temp.MenuID,
			text: temp.MenuName,
			type: temp.Template,
			MenuNo: temp.MenuNo
			}
			})
			duration: 5
			})
			}
			})
			@@ -260,1494 +185,296 @@
			* @description 组件销毁，清除state更新
			*/
			componentWillUnmount () {
			this.setState = (state, callback) => {
			this.setState = () => {
			return
			}
			}

			handleList = (type, list, card) => {
			const { config } = this.state
			// 页面返回
			handleViewBack = () => {
			const {menu, editTab, tabConfig, editSubTab, btnTab, btnTabConfig} = this.props
			let _tabview = menu ? menu.LongParam.Template : ''
			let _subconfig = null

			if (list.length > config[type].length) {
			list = list.filter(item => !item.origin)

			this.setState({
			[type + 'loading']: true,
			config: {...config, [type]: list }
			}, () => {
			// 刷新对应的配置信息
			this.setState({
			[type + 'loading']: false
			})

			if (type === 'search') {
			this.handleSearch(card)
			} else if (type === 'action') {
			this.handleAction(card)
			} else if (type === 'columns') {
			this.handleColumn(card)
			}
			})
			} else {
			this.setState({config: {...config, [type]: list}})
			}
			}

			handleSearch = (card) => {
			this.setState({
			visible: true,
			formtemp: 'search',
			modalTitle: '编辑-搜索条件',
			card: card,
			formlist: [
			{
			type: 'text',
			key: 'label',
			label: this.state.dict['header.form.name'],
			initVal: card.label,
			required: true,
			readonly: false
			},
			{
			type: 'text',
			key: 'field',
			label: this.state.dict['header.form.field'],
			initVal: card.field,
			tooltip: '字段名可以使用逗号分隔，进行多字段综合搜索，注：综合搜索仅在文本类型时有效',
			tooltipClass: 'middle',
			required: true,
			rules: [{
			pattern: /^[\u4E00-\u9FA50-9a-zA-Z,_]*$/ig,
			message: '字段名只允许包含数字、字母、汉字以及_'
			}, {
			max: 50,
			message: '字段名最多50个字符！'
			}],
			readonly: false
			},
			{
			type: 'select',
			key: 'type',
			label: this.state.dict['header.form.type'],
			initVal: card.type,
			required: true,
			options: [{
			value: 'text',
			text: this.state.dict['header.form.text']
			}, {
			value: 'select',
			text: this.state.dict['header.form.select']
			}, {
			value: 'multiselect',
			text: this.state.dict['header.form.multiselect']
			}, {
			value: 'link',
			text: this.state.dict['header.form.link']
			}, {
			value: 'date',
			text: this.state.dict['header.form.dateday']
			}, {
			value: 'dateweek',
			text: this.state.dict['header.form.dateweek']
			}, {
			value: 'datemonth',
			text: this.state.dict['header.form.datemonth']
			}, {
			value: 'daterange',
			text: this.state.dict['header.form.daterange']
			}]
			},
			{
			type: 'text',
			key: 'initval',
			label: this.state.dict['header.form.initval'],
			initVal: card.initval,
			required: false
			},
			{
			type: 'radio',
			key: 'resourceType',
			label: this.state.dict['header.form.resourceType'],
			initVal: card.resourceType \|\| '0',
			required: true,
			options: [{
			value: '0',
			text: this.state.dict['header.form.custom']
			}, {
			value: '1',
			text: this.state.dict['header.form.datasource']
			}]
			},
			{
			type: 'radio',
			key: 'setAll',
			label: this.state.dict['header.form.setAll'],
			initVal: card.setAll \|\| 'false',
			options: [{
			value: 'true',
			text: this.state.dict['header.form.true']
			}, {
			value: 'false',
			text: this.state.dict['header.form.false']
			}]
			},
			{
			type: 'textarea',
			key: 'dataSource',
			label: this.state.dict['header.form.datasource'],
			initVal: card.dataSource \|\| '',
			required: true,
			readonly: false
			},
			{
			type: 'options',
			key: 'options',
			label: '',
			initVal: card.options \|\| [],
			required: true,
			readonly: false
			},
			{
			type: 'text',
			key: 'linkField',
			label: this.state.dict['header.form.linkField'],
			initVal: card.linkField \|\| '',
			required: true,
			readonly: false
			},
			{
			type: 'text',
			key: 'valueField',
			label: this.state.dict['header.form.valueField'],
			initVal: card.valueField \|\| '',
			required: true,
			readonly: false
			},
			{
			type: 'text',
			key: 'valueText',
			label: this.state.dict['header.form.valueText'],
			initVal: card.valueText \|\| '',
			required: true,
			readonly: false
			},
			{
			type: 'text',
			key: 'orderBy',
			label: this.state.dict['header.form.orderBy'],
			initVal: card.orderBy \|\| '',
			required: false,
			readonly: false
			},
			{
			type: 'select',
			key: 'orderType',
			label: this.state.dict['header.form.orderType'],
			initVal: card.orderType \|\| 'asc',
			options: [{
			value: 'asc',
			text: this.state.dict['header.form.asc']
			}, {
			value: 'desc',
			text: this.state.dict['header.form.desc']
			}]
			},
			{
			type: 'select',
			key: 'match',
			label: this.state.dict['header.form.match'],
			initVal: card.match \|\| 'like',
			required: true,
			options: [{
			value: 'like',
			text: 'like'
			}, {
			value: 'equal',
			text: 'equal'
			}, {
			value: 'greater',
			text: '>'
			}, {
			value: 'less',
			text: '<'
			}, {
			value: 'greaterequal',
			text: '>='
			}]
			},
			{
			type: 'select',
			key: 'display',
			label: this.state.dict['header.form.display'],
			initVal: card.display \|\| 'dropdown',
			required: true,
			options: [{
			value: 'dropdown',
			text: this.state.dict['header.form.dropdown']
			}, {
			value: 'button',
			text: this.state.dict['header.form.button']
			}]
			}
			]
			})
			}

			handleAction = (card, type) => {
			let ableField = this.props.permFuncField.join(', ')
			this.setState({
			visible: true,
			formtemp: 'action',
			modalTitle: type === 'copy' ? '复制-按钮' : '编辑-按钮',
			card: card,
			formlist: [
			{
			type: 'text',
			key: 'label',
			label: this.state.dict['header.form.name'],
			initVal: card.label,
			required: true,
			readonly: false
			},
			{
			type: 'select',
			key: 'OpenType',
			label: this.state.dict['header.form.openType'],
			initVal: card.OpenType,
			required: true,
			options: [{
			value: 'pop',
			text: this.state.dict['header.form.popform']
			}, {
			value: 'prompt',
			text: this.state.dict['header.form.prompt']
			}, {
			value: 'exec',
			text: this.state.dict['header.form.exec']
			}, {
			value: 'excelIn',
			text: this.state.dict['header.form.excelIn']
			}, {
			value: 'excelOut',
			text: this.state.dict['header.form.excelOut']
			}, {
			value: 'popview',
			text: this.state.dict['header.form.popview']
			}]
			}, {
			type: 'select',
			key: 'tabType',
			label: this.state.dict['header.form.tabType'],
			initVal: card.tabType \|\| 'SubTable',
			required: true,
			options: [{
			value: 'SubTable',
			text: this.state.dict['header.menu.tab.subtable']
			}]
			},
			{
			type: 'select',
			key: 'linkTab',
			label: '关联标签',
			initVal: card.linkTab \|\| '',
			required: false,
			options: []
			},
			{
			type: 'radio',
			key: 'intertype',
			label: this.state.dict['header.form.intertype'],
			initVal: card.intertype,
			required: true,
			options: [{
			value: 'inner',
			text: this.state.dict['header.form.interface.inner']
			}, {
			value: 'outer',
			text: this.state.dict['header.form.interface.outer']
			}]
			},
			{
			type: 'text',
			key: 'innerFunc',
			label: this.state.dict['header.form.innerFunc'],
			initVal: card.innerFunc,
			tooltip: <div>
			<p>内部接口: 可自定义数据处理函数，函数名称需以{ableField}等字符开始；未设置时会调用系统函数，使用系统函数需完善数据源及操作类型;</p>
			<p>外部接口: 可自定义数据处理函数，提交数据经过内部函数处理后，传入外部接口，未设置时，数据会直接传入外部接口。</p>
			</div>,
			fields: this.props.permFuncField,
			tooltipClass: 'middle',
			required: false,
			readonly: false
			},
			{
			type: 'text',
			key: 'interface',
			label: this.state.dict['header.form.interface'],
			initVal: card.interface,
			required: true,
			readonly: false
			},
			{
			type: 'text',
			key: 'outerFunc',
			label: this.state.dict['header.form.outerFunc'],
			initVal: card.outerFunc,
			required: false,
			readonly: false
			},
			{
			type: 'text',
			key: 'callbackFunc',
			label: this.state.dict['header.form.callbackFunc'],
			initVal: card.callbackFunc,
			required: false,
			readonly: false
			},
			{
			type: 'select',
			key: 'position',
			label: this.state.dict['header.form.position'],
			initVal: card.position \|\| 'toolbar',
			required: true,
			options: [{
			value: 'toolbar',
			text: this.state.dict['header.form.toolbar']
			}, {
			value: 'grid',
			text: this.state.dict['header.form.grid']
			}]
			},
			{
			type: 'select',
			key: 'Ot',
			label: this.state.dict['header.form.isRequired'],
			initVal: card.Ot \|\| 'requiredSgl',
			required: true,
			options: []
			},
			{
			type: 'select',
			key: 'execSuccess',
			label: this.state.dict['header.form.execSuccess'],
			initVal: card.execSuccess \|\| 'never',
			required: true,
			options: [{
			value: 'never',
			text: this.state.dict['header.form.refresh.never']
			}, {
			value: 'grid',
			text: this.state.dict['header.form.refresh.grid']
			}, {
			value: 'view',
			text: this.state.dict['header.form.refresh.view']
			}]
			},
			{
			type: 'select',
			key: 'execError',
			label: this.state.dict['header.form.execError'],
			initVal: card.execError \|\| 'never',
			required: true,
			options: [{
			value: 'never',
			text: this.state.dict['header.form.refresh.never']
			}, {
			value: 'grid',
			text: this.state.dict['header.form.refresh.grid']
			}, {
			value: 'view',
			text: this.state.dict['header.form.refresh.view']
			}]
			},
			{
			type: 'select',
			key: 'popClose',
			label: this.state.dict['header.form.popClose'],
			initVal: card.popClose \|\| 'never',
			required: true,
			options: [{
			value: 'never',
			text: this.state.dict['header.form.refresh.never']
			}, {
			value: 'maingrid',
			text: this.state.dict['header.form.refresh.maingrid']
			}, {
			value: 'subgrid',
			text: this.state.dict['header.form.refresh.subgrid']
			}]
			},
			// {
			// type: 'select',
			// key: 'errorTip',
			// label: this.state.dict['header.form.messageTip'],
			// initVal: card.errorTip \|\| 'E',
			// tooltip: '该选项为提示效果展示，选择提示类型后，可点击按钮查看，自定义函数中设置 ErrCode 为（S、-1、E、N、F、NM）时，会以对应方式展示提示信息。',
			// tooltipClass: 'middle',
			// required: false,
			// options: [{
			// value: 'S',
			// text: 'S(提醒框-0)'
			// }, {
			// value: '-1',
			// text: '-1(不提示)'
			// }, {
			// value: 'N',
			// text: 'N(提醒框-1)'
			// }, {
			// value: 'F',
			// text: 'F(提醒框-2)'
			// }, {
			// value: 'E',
			// text: 'E(确认框)'
			// }, {
			// value: 'NM',
			// text: 'NM(顶部提示)'
			// }]
			// },
			// {
			// type: 'number',
			// key: 'errorTime',
			// label: this.state.dict['header.form.errorTime'],
			// initVal: card.errorTime \|\| 15,
			// tooltip: '执行结果中设置 ErrCode 为 N 或 F 时有效',
			// required: false
			// },
			{
			type: 'select',
			key: 'icon',
			label: this.state.dict['header.form.icon'],
			initVal: card.icon,
			required: false,
			options: []
			},
			{
			type: 'select',
			key: 'class',
			label: this.state.dict['header.form.class'],
			initVal: card.class,
			required: false,
			options: []
			},
			{
			type: 'text',
			key: 'sql',
			label: this.state.dict['header.form.datasource'],
			initVal: card.sql \|\| this.state.config.setting.tableName \|\| '',
			tooltip: this.state.dict['header.form.actionhelp.datasource'],
			required: false
			},
			{
			type: 'select',
			key: 'sqlType',
			label: this.state.dict['header.form.action.type'],
			initVal: card.sqlType \|\| '',
			tooltip: this.state.dict['header.form.actionhelp.sqlType'],
			required: false,
			options: []
			}
			]
			})
			}

			handleColumn = (card) => {
			if (card.type !== 'colspan') {
			this.setState({
			visible: true,
			formtemp: 'columns',
			modalTitle: '编辑-显示列',
			card: card,
			formlist: [
			{
			type: 'text',
			key: 'label',
			label: this.state.dict['header.form.name'],
			initVal: card.label,
			required: true
			},
			{
			type: 'text',
			key: 'field',
			label: this.state.dict['header.form.field'],
			initVal: card.field,
			required: true,
			rules: [{
			pattern: /^[\u4E00-\u9FA50-9a-zA-Z_]*$/ig,
			message: '字段名只允许包含数字、字母、汉字以及_'
			}, {
			max: 50,
			message: '字段名最多50个字符！'
			}],
			readonly: false
			},
			{
			type: 'select',
			key: 'type',
			label: this.state.dict['header.form.type'],
			initVal: card.type,
			required: true,
			options: [{
			value: 'text',
			text: this.state.dict['header.form.text']
			}, {
			value: 'picture',
			text: this.state.dict['header.form.picture']
			}, {
			value: 'number',
			text: this.state.dict['header.form.number']
			}, {
			value: 'textarea',
			text: this.state.dict['header.form.textarea']
			}]
			},
			{
			type: 'select',
			key: 'Align',
			label: this.state.dict['header.form.align'],
			initVal: card.Align,
			required: true,
			options: [{
			value: 'left',
			text: this.state.dict['header.form.alignLeft']
			}, {
			value: 'right',
			text: this.state.dict['header.form.alignRight']
			}, {
			value: 'center',
			text: this.state.dict['header.form.alignCenter']
			}]
			},
			{
			type: 'radio',
			key: 'Hide',
			label: this.state.dict['header.form.Hide'],
			initVal: card.Hide,
			required: true,
			options: [{
			value: 'true',
			text: this.state.dict['header.form.true']
			}, {
			value: 'false',
			text: this.state.dict['header.form.false']
			}]
			},
			{
			type: 'radio',
			key: 'IsSort',
			label: this.state.dict['header.form.IsSort'],
			initVal: card.IsSort,
			required: true,
			options: [{
			value: 'true',
			text: this.state.dict['header.form.true']
			}, {
			value: 'false',
			text: this.state.dict['header.form.false']
			}]
			},
			{
			type: 'number',
			key: 'Width',
			min: 1,
			max: 1000,
			decimal: 0,
			label: this.state.dict['header.form.columnWidth'],
			initVal: card.Width,
			required: true
			},
			{
			type: 'number',
			key: 'decimal',
			min: 0,
			max: 18,
			decimal: 0,
			label: this.state.dict['header.form.decimal'],
			initVal: card.decimal,
			required: false
			},
			{
			type: 'select',
			key: 'format',
			label: this.state.dict['header.form.format'],
			initVal: card.format \|\| '',
			options: [{
			value: '',
			text: this.state.dict['header.form.empty']
			}, {
			value: 'thdSeparator',
			text: this.state.dict['header.form.thdSeparator']
			}],
			required: false
			},
			{
			type: 'text',
			key: 'prefix',
			label: this.state.dict['header.form.prefix'],
			initVal: card.prefix \|\| '',
			required: false,
			readonly: false
			},
			{
			type: 'text',
			key: 'postfix',
			label: this.state.dict['header.form.postfix'],
			initVal: card.postfix \|\| '',
			// tooltip: '后缀值设置为"\\n",表示换行',
			tooltipClass: 'middle',
			required: false,
			readonly: false
			},
			{
			type: 'select',
			key: 'match',
			label: this.state.dict['header.form.match'],
			initVal: card.match \|\| '',
			options: [{
			value: '',
			text: this.state.dict['header.form.empty']
			}, {
			value: '>',
			text: '>'
			}, {
			value: '<',
			text: '<'
			}, {
			value: '>=',
			text: '>='
			}, {
			value: '<=',
			text: '<='
			}],
			required: false
			},
			{
			type: 'text',
			key: 'matchVal',
			min: -Infinity,
			max: Infinity,
			decimal: 0,
			label: this.state.dict['header.form.matchVal'],
			initVal: card.matchVal \|\| '',
			required: false,
			readonly: false
			},
			{
			type: 'select',
			key: 'color',
			label: this.state.dict['header.form.color'],
			initVal: card.color \|\| '',
			options: [{
			value: '',
			text: this.state.dict['header.form.empty']
			}, {
			value: 'red',
			text: '红色（内容）'
			}, {
			value: 'redbg',
			text: '红色（背景）'
			}, {
			value: 'orange',
			text: '橙色（内容）'
			}, {
			value: 'orangebg',
			text: '橙色（背景）'
			}, {
			value: 'green',
			text: '绿色（内容）'
			}, {
			value: 'greenbg',
			text: '绿色（背景）'
			}],
			required: false
			}
			]
			})
			} else {
			this.setState({
			visible: true,
			formtemp: 'columns',
			card: card
			})
			}
			}

			handleGridBtn = () => {
			this.setState({
			visible: true,
			formtemp: 'gridbtn',
			modalTitle: '编辑-操作列',
			})
			}

			/**
			* @description 搜索、按钮、显示列修改后提交保存
			* 1、搜索条件保存，当类型为下拉框且存在数据源时，将查询条件拼接为sql，并用base64转码
			* 2、按钮包括正常编辑和复制，复制时,按钮列末尾添加
			* 3、添加或编辑列，保存时，如按钮位置设置为表格，则修改操作列显示状态
			*/
			handleSubmit = () => {
			const { card } = this.state
			let _config = JSON.parse(JSON.stringify(this.state.config))

			if (this.state.formtemp !== 'gridbtn') {
			this.formRef.handleConfirm().then(res => {
			let isupdate = false

			if (res.type === 'action' && card.originCard && res.values.OpenType === 'pop') {
			Api.getSystemConfig({
			func: 'sPC_Get_LongParam',
			MenuID: card.originCard.uuid
			}).then(result => {
			if (result.status && result.LongParam) {
			let param = {
			func: 'sPC_ButtonParam_AddUpt',
			ParentID: _config.uuid,
			MenuID: res.values.uuid,
			MenuNo: _config.tabNo,
			Template: 'Modal',
			MenuName: res.values.label,
			PageParam: JSON.stringify({Template: 'Modal'}),
			LongParam: result.LongParam
			}
			Api.getSystemConfig(param).then(response => {
			if (!response.status) {
			notification.warning({
			top: 92,
			message: response.message,
			duration: 10
			})
			}
			})
			}
			})
			}

			_config[res.type] = _config[res.type].map(item => {
			if (item.uuid === res.values.uuid) {
			isupdate = true
			return res.values
			} else {
			return item
			}
			})
			_config[res.type] = _config[res.type].filter(item => !item.origin)

			if (!isupdate) { // 操作不是修改，添加元素至列表
			_config[res.type].push(res.values)
			}

			if (res.type === 'action') {
			let gridbtn = _config.action.filter(act => act.position === 'grid')
			let _display = false

			if (gridbtn.length > 0) {
			_display = true
			}

			if (_config.gridBtn) {
			_config.gridBtn.display = _display
			} else {
			_config.gridBtn = {
			display: _display,
			Align: 'center',
			IsSort: 'false',
			uuid: Utils.getuuid(),
			label: this.state.dict['header.form.column.action'],
			type: 'action',
			style: 'button',
			show: 'horizontal',
			Width: 120
			}
			}
			}

			this.setState({
			config: _config,
			searchloading: true,
			actionloading: true,
			columnsloading: true,
			visible: false
			}, () => {
			this.setState({
			searchloading: false,
			actionloading: false,
			columnsloading: false,
			})
			})
			})
			} else {
			this.formRef.handleConfirm().then(res => {
			_config.gridBtn = res

			this.setState({
			config: _config,
			visible: false
			})
			})
			}
			}

			/**
			* @description 创建按钮存储过程
			*/
			creatFunc = () => {
			let _config = JSON.parse(JSON.stringify(this.state.config))

			this.formRef.handleConfirm().then(res => {
			let btn = res.values // 按钮信息
			let newLText = '' // 创建存储过程sql
			let DelText = '' // 删除存储过程sql
			let isExit = false // 存储过程是否存在
			let sysTVPText = '' // 已有的存储过程语句(云端)
			let localTVPText = '' // 已有的存储过程语句(本地)

			// 创建存储过程，必须填写内部函数名
			if (!btn.innerFunc) {
			notification.warning({
			top: 92,
			message: '请填写内部函数！',
			duration: 10
			})
			return
			if (editSubTab) {
			_subconfig = tabConfig
			if (editTab.hasOwnProperty('OpenType')) {
			_tabview = editTab.tabType \|\| 'SubTable'
			} else {
			_tabview = editTab.type
			}
			} else if (!editSubTab && btnTab) {
			_tabview = btnTab.tabTemplate
			_subconfig = btnTabConfig
			}

			// 创建中
			this.setState({
			funcLoading: true
			})
			let param = {
			editMenu: menu,
			editTab: editSubTab ? editTab : null,
			tabConfig: null,
			editSubTab: null,
			subTabConfig: null,
			btnTab: btnTab,
			btnTabConfig: btnTabConfig,
			editAction: null,
			subConfig: _subconfig,
			tabview: _tabview
			}

			new Promise(resolve => {
			// 弹窗（表单）类按钮，先获取按钮配置信息，如果尚未配置按钮则会报错并终止。
			// 获取信息后生成删除和创建存储过程的语句
			if (btn.OpenType === 'pop') {
			Api.getSystemConfig({
			func: 'sPC_Get_LongParam',
			MenuID: btn.uuid
			}).then(res => {
			let _LongParam = ''
			if (res.status && res.LongParam) {
			_LongParam = window.decodeURIComponent(window.atob(res.LongParam))
			try {
			_LongParam = JSON.parse(_LongParam)
			} catch (e) {
			_LongParam = ''
			}
			}

			if (_LongParam) {
			let fields = []
			if (_LongParam.groups.length > 0) {
			_LongParam.groups.forEach(group => {
			fields = [...fields, ...group.sublist]
			})
			} else {
			fields = _LongParam.fields
			}

			let _param = {
			funcName: btn.innerFunc,
			name: _config.setting.tableName \|\| '',
			fields: fields,
			menuNo: _config.tabNo
			}
			newLText = Utils.formatOptions(Utils.getfunc(_param, btn, {MenuID: _config.uuid, MenuName: _config.tabName}, _config))
			DelText = Utils.formatOptions(Utils.dropfunc(_param.funcName))
			resolve(true)
			} else {
			resolve(false)
			notification.warning({
			top: 92,
			message: '弹窗（表单）按钮，请先配置表单信息！',
			duration: 10
			})
			}
			})
			} else {
			let _param = {
			funcName: btn.innerFunc,
			name: _config.setting.tableName \|\| '',
			fields: '',
			menuNo: _config.tabNo
			}
			newLText = Utils.formatOptions(Utils.getfunc(_param, btn, {MenuID: _config.uuid, MenuName: _config.tabName}, _config))
			DelText = Utils.formatOptions(Utils.dropfunc(_param.funcName))
			resolve(true)
			}
			}).then(res => {
			// 获取云端及本地，是否已存在该存储过程的信息
			if (res === false) return res

			let sysDefer = new Promise(resolve => {
			Api.getSystemConfig({
			func: 'sPC_Get_TVP', // 云端获取存储结果
			TVPName: btn.innerFunc
			}).then(result => {
			resolve(result)
			})
			})

			let localDefer = new Promise(resolve => {
			let _param = { // 获取本地存储过程信息
			func: 's_get_userproc',
			LText: btn.innerFunc
			}
			_param.timestamp = moment().format('YYYY-MM-DD HH:mm:ss') + '.000'
			_param.secretkey = Utils.encrypt(_param.LText, _param.timestamp)

			Api.getLocalConfig(_param).then(result => {
			resolve(result)
			})
			})

			return Promise.all([sysDefer, localDefer])
			}).then(res => {
			// 云端结果与新语句不同时，更新云端信息
			if (res === false) return res

			let isError = false

			res.forEach((result, index) => {
			if (!result.status) {
			notification.warning({
			top: 92,
			message: result.message,
			duration: 10
			})
			isError = true
			} else if (index === 0) {
			sysTVPText = result.TVPText
			} else {
			if (result.Ltext) { // 本地存储过程是否存在
			isExit = true
			}
			localTVPText = Utils.formatOptions(result.Ltext)
			}
			})

			if (isError) return false

			if ((newLText === localTVPText) && (newLText === sysTVPText)) {
			return 'drop'
			} else if (!localTVPText \|\| (localTVPText === sysTVPText)) {
			// 本地存储过程不存在，将新的存储过程更新至云端
			return Api.getSystemConfig({
			func: 'sPC_TVP_InUp',
			TVPName: btn.innerFunc,
			TVPText: newLText,
			TypeName: 'P'
			})
			} else {
			return new Promise(resolve => {
			Api.getSystemConfig({ // 添加现有的本地存储过程至云端
			func: 'sPC_TVP_InUp',
			TVPName: btn.innerFunc,
			TVPText: localTVPText,
			TypeName: 'P'
			}).then(result => {
			if (result.status) {
			Api.getSystemConfig({
			func: 'sPC_TVP_InUp', // 添加最新的存储过程至云端
			TVPName: btn.innerFunc,
			TVPText: newLText,
			TypeName: 'P'
			}).then(response => {
			resolve(response)
			})
			} else {
			resolve(result)
			}
			})
			})
			}
			}).then(res => {
			// 云端信息更新后，判断是删除或是直接新建存储过程
			if (res === false \|\| res === 'drop') return res

			if (!res.status) {
			notification.warning({
			top: 92,
			message: res.message,
			duration: 10
			})
			return false
			} else if (isExit) {
			return 'drop'
			} else {
			return 'create'
			}
			}).then(res => {
			// 删除存储过程
			if (res === false \|\| res === 'create') return res

			let _param = {
			func: 'sPC_TableData_InUpDe',
			LText: DelText,
			TypeCharOne: 'proc' // 删除或创建存储过程
			}

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

			return Api.getLocalConfig(_param)
			}).then(res => {
			// 根据上述操作结果，判断是否新建存储过程
			if (res === false \|\| res === 'create') return res

			if (!res.status) {
			notification.warning({
			top: 92,
			message: res.message,
			duration: 10
			})
			return false
			} else {
			return 'create'
			}
			}).then(res => {
			// 新建存储过程
			if (res === false) return res

			let _param = {
			func: 'sPC_TableData_InUpDe',
			LText: newLText,
			TypeCharOne: 'proc' // 删除或创建存储过程
			}
			_param.timestamp = moment().format('YYYY-MM-DD HH:mm:ss') + '.000'
			_param.secretkey = Utils.encrypt(_param.LText, _param.timestamp)

			return Api.getLocalConfig(_param)
			}).then(res => {
			// 处理新建结果
			if (res === false) return res

			if (!res.status) {
			notification.warning({
			top: 92,
			message: res.message,
			duration: 10
			})
			return false
			} else {
			notification.success({
			top: 92,
			message: '创建成功',
			duration: 2
			})
			return true
			}
			}).then(res => {
			// 新建成功后，更新页面按钮信息
			if (res === false) {
			this.setState({
			funcLoading: false
			})
			return
			}

			let isupdate = false
			_config.action = _config.action.map(item => {
			if (item.uuid === btn.uuid) {
			isupdate = true
			return btn
			} else {
			return item
			}
			})
			_config.action = _config.action.filter(item => !item.origin)


			if (!isupdate) { // 操作不是修改，添加元素至列表
			_config.action.push(btn)
			}

			let gridbtn = _config.action.filter(act => act.position === 'grid')
			let _display = false

			if (gridbtn.length > 0) {
			_display = true
			}

			if (_config.gridBtn) {
			_config.gridBtn.display = _display
			} else {
			_config.gridBtn = {
			display: _display,
			Align: 'center',
			IsSort: 'false',
			uuid: Utils.getuuid(),
			label: this.state.dict['header.form.column.action'],
			type: 'action',
			style: 'button',
			show: 'horizontal',
			Width: 120
			}
			}

			this.setState({
			config: _config,
			actionloading: true,
			funcLoading: false
			}, () => {
			this.setState({
			actionloading: false
			})
			})
			})
			})
			}

			/**
			* @description 创建表格存储过程
			*/
			tableCreatFunc = () => {
			let config = JSON.parse(JSON.stringify(this.state.config))

			this.settingRef.handleConfirm().then(res => {
			const setting = res
			if (!(setting.interType === 'inner') \|\| !setting.innerFunc) {
			notification.warning({
			top: 92,
			message: '接口类型为-内部，且存在内部函数时，才可以创建存储过程！',
			duration: 10
			})
			return
			this.state.copyActions.forEach(item => {
			let _param = {
			func: 'sPC_MainMenu_Del',
			MenuID: item
			}

			if (setting.dataresource.length > 50 && config.setting.dataresource !== setting.dataresource) {
			let param = {
			func: 's_DataSrc_Save',
			LText: setting.dataresource,
			MenuID: config.uuid
			}

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

			Api.getLocalConfig(param)
			}

			this.setState({
			funcLoading: true
			})

			let newLText = Utils.formatOptions(Utils.getTableFunc(setting, {MenuID: config.uuid, MenuName: config.tabName, MenuNo: config.tabNo}, config)) // 创建存储过程sql
			let DelText = Utils.formatOptions(Utils.dropfunc(setting.innerFunc)) // 删除存储过程sql

			new Promise(resolve => {
			let sysDefer = new Promise(resolve => {
			Api.getSystemConfig({
			func: 'sPC_Get_TVP', // 云端获取存储结果
			TVPName: setting.innerFunc
			}).then(result => {
			if (!result.status) {
			notification.warning({
			top: 92,
			message: result.message,
			duration: 10
			})
			resolve(false)
			} else {
			resolve(result)
			}
			})
			})

			let localDefer = new Promise(resolve => {
			let _param = { // 获取本地存储过程信息
			func: 's_get_userproc',
			LText: setting.innerFunc
			}
			_param.timestamp = moment().format('YYYY-MM-DD HH:mm:ss') + '.000'
			_param.secretkey = Utils.encrypt(_param.LText, _param.timestamp)

			Api.getLocalConfig(_param).then(result => {
			if (!result.status) {
			notification.warning({
			top: 92,
			message: result.message,
			duration: 10
			})
			resolve(false)
			} else {
			resolve(result)
			}
			})
			})

			Promise.all([sysDefer, localDefer]).then(result => {
			resolve(result)
			})
			}).then(res => {
			// 获取云端及本地，是否已存在该存储过程的信息
			if (res === false) return res
			if (res[0] === false \|\| res[1] === false) return false

			let cloudfunc = ''
			let localfunc = ''
			res.forEach((item, index) => {
			if (index === 0 && item.TVPText) {
			cloudfunc = item.TVPText
			} else if (index === 1 && item.Ltext) {
			localfunc = Utils.formatOptions(item.Ltext)
			}
			})

			if ((newLText === localfunc) && (newLText === cloudfunc)) {
			return 'drop'
			} else if (!localfunc \|\| (cloudfunc === localfunc)) {
			// 本地存储过程不存在，或云端和本地存储过程一致时，将新的存储过程更新至云端
			return Api.getSystemConfig({
			func: 'sPC_TVP_InUp',
			TVPName: setting.innerFunc,
			TVPText: newLText,
			TypeName: 'P'
			})
			} else {
			return new Promise(resolve => {
			Api.getSystemConfig({ // 添加现有的本地存储过程至云端
			func: 'sPC_TVP_InUp',
			TVPName: setting.innerFunc,
			TVPText: localfunc,
			TypeName: 'P'
			}).then(result => {
			if (result.status) {
			Api.getSystemConfig({
			func: 'sPC_TVP_InUp', // 添加最新的存储过程至云端
			TVPName: setting.innerFunc,
			TVPText: newLText,
			TypeName: 'P'
			}).then(response => {
			resolve(response)
			})
			} else {
			resolve(result)
			}
			})
			})
			}
			}).then(res => {
			// 云端信息更新后，判断是删除或是直接新建存储过程
			if (res === false \|\| res === 'drop') return res

			if (!res.status) {
			notification.warning({
			top: 92,
			message: res.message,
			duration: 10
			})
			return false
			} else {
			return 'create'
			}
			}).then(res => {
			// 删除存储过程
			if (res === false \|\| res === 'create') return res

			let _param = {
			func: 'sPC_TableData_InUpDe',
			LText: DelText,
			TypeCharOne: 'proc' // 删除或创建存储过程
			}

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

			return Api.getLocalConfig(_param)
			}).then(res => {
			// 根据上述操作结果，判断是否新建存储过程
			if (res === false \|\| res === 'create') return res

			if (!res.status) {
			notification.warning({
			top: 92,
			message: res.message,
			duration: 10
			})
			return false
			} else {
			return 'create'
			}
			}).then(res => {
			// 新建存储过程
			if (res === false) return res

			let _param = {
			func: 'sPC_TableData_InUpDe',
			LText: newLText,
			TypeCharOne: 'proc' // 删除或创建存储过程
			}
			_param.timestamp = moment().format('YYYY-MM-DD HH:mm:ss') + '.000'
			_param.secretkey = Utils.encrypt(_param.LText, _param.timestamp)

			return Api.getLocalConfig(_param)
			}).then(res => {
			// 处理新建结果
			if (res === false) return res

			if (!res.status) {
			notification.warning({
			top: 92,
			message: res.message,
			duration: 10
			})
			return false
			} else {
			notification.success({
			top: 92,
			message: '创建成功',
			duration: 2
			})
			return true
			}
			}).then(res => {
			// 新建成功后，更新页面按钮信息
			if (res === false) {
			this.setState({
			funcLoading: false
			})
			return
			}

			this.setState({
			config: {...config, setting: setting}
			})
			})
			Api.getSystemConfig(_param)
			})

			this.props.handleView(param)
			}

			deleteElement = (element) => {
			let _this = this
			confirm({
			content: `确定删除<<${element.card.label}>>吗？`,
			okText: this.state.dict['header.confirm'],
			cancelText: this.state.dict['header.cancel'],
			onOk() {
			let _config = JSON.parse(JSON.stringify(_this.state.config))
			_config[element.type] = _config[element.type].filter(item => {
			if (item.uuid === element.card.uuid) {
			return false
			} else {
			return true
			}
			})

			let refreshtype = element.type + 'loading'

			_this.setState({
			config: _config,
			delActions: [..._this.state.delActions, element.card.uuid],
			[refreshtype]: true
			}, () => {
			_this.setState({
			[refreshtype]: false
			})
			})
			},
			onCancel() {}
			})
			}

			// changeTemplate = () => {
			// this.props.handleConfig('template')
			// }

			/**
			* @description 标签页保存
			*/
			submitConfig = () => {
			let config = JSON.parse(JSON.stringify(this.state.config))
			const { delActions, thawButtons, openEdition } = this.state
			let _config = fromJS(this.state.config).toJS()
			let copyreg = /\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}$/ig

			this.menuformRef.handleConfirm().then(res => {
			// 基本信息验证
			if (!_config.tabName \|\| !_config.tabNo) {
			notification.warning({
			top: 92,
			message: this.state.dict['model.menu.basemsg'],
			duration: 5
			})
			this.setState({activeKey: '0'})
			return
			}

			if (config.search[0] && config.search[0].origin) {
			config.search = config.search.filter(item => !item.origin)
			if (copyreg.test(_config.tabNo) \|\| copyreg.test(_config.tabName)) {
			notification.warning({
			top: 92,
			message: '此标签为复制标签，请修改标签名称和标签参数，不可以时间格式 YYYY-MM-DD HH:mm:ss 结尾！',
			duration: 5
			})
			return
			}

			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.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.columns[0] && _config.columns[0].origin) {
			_config.columns = _config.columns.filter(item => !item.origin)
			}
			}

			let _LongParam = ''
			let _config = {...config, tables: this.state.selectedTables, ...res}
			// 未设置数据源或主键时，启用状态为false
			let result = this.verifyconfig(_config)

			if (result !== true) {
			_config.enabled = false
			}

			// 保存时删除配置类型，system 、user
			delete _config.type
			if (this.state.closeVisible) { // 显示关闭对话框时，模态框中保存按钮，显示保存中状态
			this.setState({
			menucloseloading: true
			})
			} else {
			this.setState({
			menuloading: true
			})
			}

			try {
			_LongParam = window.btoa(window.encodeURIComponent(JSON.stringify(_config)))
			} catch (e) {
			// 保存时删除配置类型，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 btnParam = {
			func: 'sPC_Button_AddUpt',
			Type: 40,
			ParentID: _config.uuid,
			MenuNo: _config.tabNo,
			Template: 'SubTable',
			PageParam: '',
			LongParam: '',
			LText: []
			}

			let btntabs = []

			_config.action.forEach((item, index) => {
			if (item.OpenType === 'popview') {
			btntabs.push(`select '${item.uuid}' as MenuID ,'${item.linkTab}' as Tabid,'${item.label}' as TabName ,'${(index + 1) * 10}' as Sort`)
			}
			btnParam.LText.push(`select '${item.uuid}' as menuid, '${item.label}' as menuname, '${(index + 1) * 10}' as Sort`)
			})

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

			let tabParam = { // 添加标签按钮tab页
			func: 'sPC_sMenusTab_AddUpt',
			MenuID: _config.uuid,
			LText: btntabs.join(' union all ')
			}

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

			let param = {
			func: 'sPC_Tab_AddUpt',
			MenuID: _config.uuid,
			MenuNo: _config.tabNo,
			Template: 'SubTable',
			MenuName: _config.tabName,
			Remark: _config.Remark,
			Sort: 0,
			PageParam: JSON.stringify({Template: 'SubTable'}),
			LongParam: _LongParam
			}

			if (openEdition) {
			param.open_edition = openEdition
			}

			// 有按钮或标签删除时，先进行删除操作
			// 删除成功后，保存页面配置
			new Promise(resolve => {
			if (delActions.length > 0) {
			let deffers = delActions.map(item => {
			let _param = {
			func: 'sPC_MainMenu_Del',
			MenuID: item.card.uuid
			}

			let _ParentParam = null

			try {
			_ParentParam = window.btoa(window.encodeURIComponent(JSON.stringify(item.card)))
			} catch (e) {
			console.warn('Stringify Failure')
			_ParentParam = null
			}

			if (_ParentParam) { // 删除按钮时，保存按钮配置信息，用于恢复按钮
			_param.ParentParam = _ParentParam
			}

			return new Promise(resolve => {
			Api.getSystemConfig(_param).then(response => {
			resolve(response)
			})
			})
			})
			Promise.all(deffers).then(result => {
			let error = null
			result.forEach(response => {
			if (!response.status) {
			error = response
			}
			})

			if (error) {
			this.setState({
			menuloading: false,
			menucloseloading: false
			})
			notification.warning({
			top: 92,
			message: error.message,
			duration: 5
			})
			resolve(false)
			} else {
			this.setState({
			delActions: []
			})
			resolve(true)
			}
			})
			} else if (delActions.length === 0) {
			resolve(true)
			}
			}).then(resp => {
			if (resp === false) return

			if (thawButtons.length > 0) {
			let defers = thawButtons.map(item => {
			return new Promise((resolve) => {
			Api.getSystemConfig({
			func: 'sPC_MainMenu_ReDel',
			MenuID: item
			}).then(res => {
			if (res.status) {
			resolve('')
			} else {
			resolve(res.message)
			}
			})
			})
			})

			return Promise.all(defers)
			} else {
			return true
			}
			}).then(res => {
			if (res === true \|\| res === false) return res

			let msg = res.filter(Boolean)[0]
			if (msg) {
			notification.warning({
			top: 92,
			message: '编译错误',
			duration: 10
			message: msg,
			duration: 5
			})
			return
			}

			let btnParam = {
			func: 'sPC_Button_AddUpt',
			ParentID: _config.uuid,
			MenuNo: res.tabNo,
			Template: 'SubTable',
			PageParam: '',
			LongParam: '',
			LText: config.action.map((item, index) => {
			return `select '${item.uuid}' as menuid, '${item.label}' as menuname, '${(index + 1) * 10}' as Sort`
			})
			}

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

			let param = {
			func: 'sPC_Tab_AddUpt',
			MenuID: _config.uuid,
			MenuNo: res.tabNo,
			Template: 'SubTable',
			MenuName: res.tabName,
			Remark: res.Remark,
			Sort: 0,
			PageParam: JSON.stringify({Template: 'SubTable'}),
			LongParam: _LongParam
			}

			if (this.state.closeVisible) { // 显示关闭对话框时，模态框中保存按钮，显示保存中状态
			this.setState({
			menucloseloading: true
			})
			return false
			} else {
			this.setState({
			menuloading: true
			thawButtons: []
			})
			return true
			}
			}).then(resp => {
			if (resp === false) return

			Api.getSystemConfig(param).then(response => {
			if (response.status) {
			this.setState({
			openEdition: response.open_edition \|\| '',
			config: _config,
			originConfig: _config,
			searchloading: true,
			actionloading: true,
			columnsloading: true
			originConfig: fromJS(_config).toJS()
			}, () => {
			this.setState({
			searchloading: false,
			actionloading: false,
			columnsloading: false
			}, () => {

			this.setState({
			menuloading: false,
			menucloseloading: false
			})
			menuloading: false,
			menucloseloading: false
			})
			this.submitAction(btnParam)
			this.submitAction(btnParam, tabParam)
			})
			} else {
			this.setState({
			@@ -1757,15 +484,9 @@
			notification.warning({
			top: 92,
			message: response.message,
			duration: 10
			duration: 5
			})
			}
			})
			}, () => {
			notification.warning({
			top: 92,
			message: this.state.dict['header.menu.basemsg'],
			duration: 10
			})
			})
			}
			@@ -1773,22 +494,38 @@
			/**
			* @description 保存或修改菜单按钮
			*/
			submitAction = (param) => {
			submitAction = (btnParam, tabParam) => {
			const { config } = this.state

			new Promise(resolve => {
			// 内部请求
			if (this.state.delActions.length > 0) {
			let deffers = this.state.delActions.map(item => {
			let _param = {
			func: 'sPC_MainMenu_Del',
			MenuID: item
			}
			return new Promise(resolve => {
			Api.getSystemConfig(_param).then(res => {
			resolve(res)
			})
			let deffers = []

			if (tabParam.LText) {
			let defer = new Promise(resolve => {
			Api.getSystemConfig(tabParam).then(result => {
			resolve(result)
			})
			})
			deffers.push(defer)
			}

			if (btnParam.LText) {
			let defer = new Promise(resolve => {
			Api.getSystemConfig(btnParam).then(result => {
			if (result.status) {
			this.setState({ // 保存成功后清空复制列表
			copyActions: []
			})
			}
			resolve(result)
			})
			})
			deffers.push(defer)
			}

			if (deffers.length === 0) {
			resolve(true)
			} else {
			Promise.all(deffers).then(result => {
			let error = false
			result.forEach(res => {
			@@ -1801,39 +538,13 @@
			notification.warning({
			top: 92,
			message: error.message,
			duration: 10
			duration: 5
			})
			resolve(false)
			} else {
			this.setState({
			delActions: []
			})
			resolve(param)
			resolve(true)
			}
			})
			} else if (this.state.delActions.length === 0) {
			resolve(param)
			}
			}).then(res => {
			if (res === false) return res

			if (res.LText) {
			return Api.getSystemConfig(res)
			} else {
			return 'copy'
			}
			}).then(response => {
			if (response === false \|\| response === 'copy') return response

			if (response.status) {
			return 'copy'
			} else {
			notification.warning({
			top: 92,
			message: response.message,
			duration: 10
			})
			return false
			}
			}).then(response => {
			if (response === false) return response
			@@ -1843,6 +554,7 @@
			let curBtn = config.action.filter(cell => item.curuuid === cell.uuid)[0] // 查看初始化按钮是否存在
			if (!curBtn) return
			if (curBtn.OpenType !== item.prebtn.OpenType) return
			if (curBtn.OpenType === 'funcbutton' && curBtn.execMode !== 'pop') return

			oriActions.push({
			prebtn: item.prebtn,
			@@ -1861,10 +573,10 @@
			let _LongParam = ''

			if (result.LongParam) {
			_LongParam = window.decodeURIComponent(window.atob(result.LongParam))
			try {
			_LongParam = JSON.parse(_LongParam)
			_LongParam = JSON.parse(window.decodeURIComponent(window.atob(result.LongParam)))
			} catch (e) {
			console.warn('Parse Failure')
			_LongParam = ''
			}
			}
			@@ -1894,8 +606,7 @@
			duration: 2
			})
			if (this.state.closeVisible) {
			let view = this.props.menu ? this.props.menu.type : ''
			this.props.handleConfig(view)
			this.handleViewBack()
			} else {
			this.setState({
			menuloading: false,
			@@ -1915,512 +626,321 @@
			const { config, originConfig } = this.state

			let _this = this
			let isAdd = false

			if (
			(config.search[0] && config.search[0].origin) \|\|
			(config.action[0] && config.action[0].origin) \|\|
			(config.columns[0] && config.columns[0].origin)
			) {
			isAdd = true
			}

			if (isAdd) {
			if (originConfig.isAdd) {
			confirm({
			content: '菜单尚未提交，确定放弃保存吗？',
			okText: this.state.dict['header.confirm'],
			cancelText: this.state.dict['header.cancel'],
			onOk() {
			let view = _this.props.menu ? _this.props.menu.type : ''
			_this.props.handleConfig(view)
			_this.handleViewBack()
			},
			onCancel() {}
			})
			} else {
			this.menuformRef.handleConfirm().then(res => {
			let _config = {...config, tables: this.state.selectedTables, ...res}

			if (!is(fromJS(originConfig), fromJS(_config))) {
			this.setState({
			closeVisible: true
			})
			} else {
			let view = this.props.menu ? this.props.menu.type : ''
			this.props.handleConfig(view)
			}
			}, () => {
			if (!is(fromJS(originConfig), fromJS(config))) {
			this.setState({
			closeVisible: true
			})
			})
			}
			}

			queryField = (type) => {
			const {selectedTables, tableColumns, config} = this.state
			// 判断是否已选择表名
			if (selectedTables.length === 0) {
			notification.warning({
			top: 92,
			message: '请选择表名！',
			duration: 10
			})
			return
			}

			// 表字段集转为map数据
			let columns = new Map()
			tableColumns.forEach(table => {
			table.columns.forEach(column => {
			columns.set(column.field, column)
			})
			})

			if (type === 'search') {
			// 添加搜索条件，字段集中存在搜索条件字段，使用搜索条件对象替换字段集，设置数据类型
			config.search.forEach(item => {
			if (columns.has(item.field)) {
			let _datatype = columns.get(item.field).datatype
			columns.set(item.field, {...item, selected: true, datatype: _datatype})
			}
			})
			} else if (type === 'columns') {
			// 添加显示列，字段集中存在显示列字段，使用显示列对象替换字段集，设置数据类型
			config.columns.forEach(item => {
			if (columns.has(item.field)) {
			let _datatype = columns.get(item.field).datatype
			columns.set(item.field, {...item, selected: true, datatype: _datatype})
			}
			})
			}

			// 显示字段集弹窗
			this.setState({
			addType: type,
			tableVisible: true,
			fields: [...columns.values()]
			})
			}

			addFieldSubmit = () => {
			// 字段集为空，关闭弹窗
			if (!this.state.fields \|\| this.state.fields.length === 0) {
			this.setState({
			tableVisible: false,
			addType: ''
			})
			}

			const {addType, config} = this.state
			const textmatch = { // 选择text时匹配规则
			text: 'like',
			number: 'like',
			datetime: 'like',
			date: 'like'
			}
			const selectmatch = { // 选择select时匹配规则
			text: '=',
			number: '=',
			datetime: '=',
			date: '='
			}
			const datematch = { // 选择dateRange时匹配规则
			text: 'between',
			number: 'between',
			datetime: 'between',
			date: 'between'
			}

			// 获取已选字段集合
			let cards = this.refs.searchcard.state.selectCards
			let columnsMap = new Map()
			cards.forEach(card => {
			columnsMap.set(card.field, card)
			})

			let items = []
			if (addType === 'search') {
			config.search.forEach(item => {
			if (columnsMap.has(item.field)) {
			let cell = columnsMap.get(item.field)

			if (cell.selected && cell.type === item.type) { // 数据未修改
			items.push(item)
			} else if (cell.selected) { // 数据类型修改
			if (cell.type === 'text') {
			item.match = textmatch[cell.datatype]
			} else if (cell.type === 'select') {
			item.match = selectmatch[cell.datatype]
			} else if (cell.type === 'daterange') {
			item.match = datematch[cell.datatype]
			} else {
			cell.type = 'text'
			item.match = textmatch[cell.datatype]
			}

			item.type = cell.type
			item.initval = ''
			items.push(item)
			}
			columnsMap.delete(item.field)
			} else if (!item.origin) {
			items.push(item)
			}
			})

			let _columns = [...columnsMap.values()]

			_columns.forEach(item => {
			if (item.selected) {
			let _match = ''
			if (item.type === 'text') {
			_match = textmatch[item.datatype]
			} else if (item.type === 'select') {
			_match = selectmatch[item.datatype]
			} else if (item.type === 'daterange') {
			_match = datematch[item.datatype]
			} else {
			item.type = 'text'
			_match = textmatch[item.datatype]
			}

			let newcard = {
			uuid: Utils.getuuid(),
			label: item.label,
			field: item.field,
			initval: '',
			type: item.type,
			resourceType: '0',
			setAll: 'false',
			options: [],
			dataSource: '',
			linkField: '',
			valueField: '',
			valueText: '',
			orderBy: '',
			orderType: 'asc',
			match: _match,
			display: 'dropdown'
			}

			items.push(newcard)
			}
			})
			} else {
			config.columns.forEach(item => {
			if (columnsMap.has(item.field)) {
			let cell = columnsMap.get(item.field)

			if (cell.selected) {
			items.push(item)
			}
			columnsMap.delete(item.field)
			} else if (!item.origin) {
			items.push(item)
			}
			})

			let _columns = [...columnsMap.values()]

			_columns.forEach(item => {
			if (item.selected) {
			let newcard = {
			uuid: Utils.getuuid(),
			Align: 'left',
			label: item.label,
			field: item.field,
			Hide: 'false',
			IsSort: item.type === 'picture' ? 'false' : 'true',
			type: item.type,
			Width: 120
			}

			items.push(newcard)
			}
			})
			}

			this.setState({
			[addType + 'loading']: true,
			config: {...config, [addType]: items}
			}, () => {
			notification.success({
			top: 92,
			message: '操作成功',
			duration: 2
			})
			this.setState({
			[addType + 'loading']: false
			})
			})
			}

			onTableChange = (value) => {
			const {tables, selectedTables, tableColumns} = this.state

			let _table = tables.filter(item => item.TbName === value)[0]
			let isSelected = !!selectedTables.filter(cell => cell.TbName === value)[0]
			if (!isSelected) {
			this.setState({
			selectedTables: [...selectedTables, _table]
			})
			Api.getSystemConfig({func: 'sPC_Get_FieldName', TBName: value}).then(res => {
			if (res.status) {
			let tabmsg = {
			tableName: _table.name,
			columns: res.FDName.map(item => {
			let _type = item.FieldType.toLowerCase()
			let _decimal = 0
			if (/^nvarchar/.test(_type)) {
			_type = 'text'
			} else if (/^int/.test(_type)) {
			_type = 'number'
			} else if (/^decimal/.test(_type)) {
			_decimal = _type.split(',')[1]
			_decimal = parseInt(_decimal)
			_type = 'number'
			} else if (/^datetime/.test(_type)) {
			_type = 'datetime'
			} else if (/^date/.test(_type)) {
			_type = 'date'
			} else {
			_type = 'text'
			}

			return {
			field: item.FieldName,
			label: item.FieldDec,
			type: _type,
			datatype: _type,
			decimal: _decimal
			}
			})
			}
			this.setState({
			tableColumns: [...tableColumns, tabmsg]
			})
			} else {
			notification.warning({
			top: 92,
			message: res.message,
			duration: 10
			})
			}
			})
			}
			}

			deleteTable = (table) => {
			const {selectedTables, tableColumns} = this.state

			this.setState({
			selectedTables: selectedTables.filter(item => item.TbName !== table.TbName),
			tableColumns: tableColumns.filter(item => item.tableName !== table.TbName)
			})
			}

			changeSetting = () => {
			this.setState({
			settingVisible: true
			})
			}

			settingSave = () => {
			const { config } = this.state

			this.settingRef.handleConfirm().then(res => {
			if (
			res.interType === 'inner' &&
			!res.innerFunc &&
			res.dataresource.length > 50 &&
			config.setting.dataresource !== res.dataresource
			) {
			let param = {
			func: 's_DataSrc_Save',
			LText: res.dataresource,
			MenuID: config.uuid
			}

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

			Api.getLocalConfig(param)
			} else {
			this.handleViewBack()
			}

			this.setState({
			config: {...config, setting: res},
			settingVisible: false,
			columnsloading: true
			}, () => {
			this.setState({
			columnsloading: false
			})
			})
			})
			}
			}

			/**
			* @description 设置可配置按钮
			*/
			setSubConfig = (btn) => {
			const { config, originConfig } = this.state
			const {menu, editTab, tabConfig, editSubTab, btnTab, btnTabConfig} = this.props
			const { config, originConfig, activeKey, openEdition } = this.state

			let isAdd = false

			if (
			(config.search[0] && config.search[0].origin) \|\|
			(config.action[0] && config.action[0].origin) \|\|
			(config.columns[0] && config.columns[0].origin)
			) {
			isAdd = true
			}

			if (isAdd) {
			if (originConfig.isAdd) {
			notification.warning({
			top: 92,
			message: '菜单尚未保存，请保存菜单配置！',
			duration: 10
			duration: 5
			})
			} else {
			this.menuformRef.handleConfirm().then(res => {
			let _config = {...config, tables: this.state.selectedTables, ...res}

			if (!is(fromJS(originConfig), fromJS(_config))) {
			notification.warning({
			top: 92,
			message: '菜单配置已修改，请保存！',
			duration: 10
			})
			} else {
			this.setState({
			loading: true
			})
			Api.getSystemConfig({
			func: 'sPC_Get_LongParam',
			MenuID: btn.uuid
			}).then(res => {
			if (res.status) {
			this.setState({
			loading: false
			})
			let _LongParam = ''
			if (res.LongParam) {
			_LongParam = window.decodeURIComponent(window.atob(res.LongParam))
			try {
			_LongParam = JSON.parse(_LongParam)
			} catch (e) {
			_LongParam = ''
			}
			}
			this.props.handleSubConfig(btn, config, _LongParam, 'tabButton')
			} else {
			this.setState({
			loading: false
			})
			notification.warning({
			top: 92,
			message: res.message,
			duration: 10
			})
			}
			})
			}
			}, () => {
			if (!is(fromJS(originConfig), fromJS(config))) {
			notification.warning({
			top: 92,
			message: '菜单基本信息已修改，请保存！',
			duration: 10
			message: '菜单配置已修改，请保存！',
			duration: 5
			})
			})
			} else {
			// 子菜单信息验证通过后，跳转子按钮配置页面
			let _view = ''
			let _subtab = editSubTab

			if (btn.OpenType === 'pop' \|\| btn.execMode === 'pop') {
			_view = 'Modal' // 表单页面
			} else if (btn.OpenType === 'popview') {
			_view = 'SubTable' // 新弹窗标签模板 tabType 属性已去除
			_subtab = btn

			if (editSubTab) {
			notification.warning({
			top: 92,
			message: '弹窗(标签)中不支持此按钮打开方式！',
			duration: 5
			})
			return
			}
			}

			if (editSubTab) {
			editSubTab.activeKey = activeKey
			editSubTab.open_edition = openEdition // 更新版本号
			} else {
			editTab.activeKey = activeKey
			editTab.open_edition = openEdition // 更新版本号
			}

			let param = {
			editMenu: menu,
			editTab: editTab,
			tabConfig: editSubTab ? tabConfig : originConfig,
			editSubTab: _subtab,
			subTabConfig: editSubTab ? originConfig : null,
			btnTab: btnTab,
			btnTabConfig: btnTabConfig,
			editAction: btn,
			subConfig: '',
			tabview: _view
			}

			this.setState({
			loading: true
			})

			Api.getSystemConfig({
			func: 'sPC_Get_LongParam',
			MenuID: btn.OpenType === 'popview' ? btn.linkTab : btn.uuid
			}).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 === 'Modal' && _LongParam.type === 'Modal') {
			param.subConfig = _LongParam
			} else if (_LongParam && param.tabview === 'SubTable' && _LongParam.Template === 'SubTable') {
			param.subConfig = _LongParam
			}

			if (param.editAction) {
			param.editAction.open_edition = res.open_edition \|\| ''
			} else if (param.editSubTab) {
			param.editSubTab.open_edition = res.open_edition \|\| ''
			}

			this.props.handleView(param)
			} else {
			this.setState({
			loading: false
			})
			notification.warning({
			top: 92,
			message: res.message,
			duration: 5
			})
			}
			})
			}
			}
			}

			/**
			* @description 切换标签是否启用
			*/
			onEnabledChange = () => {
			const { config } = this.state

			if (config.setting.interType === 'inner' && !config.setting.innerFunc && !config.setting.dataresource) {
			let _enabled = !config.enabled
			let result = this.verifyconfig(config)

			if (_enabled && result !== true) {
			notification.warning({
			top: 92,
			message: '菜单尚未设置数据源，不可启用！',
			duration: 10
			message: result,
			duration: 5
			})
			} else {
			this.setState({
			config: {...config, enabled: !config.enabled}
			})
			return
			}
			}

			onColumnNameChange = () => {
			const { showColumnName } = this.state

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

			dontsave = () => {
			let view = this.props.menu ? this.props.menu.type : ''
			this.props.handleConfig(view)
			/**
			* @description 校验配置信息的合法性
			*/
			verifyconfig = (config) => {
			let hasKey = false
			let chartcols = []
			config.columns.forEach(col => {
			if (col.field) {
			chartcols.push(col.field)
			}
			if (config.setting.primaryKey === col.field) {
			hasKey = true
			}
			})

			let chartError = ''
			config.charts && config.charts.forEach((chart, index) => {
			if (chartError) return
			if (chart.Hide === 'true') return
			if (!['line', 'bar', 'pie'].includes(chart.chartType)) return

			if (!chart.Xaxis) {
			chartError = `图表${chart.title ? '《' + chart.title + '》' : index + 1}坐标轴字段尚未设置，不可启用！`
			} else if (['line', 'bar'].includes(chart.chartType) && chart.datatype !== 'statistics' && (!chart.Yaxis \|\| chart.Yaxis.length === 0)) { // query 查询数据
			chartError = `图表${chart.title ? '《' + chart.title + '》' : index + 1}坐标轴字段尚未设置，不可启用！`
			} else if (['line', 'bar'].includes(chart.chartType) && chart.datatype === 'statistics' && (!chart.InfoType \|\| !chart.InfoValue)) { // statistics 统计数据
			chartError = `图表${chart.title ? '《' + chart.title + '》' : index + 1}坐标轴字段尚未设置，不可启用！`
			} else if (chart.chartType === 'pie' && !chart.Yaxis) {
			chartError = `图表${chart.title ? '《' + chart.title + '》' : index + 1}坐标轴字段尚未设置，不可启用！`
			} else if (!chartcols.includes(chart.Xaxis)) {
			chartError = `图表${chart.title ? '《' + chart.title + '》' : index + 1}坐标轴字段在显示列中不存在，不可启用！`
			} else if (chart.chartType === 'pie' && !chartcols.includes(chart.Yaxis)) {
			chartError = `图表${chart.title ? '《' + chart.title + '》' : index + 1}坐标轴字段在显示列中不存在，不可启用！`
			} else if (['line', 'bar'].includes(chart.chartType) && chart.datatype === 'statistics' && (!chartcols.includes(chart.InfoType) \|\| !chartcols.includes(chart.InfoValue))) { // statistics 统计数据
			chartError = `图表${chart.title ? '《' + chart.title + '》' : index + 1}坐标轴字段在显示列中不存在，不可启用！`
			} else if (['line', 'bar'].includes(chart.chartType) && chart.datatype !== 'statistics' && chart.Yaxis.filter(yaxis => !chartcols.includes(yaxis)).length > 0) {
			chartError = `图表${chart.title ? '《' + chart.title + '》' : index + 1}坐标轴字段在显示列中不存在，不可启用！`
			}
			})

			config.action && config.action.forEach((btn) => {
			if (['prompt', 'exec', 'pop'].includes(btn.OpenType) && btn.Ot === 'required' && btn.verify && btn.verify.scripts && btn.verify.scripts.length > 0) {
			let hascheck = false
			btn.verify.scripts.forEach(item => {
			if (item.status === 'false') return

			if (/\$check@\|@check\$/ig.test(item.sql)) {
			hascheck = true
			}
			})
			if (hascheck) {
			notification.warning({
			top: 92,
			message: `可选择多行的按钮《${btn.label}》中 $check@ 或 @check$ 将不会生效！`,
			duration: 5
			})
			}
			}
			})

			if ((config.setting.interType === 'system' \|\| config.setting.requestMode === 'system') && config.setting.default === 'false' && config.setting.scripts && config.setting.scripts.filter(item => item.status !== 'false').length === 0) {
			return '数据源中不执行默认sql，且未添加自定义脚本，不可启用！'
			} else if (config.setting.interType === 'custom' && config.setting.procMode !== 'inner' && config.setting.preScripts && config.setting.preScripts.filter(item => item.status !== 'false').length === 0) {
			return '数据源未设置前置脚本，不可启用！'
			} else if (config.setting.interType === 'custom' && config.setting.callbackType === 'script' && config.setting.cbScripts && config.setting.cbScripts.filter(item => item.status !== 'false').length === 0) {
			return '数据源未设置回调脚本，不可启用！'
			} else if (!config.setting.primaryKey) {
			return '尚未设置主键，不可启用！'
			} else if (config.columns.length === 0) {
			return '尚未设置显示列，不可启用！'
			} else if (!hasKey) {
			return '显示列中不存在主键字段，不可启用！'
			} else if (chartError) {
			return chartError
			} else {
			return true
			}
			}

			/**
			* @description 编辑功能完成更新，包括解冻按钮、粘贴、替换等
			*/
			updateConfig = (res) => {
			if (res.type === 'thaw') {
			this.setState({
			thawButtons: res.thawButtons,
			config: res.config
			})
			} else if (res.type === 'paste') {
			this.setState({config: res.config})
			}
			}

			/**
			* @description 更新搜索条件配置信息
			*/
			updatesearch = (config) => {

			this.setState({
			config: config
			})
			}

			/**
			* @description 更新按钮配置信息
			*/
			updateaction = (config, copyId, delcard) => {
			const { copyActions, delActions } = this.state

			this.setState({
			config: config,
			copyActions: copyId ? [...copyActions, copyId] : copyActions,
			delActions: delcard ? [...delActions, delcard] : delActions
			})
			}

			/**
			* @description 更新显示列配置信息
			*/
			updateconfig = (config) => {
			this.setState({
			config: config
			})
			}

			/**
			* @description 更新图表组配置信息
			*/
			updatechartgroup = (config, _chartview) => {
			this.setState({
			config: config,
			chartview: _chartview
			})
			}

			render () {
			const configAction = this.state.config.action.filter(_action =>
			!_action.origin && (_action.OpenType === 'pop' \|\| _action.OpenType === 'popview' \|\| _action.OpenType === 'blank' \|\| _action.OpenType === 'tab')
			)
			const { activeKey, config, chartview } = this.state

			const confActions = config.action.filter(_action => !_action.origin && (['pop', 'popview'].includes(_action.OpenType) \|\| (_action.OpenType === 'funcbutton' && _action.execMode === 'pop')))

			return (
			<div className="common-table-board">
			<div className="model-subtable-board">
			<DndProvider backend={HTML5Backend}>
			{/* 工具栏 */}
			<div className="tools">
			<Collapse accordion defaultActiveKey="0" bordered={false}>
			<Collapse accordion activeKey={activeKey} bordered={false} onChange={(key) => this.setState({activeKey: key})}>
			{/* 基本信息 */}
			<Panel header={'标签基本信息'} key="0" id="common-basedata">
			<Panel forceRender={true} header={'标签基本信息'} key="0" id="subtable-basedata">
			{/* 菜单信息 */}
			<MenuForm
			dict={this.state.dict}
			formlist={this.state.menuformlist}
			wrappedComponentRef={(inst) => this.menuformRef = inst}
			config={config}
			updatemenu={this.updateconfig}
			/>
			{/* 表名添加 */}
			<div className="ant-col ant-form-item-label">
			<label>
			<Tooltip placement="topLeft" title="此处可以添加配置相关的常用表，在添加搜索条件和显示列时，可通过工具栏中的添加按钮，批量添加表格相关字段。">
			<Icon type="question-circle" />
			{this.state.dict['header.menu.table.add']}
			</Tooltip>
			</label>
			</div>
			<Select
			showSearch
			className="tables"
			style={{ width: '100%' }}
			optionFilterProp="children"
			value={this.state.dict['header.menu.table.placeholder']}
			onChange={this.onTableChange}
			showArrow={false}
			getPopupContainer={() => document.getElementById('common-basedata')}
			filterOption={(input, option) => {
			return option.props.children.toLowerCase().indexOf(input.toLowerCase()) >= 0 \|\|
			option.props.value.toLowerCase().indexOf(input.toLowerCase()) >= 0
			}}
			>
			{this.state.tables.map((table, index) => (
			<Option key={index} value={table.TbName}>{table.Remark}</Option>
			))}
			</Select>
			{this.state.selectedTables.length > 0 && <List
			size="small"
			bordered
			dataSource={this.state.selectedTables}
			renderItem={(item, index) => <List.Item key={index} title={item.Remark + ' (' + item.TbName + ')'}>
			{item.Remark + ' (' + item.TbName + ')'}
			<Icon type="close" onClick={() => this.deleteTable(item)}/>
			<div className="bottom-mask"></div>
			</List.Item>}
			/>}
			<TableComponent
			config={config}
			containerId="subtable-basedata"
			updatetable={this.updateconfig}
			/>
			</Panel>
			{/* 搜索条件添加 */}
			<Panel header={this.state.dict['header.menu.search']} key="1">
			@@ -2429,7 +949,11 @@
			return (<SourceElement key={index} content={item}/>)
			})}
			</div>
			<Button type="primary" block onClick={() => this.queryField('search')}>{this.state.dict['header.menu.search.add']}</Button>
			<FieldsComponent
			config={config}
			type="search"
			updatefield={this.updateconfig}
			/>
			</Panel>
			{/* 按钮添加 */}
			<Panel header={this.state.dict['header.menu.action']} key="2">
			@@ -2438,15 +962,17 @@
			return (<SourceElement key={index} content={item}/>)
			})}
			</div>
			{configAction.length > 0 ?
			<p className="config-btn-title">
			<Tooltip placement="topLeft" title="点击按钮，可完成或查看按钮配置信息。">
			<Icon type="question-circle" />
			</Tooltip>
			{this.state.dict['header.menu.action.configurable']}
			</p> : null
			}
			{configAction.map((item, index) => {
			<div className="config-btn">
			{confActions.length > 0 ?
			<p className="config-btn-title">
			<Tooltip placement="topLeft" title="点击按钮，可完成或查看按钮配置信息。">
			<Icon type="question-circle" />
			</Tooltip>
			{this.state.dict['header.menu.action.configurable']}
			</p> : null
			}
			</div>
			{confActions.map((item, index) => {
			return (
			<div key={index}>
			<Button
			@@ -2466,189 +992,102 @@
			return (<SourceElement key={index} content={item}/>)
			})}
			</div>
			<Button type="primary" block onClick={() => this.queryField('columns')}>{this.state.dict['header.menu.column.add']}</Button>
			<FieldsComponent
			config={config}
			type="columns"
			updatefield={this.updateconfig}
			/>
			</Panel>
			</Collapse>
			</div>
			<div className="setting">
			<Card title={'标签（子表）页面配置'} bordered={false} extra={
			<Card title={
			<div>
			<Switch className="big" checkedChildren="启" unCheckedChildren="停" checked={this.state.config.enabled} onChange={this.onEnabledChange} />
			{/* <Button type="primary" onClick={this.changeTemplate}>{this.state.dict['header.menu.template.change']}</Button> */}
			<Button type="primary" onClick={this.submitConfig} loading={this.state.menuloading}>{this.state.dict['header.save']}</Button>
			<Button onClick={this.cancelConfig}>{this.state.dict['header.return']}</Button>
			标签（子表）页面配置
			<Icon type="redo" style={{marginLeft: '10px'}} title="刷新标签列表" onClick={() => this.reloadTab(true)} />
			</div>
			} bordered={false} extra={
			<div>
			<EditComponent dict={this.state.dict} options={['search', 'action', 'columns']} config={config} MenuID={config.uuid} thawButtons={this.state.thawButtons} refresh={this.updateConfig}/>
			<Switch className="big" checkedChildren="启" unCheckedChildren="停" checked={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%' }}>
			<Icon type="setting" onClick={this.changeSetting} />
			<div className="search-list">
			<Tooltip placement="bottomLeft" overlayClassName="middle" title="在左侧工具栏《搜索》中，选择对应搜索框拖至此处添加；或点击按钮《添加搜索条件》批量添加，选择批量添加时，需提前选择使用表。">
			<Icon type="question-circle" />
			</Tooltip>
			{!this.state.searchloading ?
			<DragElement
			type="search"
			list={this.state.config.search}
			handleList={this.handleList}
			handleMenu={this.handleSearch}
			deleteMenu={this.deleteElement}
			placeholder={this.state.dict['header.form.search.placeholder']}
			/> : null
			}
			</div>
			<div className="action-list">
			<Tooltip placement="bottomLeft" overlayClassName="middle" title="在左侧工具栏《按钮》中，选择对应类型的按钮拖至此处添加，如选择按钮类型为表单、新标签页等含有配置页面的按钮，可在左侧工具栏-按钮-可配置按钮处，点击按钮完成相关配置。注：当设置按钮显示位置为表格时，显示列会增加操作列。">
			<Icon type="question-circle" />
			</Tooltip>
			{!this.state.actionloading ?
			<DragElement
			type="action"
			list={this.state.config.action}
			handleList={this.handleList}
			handleMenu={this.handleAction}
			copyElement={(val) => this.handleAction(val, 'copy')}
			deleteMenu={this.deleteElement}
			placeholder={this.state.dict['header.form.action.placeholder']}
			/> : null
			}
			</div>
			<div className="column-list">
			<Tooltip placement="bottomLeft" overlayClassName="middle" title="在左侧工具栏《显示列》中，选择对应类型的显示列拖至此处添加；或点击《添加显示列》按钮批量添加，选择批量添加时，需提前选择使用表。注：添加合并列时，需设置可选列。">
			<Icon type="question-circle" />
			</Tooltip>
			<Switch checkedChildren="开" unCheckedChildren="关" defaultChecked={this.state.showColumnName} onChange={this.onColumnNameChange} />
			{!this.state.columnsloading ?
			<DragElement
			type="columns"
			list={this.state.config.columns}
			setting={this.state.config.setting}
			gridBtn={this.state.config.gridBtn}
			handleList={this.handleList}
			handleMenu={this.handleColumn}
			deleteMenu={this.deleteElement}
			handleGridBtn={this.handleGridBtn}
			showfield={this.state.showColumnName}
			placeholder={this.state.dict['header.form.column.placeholder']}
			/> : null
			}
			<SettingComponent
			config={config}
			mainsearch={!this.props.editSubTab && this.props.editTab.mainsearch ? this.props.editTab.mainsearch : ''}
			MenuID={config.uuid}
			updatesetting={this.updateconfig}
			/>
			<SearchComponent
			config={config}
			updatesearch={this.updatesearch}
			/>
			<div className="chart-view" style={{position: 'relative'}}>
			{/* 视图组权限会员等级20+ */}
			{this.props.memberLevel >= 20 ? <ChartGroupComponent
			config={config}
			updatechartgroup={this.updatechartgroup}
			/> : null}
			{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="subtable"
			menu={{MenuID: config.uuid, MenuName: config.tabName, MenuNo: config.tabNo, fstMenuList: this.props.menu.fstMenuList}}
			config={config}
			tabs={this.state.tabviews}
			setSubConfig={this.setSubConfig}
			updateaction={this.updateaction}
			/>
			<ColumnComponent
			config={config}
			menu={this.props.menu}
			updatecolumn={this.updateconfig}
			/>
			</Col>
			)
			} else if (item.chartType === 'card') {
			return (
			<Col span={item.width} key={item.uuid}>
			<CardComponent
			card={item}
			config={config}
			plotchange={this.updateconfig}
			/>
			</Col>
			)
			} else {
			return (
			<Col span={item.width} key={item.uuid}>
			<ChartComponent
			plot={item}
			config={config}
			plotchange={this.updateconfig}
			/>
			</Col>
			)
			}
			})}
			</div>
			</Card>
			</div>
			</DndProvider>
			{/* 编辑搜索条件、按钮、显示列 */}
			<Modal
			title={this.state.modalTitle}
			visible={this.state.visible}
			width={700}
			onCancel={() => { this.setState({ visible: false }) }}
			footer={[
			this.state.formtemp === 'action' ?
			<Button key="delete" className="mk-btn mk-purple" onClick={this.creatFunc} loading={this.state.funcLoading}>{this.state.dict['header.menu.func.create']}</Button> : null,
			<Button key="cancel" onClick={() => { this.setState({ visible: false }) }}>{this.state.dict['header.cancel']}</Button>,
			<Button key="confirm" type="primary" onClick={this.handleSubmit}>{this.state.dict['header.confirm']}</Button>
			]}
			destroyOnClose
			>
			{this.state.formtemp === 'search' ?
			<SearchForm
			dict={this.state.dict}
			formlist={this.state.formlist}
			card={this.state.card}
			wrappedComponentRef={(inst) => this.formRef = inst}
			/> : null
			}
			{this.state.formtemp === 'action' ?
			<ActionForm
			dict={this.state.dict}
			card={this.state.card}
			tabs={this.state.tabviews}
			formlist={this.state.formlist}
			wrappedComponentRef={(inst) => this.formRef = inst}
			/> : null
			}
			{this.state.formtemp === 'columns' && this.state.card.type !== 'colspan' ?
			<ColumnForm
			dict={this.state.dict}
			card={this.state.card}
			formlist={this.state.formlist}
			wrappedComponentRef={(inst) => this.formRef = inst}
			/> : null
			}
			{this.state.formtemp === 'columns' && this.state.card.type === 'colspan' ?
			<ColspanForm
			dict={this.state.dict}
			card={this.state.card}
			columns={this.state.config.columns}
			wrappedComponentRef={(inst) => this.formRef = inst}
			/> : null
			}
			{this.state.formtemp === 'gridbtn' ?
			<GridBtnForm
			dict={this.state.dict}
			card={this.state.config.gridBtn}
			wrappedComponentRef={(inst) => this.formRef = inst}
			/> : null
			}
			</Modal>
			{/* 根据字段名添加显示列及搜索条件 */}
			<Modal
			wrapClassName="common-table-fields-modal"
			title={this.state.dict['header.edit']}
			visible={this.state.tableVisible}
			width={'65vw'}
			style={{minWidth: '900px', maxWidth: '1200px'}}
			cancelText={this.state.dict['header.close']}
			onOk={this.addFieldSubmit}
			onCancel={() => { // 取消添加
			this.setState({
			tableVisible: false,
			addType: ''
			})
			}}
			destroyOnClose
			>
			{this.state.addType && this.state.fields.length > 0 ?
			<EditCard data={this.state.fields} ref="searchcard" type={this.state.addType} dict={this.state.dict} /> : null
			}
			{(!this.state.fields \|\| this.state.fields.length === 0) &&
			<Empty />
			}
			</Modal>
			{/* 设置全局配置及列表数据源 */}
			<Modal
			title={this.state.dict['header.edit']}
			visible={this.state.settingVisible}
			width={700}
			// onOk={this.settingSave}
			onCancel={() => { // 取消修改
			this.setState({
			settingVisible: false
			})
			}}
			footer={[
			<Button key="delete" className="mk-btn mk-purple" onClick={this.tableCreatFunc} loading={this.state.funcLoading}>{this.state.dict['header.menu.func.create']}</Button>,
			<Button key="cancel" onClick={() => { this.setState({ settingVisible: false }) }}>{this.state.dict['header.cancel']}</Button>,
			<Button key="confirm" type="primary" onClick={this.settingSave}>{this.state.dict['header.confirm']}</Button>
			]}
			destroyOnClose
			>
			<SettingForm
			dict={this.state.dict}
			tabId={this.state.config.uuid}
			data={this.state.config.setting}
			columns={this.state.config.columns}
			usefulFields={this.props.permFuncField}
			wrappedComponentRef={(inst) => this.settingRef = inst}
			/>
			</Modal>
			<Modal
			bodyStyle={{textAlign: 'center', color: '#000000', fontSize: '16px'}}
			closable={false}
			maskClosable={false}
			visible={this.state.closeVisible}
			onCancel={() => { this.setState({closeVisible: false}) }}
			footer={[
			<Button key="save" className="mk-btn mk-green" loading={this.state.menucloseloading} onClick={this.submitConfig}>{this.state.dict['header.save']}</Button>,
			<Button key="confirm" className="mk-btn mk-yellow" onClick={this.dontsave}>{this.state.dict['header.notsave']}</Button>,
			<Button key="cancel" onClick={() => { this.setState({closeVisible: false}) }}>{this.state.dict['header.cancel']}</Button>
			<Button key="save" className="mk-btn mk-green" loading={this.state.menucloseloading} onClick={this.submitConfig}>{this.state.dict['model.save']}</Button>,
			<Button key="confirm" className="mk-btn mk-yellow" onClick={this.handleViewBack}>{this.state.dict['model.notsave']}</Button>,
			<Button key="cancel" onClick={() => { this.setState({closeVisible: false}) }}>{this.state.dict['model.cancel']}</Button>
			]}
			destroyOnClose
			>
			@@ -2662,7 +1101,7 @@

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