import React, {Component} from 'react'
|
import PropTypes from 'prop-types'
|
import { connect } from 'react-redux'
|
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 moment from 'moment'
|
|
import Api from '@/api'
|
import Utils from '@/utils/utils.js'
|
import zhCN from '@/locales/zh-CN/comtable.js'
|
import enUS from '@/locales/en-US/comtable.js'
|
import { getSearchForm, getActionForm, getColumnForm } from '@/templates/tableshare/formconfig'
|
import { queryTableSql } from '@/utils/option.js'
|
|
import ActionForm from './actionform'
|
import SettingForm from './settingform'
|
import TabForm from '@/templates/tableshare/tabform'
|
import SearchForm from '@/templates/tableshare/searchform'
|
import ColumnForm from '@/templates/tableshare/columnform'
|
import PasteForm from '@/templates/tableshare/pasteform'
|
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 VerifyCard from '@/templates/tableshare/verifycard'
|
import VerifyCardExcelIn from '@/templates/tableshare/verifycardexcelin'
|
import VerifyCardExcelOut from '@/templates/tableshare/verifycardexcelout'
|
import VerifyCardPrint from '@/templates/tableshare/verifycardprint'
|
import MenuForm from '@/templates/tableshare/menuform'
|
import TabDragElement from '@/templates/tableshare/tabdragelement'
|
import TransferForm from '@/components/transferform'
|
import SourceElement from '@/templates/tableshare/dragelement/source'
|
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
|
|
class ComTableConfig extends Component {
|
static propTpyes = {
|
menu: PropTypes.any,
|
optionLibs: PropTypes.any,
|
supMenuList: PropTypes.array,
|
reloadmenu: PropTypes.func,
|
handleView: PropTypes.func
|
}
|
|
state = {
|
dict: CommonDict, // 字典
|
config: null, // 页面配置
|
tableVisible: false, // 数据表字段模态框
|
addType: '', // 添加类型-搜索条件或显示列
|
tableColumns: [], // 表格显示列
|
fields: null, // 搜索条件及显示列，可选字段
|
menuformlist: null, // 基本信息表单字段
|
formlist: null, // 搜索条件、按钮、显示列表单字段
|
modaltype: '', // 模态框类型，控制模态框显示
|
card: null, // 编辑元素
|
menuloading: false, // 菜单保存中
|
menucloseloading: false, // 菜单关闭时，选择保存
|
loading: false, // 加载中，页面spin
|
settingVisible: false, // 全局配置模态框
|
closeVisible: false, // 关闭模态框
|
tables: [], // 可用表名
|
selectedTables: [], // 已选表名
|
originMenu: null, // 原始菜单
|
originActions: null, // 原始按钮信息，使用已有用户模板
|
delActions: [], // 删除按钮列表
|
copyActions: [], // 复制按钮组
|
funcLoading: false, // 存储过程创建中
|
showColumnName: false, // 显示列字段名控制
|
tabviews: [], // 所有标签页
|
profileVisible: false, // 验证信息模态框
|
optionLibs: null, // 自定义下拉选项库
|
thawBtnVisible: false, // 解冻按钮弹窗
|
thawbtnlist: null, // 解冻按钮列表
|
thawButtons: [] // 已选择要解冻的按钮
|
}
|
|
/**
|
* @description 数据预处理
|
* 1、设置页面配置信息，新建或无配置信息时（切换模板后无配置信息），使用模板默认配置
|
* 2、设置操作类型、原始菜单信息（每次保存后重置）、已使用表及基本信息表单
|
*/
|
UNSAFE_componentWillMount () {
|
const { menu, optionLibs } = this.props
|
|
let _LongParam = menu.LongParam
|
let _config = ''
|
|
if (!_LongParam) {
|
_config = JSON.parse(JSON.stringify(Source.baseConfig))
|
if (!menu.isSubtable) { // 不是选择主子表时，隐藏标签页
|
_config.tabs = []
|
}
|
_config.isAdd = true
|
} else {
|
_config = _LongParam
|
_config.search.forEach(item => {
|
if (
|
(item.type === 'select' || item.type === 'multiselect' || item.type === 'link') &&
|
item.resourceType === '0' &&
|
item.options && item.options.length > 0
|
) {
|
optionLibs.set(menu.MenuID + item.uuid, {
|
uuid: menu.MenuID + item.uuid,
|
label: item.label,
|
parname: menu.MenuName,
|
type: 'search',
|
options: item.options
|
})
|
}
|
})
|
}
|
|
// 配置默认值，兼容
|
_config.tabs = _config.tabs || []
|
_config.tabgroups = _config.tabgroups || ['tabs']
|
_config.setting.subtabs = _config.setting.subtabs || []
|
_config.Template = 'CommonTable'
|
|
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)),
|
curuuid: uuid,
|
Template: 'Modal'
|
})
|
} else if (item.OpenType === 'tab' || item.OpenType === 'blank') { // 含有子配置项的按钮(标签后当前页打开)
|
_oriActions.push({
|
prebtn: JSON.parse(JSON.stringify(item)),
|
curuuid: uuid,
|
Template: item.tabTemplate
|
})
|
}
|
|
item.uuid = uuid
|
return item
|
})
|
|
// 重置标签ID
|
_config.tabgroups.forEach(group => {
|
_config[group] = _config[group].map(tab => {
|
tab.uuid = Utils.getuuid()
|
|
if (tab.linkTab) {
|
tab.linkTab = ''
|
}
|
|
return tab
|
})
|
})
|
}
|
|
this.setState({
|
config: _config,
|
optionLibs: optionLibs,
|
originActions: _oriActions,
|
originMenu: JSON.parse(JSON.stringify(menu)),
|
selectedTables: _config.tables || [],
|
menuformlist: [
|
// {
|
// type: 'select',
|
// key: 'firparentId',
|
// label: '一级菜单',
|
// initVal: menu.ParentID,
|
// required: true,
|
// readonly: false,
|
// options: this.props.supMenuList
|
// },
|
{
|
type: 'select',
|
key: 'parentId',
|
label: '二级菜单',
|
initVal: menu.ParentID,
|
required: true,
|
readonly: false,
|
options: this.props.supMenuList
|
},
|
{
|
type: 'text',
|
key: 'menuName',
|
label: this.state.dict['header.menu.menuName'],
|
initVal: menu.MenuName,
|
required: true,
|
readonly: false
|
},
|
{
|
type: 'text',
|
key: 'menuNo',
|
label: this.state.dict['header.menu.menuNo'],
|
initVal: menu.MenuNo,
|
required: true,
|
readonly: false
|
},
|
{
|
type: 'select',
|
key: 'opentype',
|
label: this.state.dict['header.menu.openType'],
|
initVal: menu.PageParam.OpenType,
|
required: true,
|
options: [{
|
MenuID: 'newtab',
|
text: this.state.dict['header.form.tab']
|
}, {
|
MenuID: 'newpage',
|
text: this.state.dict['header.form.newpage']
|
}, {
|
MenuID: 'currenttab',
|
text: this.state.dict['header.form.currenttab']
|
}]
|
}
|
]
|
})
|
}
|
|
/**
|
* @description 加载完成后
|
* 1、获取系统可使用表
|
* 2、根据配置信息中已使用表获取相关字段信息
|
* 3、获取所有标签页信息
|
*/
|
componentDidMount () {
|
let param = {
|
func: 'sPC_Get_SelectedList',
|
LText: queryTableSql,
|
obj_name: 'data',
|
arr_field: 'TbName,Remark'
|
}
|
|
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 => {
|
if (res.status) {
|
this.setState({
|
tables: res.data
|
})
|
} else {
|
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
|
}
|
})
|
})
|
}
|
})
|
}
|
|
/**
|
* @description 组件销毁，清除state更新
|
*/
|
componentWillUnmount () {
|
this.setState = () => {
|
return
|
}
|
}
|
|
/**
|
* @description 元素添加或拖动时顺序变化
|
*/
|
handleList = (type, list, card) => {
|
const { config } = this.state
|
|
if (type === 'tabs') { // 标签页调整顺序或添加元素
|
if (list.length > config[card.groupId].length) {
|
list = list.filter(item => !item.origin)
|
this.handleTab(card)
|
}
|
|
this.setState({config: {...config, [card.groupId]: list}})
|
} else {
|
if (list.length > config[type].length) {
|
list = list.filter(item => !item.origin)
|
if (type === 'search') {
|
this.handleSearch(card)
|
} else if (type === 'action') {
|
this.handleAction(card)
|
} else if (type === 'columns') {
|
this.handleColumn(card)
|
}
|
}
|
|
this.setState({
|
config: {...config, [type]: list }
|
})
|
}
|
}
|
|
/**
|
* @description 搜索条件编辑，获取搜索条件表单信息
|
*/
|
handleSearch = (card) => {
|
this.setState({
|
modaltype: 'search',
|
card: card,
|
formlist: getSearchForm(card)
|
})
|
}
|
|
/**
|
* @description 按钮编辑，获取按钮表单信息
|
*/
|
handleAction = (card, type) => {
|
let ableField = this.props.permFuncField.join(', ')
|
let functip = <div>
|
<p style={{marginBottom: '5px'}}>{this.state.dict['header.modal.func.innerface'].replace('@ableField', ableField)}</p>
|
<p>{this.state.dict['header.modal.func.outface']}</p>
|
</div>
|
|
this.setState({
|
modaltype: type === 'copy' ? 'actionCopy' : 'actionEdit',
|
card: card,
|
formlist: getActionForm(card, functip, this.state.config, this.props.permFuncField)
|
})
|
}
|
|
/**
|
* @description 显示列与合并列编辑，获取表单信息
|
*/
|
handleColumn = (card) => {
|
if (card.type !== 'colspan') {
|
this.setState({
|
modaltype: 'columns',
|
card: card,
|
formlist: getColumnForm(card)
|
})
|
} else {
|
this.setState({
|
modaltype: 'colspan',
|
card: card
|
})
|
}
|
}
|
|
/**
|
* @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'],
|
initVal: equalTab,
|
required: false,
|
options: equalTabs
|
}
|
]
|
})
|
}
|
|
/**
|
* @description 操作列编辑
|
*/
|
handleGridBtn = () => {
|
this.setState({
|
modaltype: 'gridbtn'
|
})
|
}
|
|
/**
|
* @description 搜索、按钮、显示列修改后提交保存
|
* 1、搜索条件保存
|
* 2、按钮包括正常编辑和复制，复制时,末尾添加,如按钮为表单（保存至数据库），复制按钮id存于复制列表（点击不保存时删除）
|
* 3、如按钮位置设置为表格，则修改操作列显示状态
|
*/
|
handleSubmit = () => {
|
const { menu } = this.props
|
const { config, card, modaltype, optionLibs } = this.state
|
|
if (modaltype === 'search') {
|
this.searchFormRef.handleConfirm().then(res => {
|
if ( // 更新下拉字典
|
(res.type === 'select' || res.type === 'multiselect' || res.type === 'link') &&
|
res.resourceType === '0' &&
|
res.options && res.options.length > 0
|
) {
|
optionLibs.set(menu.MenuID + res.uuid, {
|
uuid: menu.MenuID + res.uuid,
|
label: res.label,
|
parname: menu.MenuName,
|
type: 'search',
|
options: res.options
|
})
|
}
|
|
let _search = config.search.map(item => {
|
if (item.uuid === res.uuid) {
|
return res
|
} else {
|
return item
|
}
|
})
|
_search = _search.filter(item => !item.origin)
|
|
this.setState({
|
config: {...config, search: _search},
|
optionLibs: optionLibs,
|
modaltype: ''
|
})
|
})
|
} else if (modaltype === 'actionEdit' || modaltype === 'actionCopy') {
|
this.actionFormRef.handleConfirm().then(res => {
|
let _action = config.action.map(item => {
|
if (item.uuid === res.uuid) {
|
return res
|
} else {
|
return item
|
}
|
})
|
_action = _action.filter(item => !item.origin)
|
|
if (modaltype === 'actionCopy') {
|
_action.push(res)
|
}
|
|
// 复制按钮前后皆为表单时，复制表单配置信息，id存于复制列表
|
if (res.OpenType === 'pop' && card.originCard && card.originCard.OpenType === 'pop') {
|
Api.getSystemConfig({
|
func: 'sPC_Get_LongParam',
|
MenuID: card.originCard.uuid
|
}).then(result => {
|
if (result.status && result.LongParam) {
|
let _LongParam = ''
|
|
// 解析配置，修改模态框标题名称
|
if (result.LongParam) {
|
try {
|
_LongParam = JSON.parse(window.decodeURIComponent(window.atob(result.LongParam)))
|
} catch (e) {
|
console.warn('Parse Failure')
|
_LongParam = ''
|
}
|
}
|
if (_LongParam && _LongParam.type === 'Modal') {
|
try {
|
_LongParam.setting.title = res.label
|
_LongParam = window.btoa(window.encodeURIComponent(JSON.stringify(_LongParam)))
|
} catch {
|
console.warn('Stringify Failure')
|
_LongParam = ''
|
}
|
} else {
|
_LongParam = ''
|
}
|
|
let param = {
|
func: 'sPC_ButtonParam_AddUpt',
|
ParentID: menu.MenuID,
|
MenuID: res.uuid,
|
MenuNo: menu.MenuNo,
|
Template: 'Modal',
|
MenuName: res.label,
|
PageParam: JSON.stringify({Template: 'Modal'}),
|
LongParam: _LongParam
|
}
|
Api.getSystemConfig(param).then(response => {
|
if (!response.status) {
|
notification.warning({
|
top: 92,
|
message: response.message,
|
duration: 10
|
})
|
} else {
|
this.setState({
|
copyActions: [...this.state.copyActions, res.uuid]
|
})
|
}
|
})
|
}
|
})
|
} else if (
|
(res.OpenType === 'tab' || res.OpenType === 'blank') &&
|
card.originCard &&
|
(card.originCard.OpenType === 'tab' || card.originCard.OpenType === 'blank')
|
) {
|
Api.getSystemConfig({
|
func: 'sPC_Get_LongParam',
|
MenuID: card.originCard.uuid
|
}).then(result => {
|
if (result.status && result.LongParam) {
|
let _LongParam = ''
|
|
// 解析配置，修改模态框标题名称
|
if (result.LongParam) {
|
try {
|
_LongParam = JSON.parse(window.decodeURIComponent(window.atob(result.LongParam)))
|
} catch (e) {
|
console.warn('Parse Failure')
|
_LongParam = ''
|
}
|
}
|
|
let _temp = ''
|
if (_LongParam && _LongParam.type === 'FormTab') {
|
try {
|
_LongParam.action = _LongParam.action.map(_btn => {
|
_btn.uuid = Utils.getuuid()
|
|
return _btn
|
})
|
_LongParam.tabgroups.forEach(_groupId => {
|
_LongParam[_groupId] = _LongParam[_groupId].map(_tab => {
|
_tab.uuid = Utils.getuuid()
|
|
return _tab
|
})
|
})
|
_LongParam = window.btoa(window.encodeURIComponent(JSON.stringify(_LongParam)))
|
_temp = 'FormTab'
|
} catch {
|
console.warn('Stringify Failure')
|
_LongParam = ''
|
}
|
} else {
|
_LongParam = ''
|
}
|
|
if (!_temp) return
|
|
let param = {
|
func: 'sPC_ButtonParam_AddUpt',
|
ParentID: menu.MenuID,
|
MenuID: res.uuid,
|
MenuNo: menu.MenuNo,
|
Template: _temp,
|
MenuName: res.label,
|
PageParam: JSON.stringify({Template: _temp}),
|
LongParam: _LongParam
|
}
|
|
Api.getSystemConfig(param).then(response => {
|
if (!response.status) {
|
notification.warning({
|
top: 92,
|
message: response.message,
|
duration: 10
|
})
|
} else {
|
this.setState({
|
copyActions: [...this.state.copyActions, res.uuid]
|
})
|
}
|
})
|
}
|
})
|
}
|
|
// 判断是否存在操作列
|
let _hasGridbtn = _action.filter(act => act.position === 'grid').length > 0
|
let _gridBtn = config.gridBtn
|
|
if (_gridBtn) {
|
_gridBtn.display = _hasGridbtn
|
} else {
|
_gridBtn = {
|
display: _hasGridbtn,
|
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, action: _action, gridBtn: _gridBtn},
|
modaltype: ''
|
})
|
})
|
} else if (modaltype === 'columns' || modaltype === 'colspan') {
|
this.columnFormRef.handleConfirm().then(res => {
|
let _columns = config.columns.map(item => {
|
if (item.uuid === res.uuid) {
|
return res
|
} else {
|
return item
|
}
|
})
|
_columns = _columns.filter(item => !item.origin)
|
|
this.setState({
|
config: {...config, columns: _columns},
|
modaltype: ''
|
})
|
})
|
} else if (modaltype === 'gridbtn') {
|
this.gridBtnFormRef.handleConfirm().then(res => {
|
this.setState({
|
config: {...config, gridBtn: res},
|
modaltype: ''
|
})
|
})
|
} else if (modaltype === 'tabs') {
|
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, modaltype } = this.state
|
|
if (card.focus) {
|
let _config = null
|
if (modaltype === 'search') {
|
let _search = config.search.filter(item => item.uuid !== card.uuid)
|
_config = {...config, search: _search}
|
} else if (modaltype === 'actionEdit') {
|
let _action = config.action.filter(item => item.uuid !== card.uuid)
|
_config = {...config, action: _action}
|
} else if (modaltype === 'columns' || modaltype === 'colspan') {
|
let _columns = config.columns.filter(item => item.uuid !== card.uuid)
|
_config = {...config, columns: _columns}
|
} else if (modaltype === 'tabs') {
|
let _tabgroup = config[card.groupId].filter(item => item.uuid !== card.uuid)
|
_config = {...config, [card.groupId]: _tabgroup}
|
} else {
|
_config = config
|
}
|
|
this.setState({
|
card: null,
|
config: _config,
|
modaltype: ''
|
})
|
} else {
|
this.setState({
|
card: null,
|
modaltype: ''
|
})
|
}
|
}
|
|
/**
|
* @description 按钮-创建存储过程
|
*/
|
creatFunc = () => {
|
const { menu } = this.props
|
const { config } = this.state
|
|
this.actionFormRef.handleConfirm().then(res => {
|
let btn = res // 按钮信息
|
let newLText = '' // 创建存储过程sql
|
let DelText = '' // 删除存储过程sql
|
let isExit = false // 存储过程是否存在
|
let sysTVPText = '' // 已有的存储过程语句(云端)
|
let localTVPText = '' // 已有的存储过程语句(本地)
|
|
// 创建存储过程，必须填写内部函数名
|
if (!btn.innerFunc) {
|
notification.warning({
|
top: 92,
|
message: '请填写内部函数！',
|
duration: 10
|
})
|
return
|
}
|
|
// 创建中
|
this.setState({
|
funcLoading: true
|
})
|
|
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) {
|
try {
|
_LongParam = JSON.parse(window.decodeURIComponent(window.atob(res.LongParam)))
|
} catch (e) {
|
console.warn('Parse Failure')
|
_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: menu.MenuNo
|
}
|
newLText = Utils.formatOptions(Utils.getfunc(_param, btn, menu, config))
|
DelText = Utils.formatOptions(Utils.dropfunc(_param.funcName))
|
resolve(true)
|
} else {
|
resolve(false)
|
notification.warning({
|
top: 92,
|
message: '弹窗（表单）按钮，请先配置表单信息！',
|
duration: 10
|
})
|
}
|
})
|
} else if (btn.OpenType === 'excelIn') {
|
if (btn.verify && btn.verify.sheet && btn.verify.columns && btn.verify.columns.length > 0) {
|
let _param = {
|
funcName: btn.innerFunc,
|
menuNo: menu.MenuNo
|
}
|
newLText = Utils.formatOptions(Utils.getexcelInfunc(_param, btn, menu))
|
DelText = Utils.formatOptions(Utils.dropfunc(_param.funcName))
|
resolve(true)
|
} else {
|
notification.warning({
|
top: 92,
|
message: '请完善导入Excel验证信息！',
|
duration: 10
|
})
|
resolve(false)
|
}
|
} else if (btn.OpenType === 'excelOut') {
|
let _param = {
|
innerFunc: btn.innerFunc
|
}
|
|
newLText = Utils.formatOptions(Utils.getTableFunc(_param, menu, config ))
|
DelText = Utils.formatOptions(Utils.dropfunc(btn.innerFunc))
|
resolve(true)
|
} else {
|
let _param = {
|
funcName: btn.innerFunc,
|
name: config.setting.tableName || '',
|
fields: '',
|
menuNo: menu.MenuNo
|
}
|
newLText = Utils.formatOptions(Utils.getfunc(_param, btn, menu, 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 _action = config.action.map(item => {
|
if (item.uuid === btn.uuid) {
|
return btn
|
} else {
|
return item
|
}
|
})
|
_action = _action.filter(item => !item.origin)
|
|
// 判断是否存在操作列
|
let _hasGridbtn = _action.filter(act => act.position === 'grid').length > 0
|
let _gridBtn = config.gridBtn
|
|
if (_gridBtn) {
|
_gridBtn.display = _hasGridbtn
|
} else {
|
_gridBtn = {
|
display: _hasGridbtn,
|
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, action: _action, gridBtn: _gridBtn},
|
funcLoading: false
|
})
|
})
|
})
|
}
|
|
/**
|
* @description 创建表格存储过程
|
*/
|
tableCreatFunc = () => {
|
const { menu } = this.props
|
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
|
}
|
|
if (/[^\s]+\s+[^\s]+/ig.test(setting.dataresource) && config.setting.dataresource !== setting.dataresource) {
|
let param = {
|
func: 's_DataSrc_Save',
|
LText: setting.dataresource,
|
MenuID: menu.MenuID
|
}
|
|
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, menu, 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}
|
})
|
})
|
})
|
}
|
|
deleteElement = (element) => {
|
const { config, thawButtons } = this.state
|
let _this = this
|
|
confirm({
|
content: `确定删除<<${element.card.label}>>吗？`,
|
okText: this.state.dict['header.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}
|
} else {
|
let list = config[element.type].filter(item => {
|
if (item.uuid === element.card.uuid) {
|
return false
|
} else {
|
return true
|
}
|
})
|
|
_config = {...config, [element.type]: list}
|
|
// 删除按钮时判断是否存在操作列
|
if (element.type === 'action' && _config.gridBtn) {
|
_config.gridBtn.display = _config.action.filter(act => act.position === 'grid').length > 0
|
}
|
}
|
|
// 删除按钮元素
|
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 验证信息配置
|
*/
|
profileAction = (element) => {
|
this.setState({
|
profileVisible: true,
|
card: element
|
})
|
}
|
|
/**
|
* @description 验证信息保存
|
*/
|
verifySubmit = () => {
|
const { card } = this.state
|
let config = JSON.parse(JSON.stringify(this.state.config))
|
|
if (card.OpenType === 'excelIn') {
|
this.verifyRef.handleConfirm().then(res => {
|
|
config.action = config.action.map(item => {
|
if (item.uuid === card.uuid) {
|
item.verify = res
|
}
|
|
return item
|
})
|
|
this.setState({
|
profileVisible: false,
|
config: config,
|
card: '',
|
})
|
})
|
} else if (card.execMode) {
|
this.verifyRef.handleConfirm().then(res => {
|
|
config.action = config.action.map(item => {
|
if (item.uuid === card.uuid) {
|
item.verify = res
|
}
|
|
return item
|
})
|
|
this.setState({
|
profileVisible: false,
|
config: config,
|
card: '',
|
})
|
})
|
} else {
|
let _verify = this.verifyRef.state.verify
|
|
if (card.OpenType !== 'excelOut' && _verify.default === 'false' && _verify.scripts.length === 0) {
|
notification.warning({
|
top: 92,
|
message: '不执行默认sql时，必须设置自定义脚本！',
|
duration: 10
|
})
|
return
|
} else if (card.OpenType === 'excelOut') {
|
let _cols = _verify.columns.map(col => col.Column)
|
let _vcols = Array.from(new Set(_cols))
|
if (_cols.length > _vcols.length) {
|
notification.warning({
|
top: 92,
|
message: 'Excel列字段名，不可重复!',
|
duration: 10
|
})
|
|
return
|
}
|
}
|
|
config.action = config.action.map(item => {
|
if (item.uuid === card.uuid) {
|
item.verify = _verify
|
}
|
|
return item
|
})
|
|
this.setState({
|
profileVisible: false,
|
config: config,
|
card: '',
|
})
|
}
|
}
|
|
/**
|
* @description 三级菜单切换模板
|
*/
|
changeTemplate = () => {
|
this.props.handleView({tabview: 'template'})
|
}
|
|
getFuncNames = (data, funcNames, tableNames) => {
|
data.forEach(item => {
|
console.log(item)
|
if (item.subfuncs) {
|
this.getFuncNames(item.subfuncs, funcNames, tableNames)
|
} else {
|
if (item.tableName) {
|
tableNames.push(item.tableName)
|
}
|
if (item.innerFunc) {
|
// funcNames.push({func: item.innerFunc, label: item})
|
funcNames.push(item.innerFunc)
|
}
|
|
if (item.callbackFunc) {
|
funcNames.push(item.callbackFunc)
|
}
|
}
|
})
|
|
return {
|
func: funcNames,
|
table: tableNames
|
}
|
}
|
|
/**
|
* @description 三级菜单保存
|
*/
|
submitConfig = () => {
|
const { menu } = this.props
|
const { originMenu, delActions, thawButtons } = this.state
|
|
let config = JSON.parse(JSON.stringify(this.state.config))
|
|
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 _LongParam = ''
|
let _config = {...config, tables: this.state.selectedTables}
|
let _pageParam = {...menu.PageParam, OpenType: res.opentype}
|
|
// 未设置数据源或标签不合法时，启用状态为false
|
if (_config.setting.interType === 'inner' && !_config.setting.innerFunc && !_config.setting.dataresource) {
|
_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 = [] // 页面及子页面存储过程集
|
|
_config.funcs.push({
|
type: 'view',
|
subtype: 'view',
|
uuid: menu.MenuID,
|
intertype: _config.setting.interType || 'inner',
|
interface: _config.setting.interface || '',
|
tableName: _config.setting.tableName || '',
|
innerFunc: _config.setting.innerFunc || '',
|
outerFunc: _config.setting.outerFunc || ''
|
})
|
|
_config.action.forEach(item => {
|
let tablename = item.OpenType === 'excelIn' ? (item.sheet || '') : (item.sql || '')
|
|
if (item.OpenType === 'excelOut' && item.intertype === 'inner' && !item.innerFunc) {
|
tablename = _config.setting.tableName || ''
|
}
|
|
if (item.OpenType === 'tab' || item.OpenType === 'blank') {
|
_config.funcs.push({
|
type: 'tab',
|
subtype: 'btn',
|
uuid: item.uuid,
|
label: item.label,
|
linkTab: item.uuid
|
})
|
} else if (item.OpenType === 'popview') {
|
_config.funcs.push({
|
type: 'tab',
|
subtype: 'btn',
|
uuid: item.uuid,
|
label: item.label,
|
linkTab: item.linkTab
|
})
|
} else if (['pop', 'prompt', 'exec', 'excelIn', 'excelOut'].includes(item.OpenType)) {
|
_config.funcs.push({
|
type: 'button',
|
subtype: 'btn',
|
uuid: item.uuid,
|
label: item.label,
|
tableName: tablename,
|
intertype: item.intertype,
|
interface: item.interface || '',
|
innerFunc: item.innerFunc || '',
|
outerFunc: item.outerFunc || '',
|
callbackFunc: item.callbackFunc || ''
|
})
|
}
|
})
|
|
_config.tabgroups.forEach(groupId => {
|
if (_config[groupId].length === 0) return
|
|
_config[groupId].forEach(tab => {
|
_config.funcs.push({
|
type: 'tab',
|
subtype: 'tab',
|
uuid: tab.uuid,
|
label: tab.label,
|
linkTab: tab.linkTab
|
})
|
})
|
})
|
|
if (this.state.closeVisible) { // 显示关闭对话框时，模态框中保存按钮，显示保存中状态
|
this.setState({
|
menucloseloading: true
|
})
|
} else {
|
this.setState({
|
menuloading: true
|
})
|
}
|
|
new Promise(resolve => {
|
let deffers = []
|
_config.funcs.forEach(item => {
|
if (item.type === 'tab') {
|
let deffer = new Promise(resolve => {
|
Api.getSystemConfig({
|
func: 'sPC_Get_LongParam',
|
MenuID: item.linkTab
|
}).then(result => {
|
if (result.status && result.LongParam) {
|
let _LongParam = ''
|
|
if (result.LongParam) {
|
try {
|
_LongParam = JSON.parse(window.decodeURIComponent(window.atob(result.LongParam)))
|
} catch (e) {
|
console.warn('Parse Failure')
|
_LongParam = ''
|
}
|
}
|
|
if (_LongParam) {
|
item.menuNo = _LongParam.tabNo || ''
|
item.subfuncs = _LongParam.funcs || []
|
}
|
}
|
resolve()
|
})
|
})
|
|
deffers.push(deffer)
|
}
|
})
|
|
if (deffers.length === 0) {
|
resolve()
|
} else {
|
Promise.all(deffers).then(() => {
|
resolve()
|
})
|
}
|
}).then(() => {
|
// 保存时删除配置类型，system 、user
|
delete _config.type
|
delete _config.isAdd
|
|
try {
|
_LongParam = window.btoa(window.encodeURIComponent(JSON.stringify(_config)))
|
} catch (e) {
|
notification.warning({
|
top: 92,
|
message: '编译错误',
|
duration: 10
|
})
|
this.setState({
|
menucloseloading: false,
|
menuloading: false
|
})
|
return
|
}
|
|
let btnParam = { // 添加菜单按钮
|
func: 'sPC_Button_AddUpt',
|
Type: 40, // 添加菜单下的按钮type为40，按钮下的按钮type为60
|
ParentID: menu.MenuID,
|
MenuNo: res.menuNo,
|
Template: menu.PageParam.Template || '',
|
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 tabParam = { // 添加菜单tab页
|
func: 'sPC_sMenusTab_AddUpt',
|
MenuID: menu.MenuID
|
}
|
|
let _LText = []
|
let _index = 1
|
|
_config.tabgroups.forEach(groupId => {
|
_config[groupId].forEach(item => {
|
_LText.push(`select '${menu.MenuID}' as MenuID ,'${item.linkTab}' as Tabid,'${item.label}' as TabName ,'${_index * 10}' as Sort`)
|
_index++
|
})
|
})
|
|
_LText = _LText.join(' union all ')
|
|
tabParam.LText = Utils.formatOptions(_LText)
|
tabParam.timestamp = moment().format('YYYY-MM-DD HH:mm:ss') + '.000'
|
tabParam.secretkey = Utils.encrypt(tabParam.LText, tabParam.timestamp)
|
|
let _vals = this.getFuncNames(_config.funcs, [], [])
|
let _funcs = Array.from(new Set(_vals.func))
|
let _tables = Array.from(new Set(_vals.table))
|
|
let param = {
|
func: 'sPC_TrdMenu_AddUpt',
|
ParentID: res.parentId,
|
MenuID: menu.MenuID,
|
MenuNo: res.menuNo,
|
Template: menu.PageParam.Template || '',
|
MenuName: res.menuName,
|
Sort: (this.props.supMenuList.length + 1) * 10,
|
PageParam: JSON.stringify(_pageParam),
|
LongParam: _LongParam,
|
LText: _funcs.map(item => `select '${menu.MenuID}' as MenuID,'${item}' as ProcName,'${item}' as MenuName`),
|
LTexttb: _tables.map(item => `select '${menu.MenuID}' as MenuID,'${item}' as tbName`)
|
}
|
|
param.LText = param.LText.join(' union all ')
|
param.LText = Utils.formatOptions(param.LText)
|
param.LTexttb = param.LTexttb.join(' union all ')
|
param.LTexttb = Utils.formatOptions(param.LTexttb)
|
param.timestamp = moment().format('YYYY-MM-DD HH:mm:ss') + '.000'
|
param.secretkey = Utils.encrypt(param.LText, param.timestamp)
|
|
// 有按钮或标签删除时，先进行删除操作
|
// 删除成功后，保存页面配置
|
new Promise(resolve => {
|
if (delActions.length > 0) {
|
let deffers = delActions.map(item => {
|
let _param = {
|
func: 'sPC_MainMenu_Del',
|
MenuID: item.card.uuid
|
}
|
|
if (item.type === 'action') {
|
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: 10
|
})
|
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: msg,
|
duration: 10
|
})
|
return false
|
} else {
|
this.setState({
|
thawButtons: []
|
})
|
return true
|
}
|
}).then(resp => {
|
if (resp === false) return
|
let localParam = JSON.parse(JSON.stringify(param))
|
|
Api.getSystemConfig(param).then(response => {
|
if (response.status) {
|
this.setState({
|
config: _config,
|
originMenu: {
|
...originMenu,
|
LongParam: _config,
|
PageParam: _pageParam,
|
MenuName: res.menuName,
|
MenuNo: res.menuNo,
|
ParentID: res.parentId
|
}
|
})
|
|
this.props.reloadmenu()
|
|
this.submitAction(btnParam, tabParam)
|
|
localParam.func = 'sPC_TrdMenu_AddUpt_For_Local'
|
delete localParam.LongParam
|
delete localParam.PageParam
|
delete localParam.Template
|
delete localParam.Sort
|
|
Api.getLocalConfig(localParam)
|
} else {
|
this.setState({
|
menuloading: false,
|
menucloseloading: false
|
})
|
notification.warning({
|
top: 92,
|
message: response.message,
|
duration: 10
|
})
|
}
|
})
|
})
|
})
|
}, () => {
|
notification.warning({
|
top: 92,
|
message: this.state.dict['header.menu.basemsg'],
|
duration: 10
|
})
|
})
|
}
|
|
/**
|
* @description 保存或修改菜单按钮集
|
*/
|
submitAction = (btnParam, tabParam) => {
|
const { config } = this.state
|
|
new Promise(resolve => {
|
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 => {
|
if (!res.status) {
|
error = res
|
}
|
})
|
|
if (error) {
|
notification.warning({
|
top: 92,
|
message: error.message,
|
duration: 10
|
})
|
resolve(false)
|
} else {
|
resolve(true)
|
}
|
})
|
}
|
}).then(response => {
|
if (response === false) return response
|
|
if (!this.state.originActions || this.state.originActions.length === 0) return 'true'
|
|
let oriActions = []
|
this.state.originActions.forEach(item => {
|
let curBtn = config.action.filter(cell => item.curuuid === cell.uuid)[0] // 查看初始化按钮是否存在
|
if (!curBtn) return
|
if (curBtn.OpenType !== item.prebtn.OpenType) return
|
|
oriActions.push({
|
prebtn: item.prebtn,
|
curBtn: curBtn
|
})
|
})
|
|
if (oriActions.length === 0) return 'true'
|
|
oriActions.forEach(action => {
|
if (!action.prebtn || !action.prebtn.uuid) return
|
|
Api.getSystemConfig({
|
func: 'sPC_Get_LongParam',
|
MenuID: action.prebtn.uuid
|
}).then(result => {
|
if (result.status && result.LongParam) {
|
let _LongParam = ''
|
let _temp = ''
|
|
if (result.LongParam) {
|
let _subconfig = ''
|
try {
|
_subconfig = JSON.parse(window.decodeURIComponent(window.atob(result.LongParam)))
|
_temp = _subconfig.type
|
} catch (e) {
|
console.warn('Parse Failure')
|
_subconfig = ''
|
}
|
|
if (_temp === 'FormTab') {
|
try {
|
_subconfig.action = _subconfig.action.map(_btn => {
|
_btn.uuid = Utils.getuuid()
|
|
return _btn
|
})
|
_subconfig.tabgroups.forEach(_groupId => {
|
_subconfig[_groupId] = _subconfig[_groupId].map(_tab => {
|
_tab.uuid = Utils.getuuid()
|
|
if (_tab.linkTab) {
|
_tab.linkTab = ''
|
}
|
|
return _tab
|
})
|
})
|
_subconfig = window.btoa(window.encodeURIComponent(JSON.stringify(_subconfig)))
|
} catch {
|
console.warn('Stringify Failure')
|
_subconfig = ''
|
}
|
|
_LongParam = _subconfig
|
} else if (_subconfig) {
|
_LongParam = result.LongParam
|
}
|
}
|
|
if (_LongParam) {
|
let param = {
|
func: 'sPC_ButtonParam_AddUpt',
|
ParentID: this.props.menu.MenuID,
|
MenuID: action.curBtn.uuid,
|
MenuNo: this.props.menu.MenuNo,
|
Template: _temp,
|
MenuName: action.curBtn.label,
|
PageParam: JSON.stringify({Template: _temp}),
|
LongParam: _LongParam
|
}
|
Api.getSystemConfig(param).then(() => {})
|
}
|
}
|
})
|
})
|
return 'true'
|
}).then(response => {
|
if (response === 'true') {
|
notification.success({
|
top: 92,
|
message: '保存成功',
|
duration: 2
|
})
|
if (this.state.closeVisible) {
|
this.props.handleView()
|
} else {
|
this.setState({
|
originActions: [],
|
menuloading: false,
|
menucloseloading: false
|
})
|
}
|
} else {
|
this.setState({
|
menuloading: false,
|
menucloseloading: false
|
})
|
}
|
})
|
}
|
|
/**
|
* @description 点击返回时，判断配置保存状态
|
*/
|
cancelConfig = () => {
|
const { menu } = this.props
|
const { config, originMenu } = this.state
|
|
let _this = this
|
|
if (config.isAdd) {
|
confirm({
|
content: '菜单尚未提交，确定放弃保存吗？',
|
okText: this.state.dict['header.confirm'],
|
cancelText: this.state.dict['header.cancel'],
|
onOk() {
|
_this.props.handleView()
|
},
|
onCancel() {}
|
})
|
} else {
|
this.menuformRef.handleConfirm().then(res => {
|
let _config = {...config, tables: this.state.selectedTables}
|
let _pageParam = {...menu.PageParam, OpenType: res.opentype}
|
let _originMenu = {
|
...originMenu,
|
LongParam: _config,
|
PageParam: _pageParam,
|
MenuName: res.menuName,
|
MenuNo: res.menuNo,
|
ParentID: res.parentId
|
}
|
|
if (!is(fromJS(originMenu), fromJS(_originMenu))) {
|
this.setState({
|
closeVisible: true
|
})
|
} else {
|
this.props.handleView()
|
}
|
}, () => {
|
this.setState({
|
closeVisible: true
|
})
|
})
|
}
|
}
|
|
/**
|
* @description 筛选可用字段集
|
*/
|
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()]
|
})
|
}
|
|
/**
|
* @description 添加字段集
|
*/
|
addFieldSubmit = () => {
|
const {addType, config} = this.state
|
|
// 字段集为空，关闭弹窗
|
if (!this.state.fields || this.state.fields.length === 0) {
|
this.setState({
|
tableVisible: false,
|
addType: ''
|
})
|
}
|
|
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
|
|
if (cards.length === 0) {
|
notification.warning({
|
top: 92,
|
message: '请选择添加字段',
|
duration: 10
|
})
|
return
|
}
|
|
let columnsMap = new Map()
|
cards.forEach(card => {
|
columnsMap.set(card.field, card)
|
})
|
|
if (addType === 'search') {
|
let _search = config.search.filter(item => !item.origin)
|
|
// 重置原有搜素条件
|
_search = _search.map(item => {
|
if (columnsMap.has(item.field)) {
|
let cell = columnsMap.get(item.field)
|
|
if (cell.type !== item.type) { // 数据类型修改
|
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 = ''
|
}
|
columnsMap.delete(item.field)
|
}
|
return item
|
})
|
|
let _columns = [...columnsMap.values()]
|
|
// 顺序添加新增搜索
|
_columns.forEach(item => {
|
let _match = ''
|
if (item.type === 'select') {
|
_match = selectmatch[item.datatype]
|
} else if (item.type === 'daterange') {
|
_match = datematch[item.datatype]
|
} else {
|
_match = textmatch[item.datatype]
|
}
|
|
let newcard = {
|
uuid: Utils.getuuid(),
|
label: item.label,
|
field: item.field,
|
initval: '',
|
type: item.type || 'text',
|
resourceType: '0',
|
setAll: 'false',
|
options: [],
|
orderType: 'asc',
|
match: _match,
|
display: 'dropdown'
|
}
|
|
_search.push(newcard)
|
})
|
|
this.setState({
|
config: {...config, search: _search}
|
})
|
} else {
|
let _columns = config.columns.filter(item => !item.origin)
|
|
// 重置原有显示列类型
|
_columns = _columns.map(item => {
|
if (columnsMap.has(item.field)) {
|
let cell = columnsMap.get(item.field)
|
|
if (cell.type) {
|
item.type = cell.type
|
}
|
|
columnsMap.delete(item.field)
|
}
|
return item
|
})
|
|
let _cols = [...columnsMap.values()]
|
|
// 添加显示列
|
_cols.forEach(item => {
|
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
|
}
|
|
_columns.push(newcard)
|
})
|
|
this.setState({
|
config: {...config, columns: _columns}
|
})
|
}
|
|
notification.success({
|
top: 92,
|
message: '操作成功',
|
duration: 2
|
})
|
}
|
|
/**
|
* @description 表名切换时，添加表名，新增时查询表相关字段
|
*/
|
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
|
})
|
}
|
})
|
}
|
}
|
|
/**
|
* @description 删除表名以及表相关字段
|
*/
|
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)
|
})
|
}
|
|
/**
|
* @description 页面配置信息模态框显示
|
*/
|
changeSetting = () => {
|
this.setState({
|
settingVisible: true
|
})
|
}
|
|
/**
|
* @description 保存页面配置信息
|
*/
|
settingSave = () => {
|
const { menu } = this.props
|
const {config} = this.state
|
|
this.settingRef.handleConfirm().then(res => {
|
if (
|
res.interType === 'inner' &&
|
!res.innerFunc &&
|
/[^\s]+\s+[^\s]+/ig.test(res.dataresource) &&
|
config.setting.dataresource !== res.dataresource
|
) {
|
let param = {
|
func: 's_DataSrc_Save',
|
LText: res.dataresource,
|
MenuID: menu.MenuID
|
}
|
|
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({
|
config: {...config, setting: res},
|
settingVisible: false,
|
})
|
})
|
}
|
|
/**
|
* @description 设置可配置按钮
|
*/
|
setSubConfig = (item, type) => {
|
const { menu } = this.props
|
const { config, originMenu, optionLibs } = this.state
|
|
if (!originMenu.MenuID) { // menuID不存在时，为新建菜单，提示菜单尚未保存
|
notification.warning({
|
top: 92,
|
message: this.state.dict['header.menu.config.notsave'],
|
duration: 10
|
})
|
} else {
|
this.menuformRef.handleConfirm().then(res => {
|
let _config = {...config, tables: this.state.selectedTables}
|
let _pageParam = {...menu.PageParam, OpenType: res.opentype}
|
let _originMenu = {
|
...originMenu,
|
LongParam: _config,
|
PageParam: _pageParam,
|
MenuName: res.menuName,
|
MenuNo: res.menuNo,
|
ParentID: res.parentId
|
}
|
|
if (!is(fromJS(originMenu), fromJS(_originMenu))) { // 菜单信息变化时，提示保存
|
notification.warning({
|
top: 92,
|
message: this.state.dict['header.menu.config.update'],
|
duration: 10
|
})
|
return
|
}
|
|
// 菜单信息验证通过后，跳转子配置页面
|
let _view = ''
|
let uuid = item.uuid
|
let isbutton = true
|
let _btnTab = null
|
|
if (type === 'button' && item.OpenType === 'pop') {
|
_view = 'Modal' // 表单页面
|
} else if (type === 'button' && (item.OpenType === 'tab' || item.OpenType === 'blank')) {
|
_view = item.tabTemplate // 新标签页模板
|
_btnTab = item
|
} else if (type === 'button' && item.OpenType === 'popview') {
|
_view = item.tabType // 新弹窗标签模板
|
uuid = item.linkTab
|
isbutton = false
|
} else if (type === 'tab') {
|
_view = item.type // 标签模板
|
uuid = item.linkTab
|
isbutton = false
|
}
|
|
let param = {
|
optionLibs: optionLibs,
|
editMenu: _originMenu,
|
editTab: !isbutton ? item : '',
|
tabConfig: null,
|
editSubTab: null,
|
subTabConfig: null,
|
btnTab: _btnTab,
|
btnTabConfig: null,
|
editAction: isbutton ? item : '',
|
subConfig: '',
|
tabview: _view
|
}
|
|
this.setState({
|
loading: true
|
})
|
|
Api.getSystemConfig({
|
func: 'sPC_Get_LongParam',
|
MenuID: 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 === 'FormTab' && _LongParam.type === 'FormTab') {
|
param.subConfig = _LongParam
|
} else if (_LongParam && param.tabview === 'SubTable' && _LongParam.Template === 'SubTable') {
|
param.subConfig = _LongParam
|
}
|
|
this.props.handleView(param)
|
} else {
|
this.setState({
|
loading: false
|
})
|
notification.warning({
|
top: 92,
|
message: res.message,
|
duration: 10
|
})
|
}
|
})
|
}, () => {
|
notification.warning({
|
top: 92,
|
message: this.state.dict['header.menu.config.update'],
|
duration: 10
|
})
|
})
|
}
|
}
|
|
/**
|
* @description 页面启用停止切换
|
*/
|
onEnabledChange = () => {
|
const { config } = this.state
|
|
let tabinvalid = true
|
if (config.tabgroups.length > 1) {
|
config.tabgroups.forEach(group => {
|
if (config[group].length === 0) {
|
tabinvalid = false
|
}
|
})
|
}
|
|
if (config.setting.interType === 'inner' && !config.setting.innerFunc && !config.setting.dataresource) {
|
notification.warning({
|
top: 92,
|
message: '菜单尚未设置数据源，不可启用！',
|
duration: 10
|
})
|
} else if (!config.setting.primaryKey) {
|
notification.warning({
|
top: 92,
|
message: '菜单尚未设置主键，不可启用！',
|
duration: 10
|
})
|
} else if (!tabinvalid) {
|
notification.warning({
|
top: 92,
|
message: '菜单标签页设置错误（多行标签内，行标签不可为空），不可启用！',
|
duration: 10
|
})
|
} else {
|
this.setState({
|
config: {...config, enabled: !config.enabled}
|
})
|
}
|
}
|
|
/**
|
* @description 显示隐藏显示列字段名
|
*/
|
onColumnNameChange = () => {
|
const { showColumnName, config } = this.state
|
|
if (!showColumnName) {
|
let fields = []
|
config.columns.forEach(col => {
|
if (col.field) {
|
fields.push(col.field)
|
}
|
})
|
|
fields = fields.join(',')
|
|
let textArea = document.createElement('textarea')
|
textArea.value = fields
|
document.body.appendChild(textArea)
|
textArea.select()
|
|
try {
|
document.execCommand('copy')
|
document.body.removeChild(textArea)
|
} catch (err) {
|
document.body.removeChild(textArea)
|
}
|
}
|
|
this.setState({
|
showColumnName: !showColumnName
|
})
|
}
|
|
/**
|
* @description 增加标签页分组
|
*/
|
addTabGroup = () => {
|
let _this = this
|
let _config = JSON.parse(JSON.stringify(this.state.config))
|
|
confirm({
|
content: `确定新建标签组吗？`,
|
okText: this.state.dict['header.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 = JSON.parse(JSON.stringify(this.state.config))
|
|
confirm({
|
content: `确定删除标签组吗？`,
|
okText: this.state.dict['header.confirm'],
|
cancelText: this.state.dict['header.cancel'],
|
onOk() {
|
|
_config.tabgroups = _config.tabgroups.filter(group => group !== groupId)
|
delete _config[groupId]
|
|
_this.setState({
|
config: _config
|
})
|
},
|
onCancel() {}
|
})
|
}
|
|
/**
|
* @description 解冻按钮
|
*/
|
handleThaw = () => {
|
const { menu } = this.props
|
|
this.setState({
|
thawBtnVisible: true
|
})
|
|
Api.getSystemConfig({
|
func: 'sPC_Get_FrozenMenu',
|
ParentID: menu.MenuID,
|
TYPE: 40
|
}).then(res => {
|
if (res.status) {
|
let _list = []
|
|
res.data.forEach(menu => {
|
let _conf = ''
|
|
if (menu.ParentParam) {
|
try {
|
_conf = JSON.parse(window.decodeURIComponent(window.atob(menu.ParentParam)))
|
} catch (e) {
|
console.warn('Parse Failure')
|
_conf = ''
|
}
|
}
|
|
if (_conf) {
|
_list.push({
|
key: menu.MenuID,
|
title: menu.MenuName,
|
btnParam: _conf
|
})
|
}
|
})
|
|
this.setState({
|
thawbtnlist: _list
|
})
|
} else {
|
notification.warning({
|
top: 92,
|
message: res.message,
|
duration: 10
|
})
|
}
|
})
|
}
|
|
/**
|
* @description 解冻按钮提交
|
*/
|
thawBtnSubmit = () => {
|
const { thawButtons, config, thawbtnlist } = this.state
|
// 三级菜单解除冻结
|
if (this.refs.trawmenu.state.targetKeys.length === 0) {
|
notification.warning({
|
top: 92,
|
message: this.state.dict['form.required.select'] + this.state.dict['header.form.thawbutton'],
|
duration: 10
|
})
|
} else {
|
|
thawbtnlist.forEach(item => {
|
if (this.refs.trawmenu.state.targetKeys.includes(item.key)) {
|
config.action.push(item.btnParam)
|
}
|
})
|
|
this.setState({
|
thawButtons: [...thawButtons, ...this.refs.trawmenu.state.targetKeys],
|
config: config,
|
thawBtnVisible: false
|
})
|
}
|
}
|
|
handleGroup = (index, type) => {
|
let config = JSON.parse(JSON.stringify(this.state.config))
|
|
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
|
})
|
}
|
|
/**
|
* @description 选择不保存时，如有复制按钮，则删除
|
*/
|
notsave = () => {
|
this.state.copyActions.forEach(item => {
|
let _param = {
|
func: 'sPC_MainMenu_Del',
|
MenuID: item
|
}
|
Api.getSystemConfig(_param)
|
})
|
this.props.handleView()
|
}
|
|
pasteSubmit = () => {
|
this.pasteFormRef.handleConfirm().then(res => {
|
if (res.copyType !== 'action') {
|
notification.warning({
|
top: 92,
|
message: '配置信息格式错误！',
|
duration: 10
|
})
|
return
|
}
|
|
this.setState({
|
modaltype: ''
|
}, () => {
|
this.handleAction(res, 'copy')
|
})
|
})
|
}
|
|
render () {
|
const { modaltype } = this.state
|
const configAction = this.state.config.action.filter(_action =>
|
!_action.origin && (_action.OpenType === 'pop' || _action.OpenType === 'popview' || _action.OpenType === 'blank' || _action.OpenType === 'tab')
|
)
|
|
let configTabs = []
|
this.state.config.tabgroups.forEach(group => {
|
configTabs.push(...this.state.config[group])
|
})
|
|
return (
|
<div className="common-table-board">
|
<DndProvider backend={HTML5Backend}>
|
{/* 工具栏 */}
|
<div className="tools">
|
<Collapse accordion defaultActiveKey="0" bordered={false}>
|
{/* 基本信息 */}
|
<Panel header={this.state.dict['header.menu.basedata']} key="0" id="common-basedata">
|
{/* 菜单信息 */}
|
<MenuForm
|
dict={this.state.dict}
|
formlist={this.state.menuformlist}
|
wrappedComponentRef={(inst) => this.menuformRef = inst}
|
/>
|
{/* 表名添加 */}
|
<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} title={table.TbName} 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>}
|
/>}
|
</Panel>
|
{/* 搜索条件添加 */}
|
<Panel header={this.state.dict['header.menu.search']} key="1">
|
<div className="search-element">
|
{Source.searchItems.map((item, index) => {
|
return (<SourceElement key={index} content={item}/>)
|
})}
|
</div>
|
<Button type="primary" block onClick={() => this.queryField('search')}>{this.state.dict['header.menu.search.add']}</Button>
|
</Panel>
|
{/* 按钮添加 */}
|
<Panel header={this.state.dict['header.menu.action']} key="2">
|
<div className="search-element">
|
{Source.actionItems.map((item, index) => {
|
return (<SourceElement key={index} content={item}/>)
|
})}
|
</div>
|
<div className="config-btn">
|
{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
|
}
|
<div className="thawbutton" title={this.state.dict['header.form.thawbutton']} onClick={this.handleThaw}>
|
<Icon type="unlock" />
|
</div>
|
</div>
|
{configAction.map((item, index) => {
|
return (
|
<div key={index}>
|
<Button
|
icon={item.icon}
|
style={{marginBottom: '10px'}}
|
className={'config-button mk-btn mk-' + item.class}
|
onClick={() => this.setSubConfig(item, 'button')}
|
>{item.label}</Button>
|
</div>
|
)
|
})}
|
</Panel>
|
{/* 添加显示列 */}
|
<Panel header={this.state.dict['header.menu.column']} key="3">
|
<div className="search-element">
|
{Source.columnItems.map((item, index) => {
|
return (<SourceElement key={index} content={item}/>)
|
})}
|
</div>
|
<Button type="primary" block onClick={() => this.queryField('columns')}>{this.state.dict['header.menu.column.add']}</Button>
|
</Panel>
|
{/* 添加标签 */}
|
<Panel header={this.state.dict['header.menu.tab']} key="4">
|
<div className="search-element">
|
{Source.tabItems.map((item, index) => {
|
return (<SourceElement key={index} content={item}/>)
|
})}
|
</div>
|
{configTabs.length > 0 ?
|
<p className="config-btn-title">
|
<Tooltip placement="topLeft" title="点击按钮，可完成或查看标签配置信息。">
|
<Icon type="question-circle" />
|
</Tooltip>
|
{this.state.dict['header.menu.tab.configurable']}
|
</p> : null
|
}
|
{configTabs.map((item, index) => {
|
return (
|
<div key={index}>
|
<Button
|
className="config-button"
|
icon={item.icon}
|
style={{marginBottom: '10px'}}
|
onClick={() => this.setSubConfig(item, 'tab')}
|
>{item.label}</Button>
|
</div>
|
)
|
})}
|
</Panel>
|
</Collapse>
|
</div>
|
<div className="setting">
|
<Card title={this.state.dict['header.menu.page.configurable']} bordered={false} extra={
|
<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>
|
</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>
|
<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']}
|
/>
|
</div>
|
<div className="action-list" id="action-list">
|
<Tooltip placement="bottomLeft" overlayClassName="middle" title="在左侧工具栏《按钮》中，选择对应类型的按钮拖至此处添加，如选择按钮类型为表单、新标签页等含有配置页面的按钮，可在左侧工具栏-按钮-可配置按钮处，点击按钮完成相关配置。注：当设置按钮显示位置为表格时，显示列会增加操作列。">
|
<Icon type="question-circle" />
|
</Tooltip>
|
<div className="copybutton" title={this.state.dict['header.form.paste']} onClick={() => {this.setState({modaltype: 'paste'})}}>
|
<Icon type="snippets" />
|
</div>
|
<DragElement
|
type="action"
|
list={this.state.config.action}
|
setting={this.state.config.setting}
|
handleList={this.handleList}
|
handleMenu={this.handleAction}
|
copyElement={(val) => this.handleAction(val, 'copy')}
|
deleteMenu={this.deleteElement}
|
profileMenu={this.profileAction}
|
placeholder={this.state.dict['header.form.action.placeholder']}
|
/>
|
</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} />
|
<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']}
|
/>
|
</div>
|
{/* 标签组 */}
|
{this.state.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 !== (this.state.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={this.state.config[groupId]}
|
handleList={this.handleList}
|
handleMenu={this.handleTab}
|
deleteMenu={this.deleteElement}
|
placeholder={this.state.dict['header.form.tab.placeholder']}
|
/>
|
</div>)
|
})}
|
</Card>
|
</div>
|
</DndProvider>
|
{/* 编辑搜索条件 */}
|
<Modal
|
title={this.state.dict['header.modal.search.edit']}
|
visible={modaltype === 'search'}
|
width={700}
|
maskClosable={false}
|
onOk={this.handleSubmit}
|
onCancel={this.editModalCancel}
|
destroyOnClose
|
>
|
<SearchForm
|
dict={this.state.dict}
|
card={this.state.card}
|
inputSubmit={this.handleSubmit}
|
optionLibs={this.state.optionLibs}
|
formlist={this.state.formlist}
|
wrappedComponentRef={(inst) => this.searchFormRef = inst}
|
/>
|
</Modal>
|
{/* 编辑按钮：复制、编辑 */}
|
<Modal
|
title={modaltype === 'actionEdit' ? this.state.dict['header.modal.action.edit'] : this.state.dict['header.modal.action.copy']}
|
visible={modaltype === 'actionEdit' || modaltype === 'actionCopy'}
|
width={800}
|
maskClosable={false}
|
onCancel={this.editModalCancel}
|
footer={[
|
modaltype === 'actionEdit' ? <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.editModalCancel}>{this.state.dict['header.cancel']}</Button>,
|
<Button key="confirm" type="primary" onClick={this.handleSubmit}>{this.state.dict['header.confirm']}</Button>
|
]}
|
destroyOnClose
|
>
|
<ActionForm
|
dict={this.state.dict}
|
card={this.state.card}
|
tabs={this.state.tabviews}
|
formlist={this.state.formlist}
|
inputSubmit={this.handleSubmit}
|
setting={this.state.config.setting}
|
wrappedComponentRef={(inst) => this.actionFormRef = inst}
|
/>
|
</Modal>
|
{/* 显示列编辑 */}
|
<Modal
|
title={this.state.dict['header.modal.column.edit']}
|
visible={modaltype === 'columns'}
|
width={700}
|
maskClosable={false}
|
onOk={this.handleSubmit}
|
onCancel={this.editModalCancel}
|
destroyOnClose
|
>
|
<ColumnForm
|
dict={this.state.dict}
|
card={this.state.card}
|
inputSubmit={this.handleSubmit}
|
formlist={this.state.formlist}
|
wrappedComponentRef={(inst) => this.columnFormRef = inst}
|
/>
|
</Modal>
|
{/* 合并列编辑 */}
|
<Modal
|
title={this.state.dict['header.modal.colspan.edit']}
|
visible={modaltype === 'colspan'}
|
width={700}
|
maskClosable={false}
|
onOk={this.handleSubmit}
|
onCancel={this.editModalCancel}
|
destroyOnClose
|
>
|
<ColspanForm
|
dict={this.state.dict}
|
card={this.state.card}
|
inputSubmit={this.handleSubmit}
|
columns={this.state.config.columns}
|
wrappedComponentRef={(inst) => this.columnFormRef = inst}
|
/>
|
</Modal>
|
{/* 操作列编辑 */}
|
<Modal
|
title={this.state.dict['header.modal.gridbtn.edit']}
|
visible={modaltype === 'gridbtn'}
|
width={700}
|
maskClosable={false}
|
onOk={this.handleSubmit}
|
onCancel={this.editModalCancel}
|
destroyOnClose
|
>
|
<GridBtnForm
|
dict={this.state.dict}
|
inputSubmit={this.handleSubmit}
|
card={this.state.config.gridBtn}
|
wrappedComponentRef={(inst) => this.gridBtnFormRef = inst}
|
/>
|
</Modal>
|
{/* 标签编辑 */}
|
<Modal
|
title={this.state.dict['header.modal.tabs.edit']}
|
visible={modaltype === 'tabs'}
|
width={700}
|
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
|
wrapClassName="common-table-fields-modal"
|
title={this.state.dict['header.edit']}
|
visible={this.state.tableVisible}
|
width={'65vw'}
|
maskClosable={false}
|
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
|
wrapClassName="common-table-fields-modal"
|
title={'验证信息'}
|
maskClosable={false}
|
visible={this.state.profileVisible}
|
width={'75vw'}
|
style={{minWidth: '900px', maxWidth: '1200px'}}
|
onOk={this.verifySubmit}
|
onCancel={() => { this.setState({ profileVisible: false }) }}
|
destroyOnClose
|
>
|
{this.state.card && !this.state.card.execMode && this.state.card.OpenType !== 'excelIn' && this.state.card.OpenType !== 'excelOut' ?
|
<VerifyCard
|
card={this.state.card}
|
dict={this.state.dict}
|
columns={this.state.config.columns}
|
wrappedComponentRef={(inst) => this.verifyRef = inst}
|
/> : null
|
}
|
{this.state.card && this.state.card.execMode ?
|
<VerifyCardPrint
|
card={this.state.card}
|
dict={this.state.dict}
|
columns={this.state.config.columns}
|
wrappedComponentRef={(inst) => this.verifyRef = inst}
|
/> : null
|
}
|
{this.state.card && this.state.card.OpenType === 'excelIn' ?
|
<VerifyCardExcelIn
|
card={this.state.card}
|
dict={this.state.dict}
|
columns={this.state.config.columns}
|
wrappedComponentRef={(inst) => this.verifyRef = inst}
|
/> : null
|
}
|
{this.state.card && this.state.card.OpenType === 'excelOut' ?
|
<VerifyCardExcelOut
|
card={this.state.card}
|
dict={this.state.dict}
|
wrappedComponentRef={(inst) => this.verifyRef = inst}
|
/> : null
|
}
|
</Modal>
|
{/* 设置全局配置及列表数据源 */}
|
<Modal
|
title={this.state.dict['header.edit']}
|
visible={this.state.settingVisible}
|
width={700}
|
maskClosable={false}
|
// 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}
|
menu={this.props.menu}
|
inputSubmit={this.settingSave}
|
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="notsave" className="mk-btn mk-yellow" onClick={this.notsave}>{this.state.dict['header.notsave']}</Button>,
|
<Button key="cancel" onClick={() => { this.setState({closeVisible: false}) }}>{this.state.dict['header.cancel']}</Button>
|
]}
|
destroyOnClose
|
>
|
{this.state.dict['header.menu.config.placeholder']}
|
</Modal>
|
{/* 解冻按钮模态框 */}
|
<Modal
|
title={this.state.dict['header.form.thawbutton']}
|
okText={this.state.dict['header.confirm']}
|
cancelText={this.state.dict['header.cancel']}
|
visible={this.state.thawBtnVisible}
|
onOk={this.thawBtnSubmit}
|
onCancel={() => {this.setState({thawBtnVisible: false, thawbtnlist: null})}}
|
destroyOnClose
|
>
|
{!this.state.thawbtnlist && <Spin style={{marginLeft: 'calc(50% - 22px)', marginTop: '70px', marginBottom: '70px'}} size="large" />}
|
{this.state.thawbtnlist && <TransferForm ref="trawmenu" dict={this.state.dict} menulist={this.state.thawbtnlist}/>}
|
</Modal>
|
{/* 按钮配置信息粘贴复制 */}
|
<Modal
|
title={this.state.dict['header.form.paste']}
|
visible={modaltype === 'paste'}
|
width={600}
|
maskClosable={false}
|
onOk={this.pasteSubmit}
|
onCancel={() => {this.setState({modaltype: ''})}}
|
destroyOnClose
|
>
|
<PasteForm
|
dict={this.state.dict}
|
wrappedComponentRef={(inst) => this.pasteFormRef = inst}
|
/>
|
</Modal>
|
{this.state.loading && <Spin size="large" />}
|
</div>
|
)
|
}
|
}
|
|
const mapStateToProps = (state) => {
|
return {
|
permFuncField: state.permFuncField
|
}
|
}
|
|
const mapDispatchToProps = () => {
|
return {}
|
}
|
|
export default connect(mapStateToProps, mapDispatchToProps)(ComTableConfig)
|
