<template>
|
<div>
|
<div v-if="this.crudArrayFlag" class="app" style="display: flex;flex-wrap: wrap; display: inline-block">
|
<el-button-group>
|
<!--新增-->
|
<span v-if="permissionList.busineStatus">
|
<el-button
|
v-if="attrEditVisible == false && attrFlagChiledren==false && editOpenFlag && (!checkStatus || crudLCStatus=='Editing' )"
|
icon="el-icon-plus" plain size="small" type="primary" @click="busineHandle">添加 {{ msg }}
|
</el-button>
|
</span>
|
<!-- 全屏编辑-->
|
<span v-if="permissionList.fullscreenStatus">
|
<el-button
|
v-if=" attrEditVisible == false && attrFlagChiledren==false && editOpenFlag&&(!checkStatus || crudLCStatus=='Editing')"
|
icon="el-icon-full-screen" size="small" @click="fullscreenHandle">全屏编辑
|
</el-button>
|
</span>
|
<span v-if="permissionList.ruleStatus">
|
<!-- 验证规则-->
|
<el-button v-if="(!checkStatus || crudLCStatus=='Editing' )&& editOpenFlag" icon="el-icon-info" size="small"
|
@click="ruleAddHandler">验证规则
|
</el-button>
|
</span>
|
<span v-if="permissionList.attrStatus">
|
<!-- 属性分组-->
|
<el-button v-if="(!checkStatus || crudLCStatus=='Editing') && editOpenFlag" icon="el-icon-menu" size="small"
|
@click="attrVisibleHandle">属性分组
|
</el-button>
|
</span>
|
</el-button-group>
|
<el-button-group>
|
<span v-if="permissionList.saveStatus">
|
<!-- 保存-->
|
<el-button v-if="(!checkStatus|| crudLCStatus=='Editing') && editOpenFlag" icon="el-icon-check" plain
|
size="small"
|
type="success" @click.prevent="addsHandler">保存
|
</el-button>
|
</span>
|
<!-- 预览排序-->
|
<el-button v-if="permissionList.orderStatus" icon="el-icon-arrow-down" size="small" @click="orderHandle">预览排序
|
</el-button>
|
<span v-if="permissionList.removeStatus">
|
<!-- 删除-->
|
<el-button v-if="(!checkStatus || crudLCStatus=='Editing') && editOpenFlag" icon="el-icon-delete" size="small"
|
@click="CrudRemove">删除
|
</el-button>
|
</span>
|
<!-- 重置-->
|
<el-button v-if="permissionList.resetStatus" icon="el-icon-refresh-right" size="small" @click="resetHandler">
|
重置
|
</el-button>
|
</el-button-group>
|
<el-button-group>
|
<span v-if="permissionList.injectStatus"><!-- 分类注入-->
|
<el-button v-if="(!checkStatus || crudLCStatus=='Editing') && editOpenFlag" icon="el-icon-magic-stick"
|
size="small" @click="injectBtn">分类注入
|
</el-button></span>
|
<span v-if="permissionList.isShowStatus"> <!-- 组合规则-->
|
<el-button v-if="(!checkStatus || crudLCStatus=='Editing') && editOpenFlag" icon="el-icon-film" size="small"
|
@click="isShowHandler">组合规则
|
</el-button></span>
|
<span v-if="permissionList.enumStatus"> <!-- 枚举注入-->
|
<el-button v-if="(!checkStatus || crudLCStatus=='Editing') && editOpenFlag" icon="el-icon-c-scale-to-original"
|
size="small" @click="enumVisHandle">枚举注入
|
</el-button></span>
|
|
<span v-if="permissionList.cascadStatus">
|
<!-- 级联属性-->
|
<el-button v-if="(!checkStatus|| crudLCStatus=='Editing') && editOpenFlag" icon="el-icon-coin" size="small"
|
@click="CascadeHandle">级联属性
|
</el-button>
|
</span>
|
</el-button-group>
|
|
<el-button-group>
|
<!-- 同步到其他模板-->
|
<el-button v-if="permissionList.syncStatus" icon="el-icon-share" size="small" @click="syncHandle">同步到其他模板
|
</el-button>
|
</el-button-group>
|
|
<el-button-group>
|
<!-- 编码申请预览-->
|
<el-button v-if="permissionList.applicationStatus" icon="el-icon-view" size="small" style=""
|
@click="applicationHandle">编码申请预览
|
</el-button>
|
|
</el-button-group>
|
<!-- 是否开启编辑 -->
|
<el-button-group>
|
<el-button
|
v-if="(!checkStatus|| crudLCStatus=='Editing') && !editOpenFlag && attrEditVisible == false && attrFlagChiledren==false"
|
icon="el-icon-view" plain
|
size="small"
|
@click="editOpen">开启编辑
|
</el-button>
|
<el-select v-if="(!checkStatus || crudLCStatus=='Editing') && editOpenFlag" v-model="selectvalue"
|
placeholder="请选择"
|
size="small">
|
<el-option
|
v-for="item in selectoptions"
|
:key="item.value"
|
:label="item.label"
|
:value="item.value">
|
</el-option>
|
</el-select>
|
<el-switch v-if="(!checkStatus || crudLCStatus=='Editing') && editOpenFlag" v-model="switchvalue"
|
active-value="true" style="margin:6px 0 0 10px" @change="batchSetFlag">
|
</el-switch>
|
</el-button-group>
|
</div>
|
<!-- 弹窗-->
|
<div>
|
<!-- 编码申请预览-->
|
<FormTemplateDialog
|
:codeClassifyOid="this.codeClassifyOid"
|
:templateOid="this.crudOid"
|
:type="add"
|
:visible.sync="addvisible"
|
>
|
</FormTemplateDialog>
|
<!-- 级联属性-->
|
<el-dialog :visible.sync="CascadeVisible" append-to-body title="请选择级联属性">
|
<avue-crud ref="crud" :data="CascadeData" :option="CascadeOption" @row-click="CascaderowClick">
|
<template slot="radio"
|
slot-scope="{row}">
|
<el-radio v-model="selectRow"
|
:label="row.$index">
|
</el-radio>
|
</template>
|
</avue-crud>
|
<div style="display: flex ;padding-top: 18px;justify-content: right">
|
<el-button size="small" type="primary" @click="CascadeAddHandle">确定</el-button>
|
<el-button size="small" style="margin-left: 10px" @click="casRemove">清除内容</el-button>
|
<el-button size="small" style="margin-left: 10px" @click="CascadeVisible=false">取消</el-button>
|
</div>
|
</el-dialog>
|
<!-- 枚举注入-->
|
<el-dialog :before-close="this.enumBeforeClose" :visible.sync="enumVisible" append-to-body title="枚举注入">
|
<!-- 渲染表格及按钮 -->
|
<!-- 渲染表格及按钮 -->
|
<el-alert
|
:closable="false"
|
style="margin-bottom: 10px;display: inline-block"
|
title="请新增后点击单元格输入枚举数据"
|
type="success">
|
</el-alert>
|
<div>
|
<el-button icon="el-icon-plus" type="primary" @click="addRow">新增</el-button>
|
<el-table :data="tableData" style="width: 100%" @cell-click="handleCellClick"
|
@selection-change="handleSelectionChange">
|
<!-- 渲染表格列及传参 -->
|
<el-table-column label="选项值" prop="key">
|
<template slot-scope="{ row }">
|
<!-- 编辑和展示逻辑 -->
|
<el-input v-if="editingRow === row && editShow == 'key'" v-model="row.key" @blur="saveRow"></el-input>
|
<span v-else>{{ row.key }}</span>
|
</template>
|
</el-table-column>
|
<el-table-column label="选项中文标签" prop="value">
|
<template slot-scope="{ row }">
|
<!-- 编辑和展示逻辑 -->
|
<el-input v-if="editingRow === row && editShow == 'value'" v-model="row.value"
|
@blur="saveRow"></el-input>
|
<span v-else>{{ row.value }}</span>
|
</template>
|
</el-table-column>
|
<el-table-column fixed="right" label="操作" width="120">
|
<template slot-scope="scope">
|
<el-button plain size="small" type="text" @click="enumDeleteRow">
|
移除
|
</el-button>
|
</template>
|
</el-table-column>
|
</el-table>
|
<template>
|
<div style="display: flex;justify-content: right;margin-top: 15px">
|
<el-button size="small" type="primary" @click="enumAddHandle">保存</el-button>
|
<el-button size="small" @click="enumCancell">取消</el-button>
|
</div>
|
</template>
|
</div>
|
</el-dialog>
|
<!-- 分类注入-->
|
<el-dialog :visible.sync="injectVisible" append-to-body class="mydialog"
|
style="width: 1400px; left:14vw ;top: 10vh;" title="分类注入">
|
<div class="injectBox">
|
<div style="color: #FF5722;margin: 1px 0 5px 20px">分类层级关联说明：</div>
|
<div
|
style="color: #01aaed;margin: 0 10px 0 45px;line-height: 20px">1：主要是设置模板属性和分类的关系<br/>2：如分类层级设置为2 <br/>3：录入资源数据时，该属性对应的值根据层级关系去对应的分类里取
|
<br/>4：层级必须是大于0的整数值
|
</div>
|
<div style="padding-top: 15px;padding-left: 35px">
|
<el-form ref="injectForm" label-width="80px">
|
<el-form-item label="注入类型">
|
<el-radio-group v-model="injectOption.classifyInvokeAttr">
|
<el-radio label="name">分类名称</el-radio>
|
<el-radio label="id">分类代号</el-radio>
|
</el-radio-group>
|
</el-form-item>
|
<el-form-item label="层级设置">
|
<el-radio-group v-model="injectOption.classifyInvokeLevel">
|
<el-radio label="min">最小层</el-radio>
|
<el-radio label="max">指定层</el-radio>
|
<el-input-number v-if="this.injectOption.classifyInvokeLevel == 'max'"
|
v-model="injectOption.classifyNumber" :max="10" :min="0"
|
controls-position="right"></el-input-number>
|
</el-radio-group>
|
</el-form-item>
|
<el-form-item label="可修改">
|
<el-radio-group v-model="injectOption.classifyInvokeEditFlag">
|
<el-radio label="true">是</el-radio>
|
<el-radio label="false">否</el-radio>
|
</el-radio-group>
|
</el-form-item>
|
</el-form>
|
</div>
|
</div>
|
<div style="display: flex;justify-content: flex-end">
|
<el-button size="small" type="primary" @click="injectAddHandle">确定</el-button>
|
<el-button size="small" @click="injectHandleReset">清除内容</el-button>
|
<el-button size="small" @click="injectRemove">取消</el-button>
|
</div>
|
</el-dialog>
|
<!-- 属性分组-->
|
<el-dialog :before-close="attrClose" :visible.sync="attrVisible" append-to-body
|
style="width: 800px; left:30vw;top: 10vh ;"
|
title="输入分组的名称">
|
<el-form ref="form" label-width="70px">
|
<el-form-item label="属性分组">
|
<el-input v-model="attrModel" autofocus></el-input>
|
</el-form-item>
|
<div style="display: flex;justify-content: flex-end">
|
<el-button size="small" type="primary" @click="attrHandle">提交</el-button>
|
<el-button size="small" @click="attrRemove">清空</el-button>
|
</div>
|
</el-form>
|
</el-dialog>
|
<!-- 验证规则-->
|
<el-dialog :visible.sync="rulesVisible" append-to-body title="属性验证规则">
|
<el-container style="border: 1px solid #9e3333;padding: 10px">
|
<el-aside style="width: 330px;">
|
<div style="display: flex">
|
<p style="display: inline-block;width: 160px"> 正则表达式：</p>
|
<el-input
|
v-model="RulesForm.expressionText"
|
:rows="6"
|
placeholder="请输入内容"
|
style="display: inline-block;"
|
type="textarea"
|
>
|
</el-input>
|
</div>
|
<div style="display: flex; margin-top: 15px">
|
<p style="display: inline-block;width: 160px"> 测试内容：</p>
|
<el-input
|
v-model="RulesForm.TestContent"
|
:rows="6"
|
placeholder="请输入内容"
|
style="display: inline-block;"
|
type="textarea"
|
>
|
</el-input>
|
</div>
|
<div style="display: flex; margin-left: 113px;margin-top: 15px">
|
<el-button type="mini" @click="rulesExamine">检查</el-button>
|
<el-button type="mini" @click="rulesremove">清除内容</el-button>
|
<el-button type="mini" @click="rulesHandle">确定</el-button>
|
</div>
|
</el-aside>
|
<el-main style="padding: 10px;margin-left: 10px">
|
<avue-crud ref="rulsecrud" :data="rulesData" :option="rulesOption" style="height: 450px"
|
@row-dblclick="handleRulesRowDBLClick"></avue-crud>
|
</el-main>
|
</el-container>
|
</el-dialog>
|
<!-- 全屏编辑-->
|
<el-dialog :before-close="escEdit" :visible.sync="attrEditVisible" append-to-body fullscreen="true">
|
<attrCrud :ProData="this.ProData" :attrFlagChiledren="this.attrFlag" :crudArrayFlag="this.crudArrayFlag"
|
:editOpenFlag="editOpenFlag" :editStyleFlag="editStyleFlag"
|
@editCloseChildren="editClose"></attrCrud>
|
</el-dialog>
|
<!-- 组合规则-->
|
<formula-editor :componentRuleText="componentRuleText"
|
:systemVariableTableData="systemVariableTableData"
|
:thisSceneTableData="thisSceneTableData"
|
:visible.sync="isShowformulaEdit"
|
@updateFormulaContent="updataFormlaContent"
|
></formula-editor>
|
<!-- 新增 -->
|
<el-dialog :visible.sync="addVisible" append-to-body title="从业务类型中选择属性">
|
<avue-crud ref="AddOriginPlace" :data="businessData" :option="businessOption"
|
@selection-change="businessSelect">
|
<template slot="menuLeft">
|
<div style="display: flex;">
|
<el-select v-model="SelectValue" placeholder="请选择" style="width: 150px !important;">
|
<el-option
|
v-for="item in SelectOption"
|
:key="item.value"
|
:label="item.label"
|
:value="item.value"
|
style="width: 150px">
|
</el-option>
|
</el-select>
|
<el-input v-model="SelectFInd" style="width: 400px;margin-left: 20px"></el-input>
|
<el-button size="small" style="margin-left: 10px" @click="AddFindHandler">查询</el-button>
|
</div>
|
</template>
|
</avue-crud>
|
<div style="display: flex;justify-content: flex-end;margin-top: 15px">
|
<el-button size="small" type="primary" @click="busineAddHandle">保存</el-button>
|
<el-button size="small" type="primary" @click="addVisible=false">取消</el-button>
|
</div>
|
</el-dialog>
|
<!-- 参照配置-->
|
<refer-config-dialog
|
:display="referConfigVisble"
|
:referConfigOption="referConfigOption"
|
@setReferConfigValue="setReferConfigValue"
|
></refer-config-dialog>
|
|
</div>
|
<el-table v-if="this.crudArrayFlag"
|
ref="referAttrCrud"
|
v-loading="loading"
|
:data="ProData"
|
:height="this.tableHeight"
|
border
|
style="width: 100%"
|
@select="selectHandle"
|
@cell-click="handleCellClicks"
|
@selection-change="selectionChange"
|
@row-click="rowClick"
|
>
|
<el-table-column
|
:fixed="!editStyleFlag ? 'left' : undefined"
|
type="selection" width="55">
|
</el-table-column>
|
<!--<el-table-column fixed label="序号" type="index" width="55"></el-table-column>-->
|
<el-table-column v-for="(item,index) in this.option.column" v-if="item.edit !='referName'"
|
:key="item.id"
|
:fixed="!editStyleFlag ? item.fixed : undefined"
|
:formatter="formAttr"
|
:label="item.label"
|
:prop="item.prop"
|
:show-overflow-tooltip="true"
|
:sortable="item.sortable"
|
:width="item.width||(item.label.length >=4 ?'160':item.label.length==3 ?'130':'100')"
|
align="center"
|
>
|
<template slot-scope="{ row }">
|
<el-input
|
v-if="editingRows === row && editShows== item.prop && item.prop != 'codeDateFormat' && (item.edit == 'text' ||item.edit == 'refer' )"
|
v-show="!AddCellFlag"
|
:ref="'input' + row.oid"
|
v-model="row[item.prop]"
|
@blur="saveRows(row)"
|
></el-input>
|
<el-input-number v-if="editingRows === row && editShows== item.prop && item.edit == 'number'"
|
v-model="row[item.prop]"
|
:style="{width:(item.width-10)+'px'}"
|
controls-position="right"
|
size="small" @blur="saveRows"></el-input-number>
|
<el-select v-if="editingRows === row && editShows== item.prop && item.edit == 'select' " slot="prepend"
|
v-model="row[item.prop]" allow-create default-first-option
|
filterable
|
@blur="selectChangeHandler(item.editConfig,index)">
|
<el-option
|
v-for="optionItem in item.data"
|
:key="optionItem.dictValue"
|
:label="optionItem.dictValue"
|
:value="optionItem.dictValue">
|
</el-option>
|
</el-select>
|
<el-switch
|
v-if="item.edit === 'switch'" v-model="row[item.prop]" :disabled="!editOpenFlag" active-value="true"
|
inactive-value="false">
|
</el-switch>
|
<span v-else>{{ row[item.prop] }}</span>
|
</template>
|
</el-table-column>
|
<el-table-column
|
fixed="right"
|
label="操作"
|
width="70">
|
<template slot-scope="scope">
|
<el-button
|
size="small"
|
type="text"
|
@click.native.prevent="CrudRowDel(scope.$index)">
|
移除
|
</el-button>
|
</template>
|
</el-table-column>
|
</el-table>
|
</div>
|
</template>
|
|
<script>
|
import {AttrByBtm, gridCodeClassifyTemplateAttr, batchAddSave, copyto, listByFlag} from '@/api/template/templateAttr'
|
import {getList} from "@/api/refer/table";
|
import func from "@/util/func";
|
import {getCurrentInstance} from "vue";
|
import {mapGetters} from "vuex";
|
|
export default {
|
name: "attrCrud .vue",
|
props: {
|
ProData: {
|
type: Array,
|
},
|
crudOid: {
|
type: String,
|
default: ''
|
},
|
checkStatus: {
|
type: Boolean,
|
default: false
|
},
|
//控制是否开启编辑
|
editOpenFlag: {
|
type: Boolean,
|
default: false
|
},
|
editStyleFlag: {
|
type: Boolean,
|
default: false
|
},
|
crudLCStatus: {
|
type: String,
|
default: 'Editing'
|
},
|
crudArray: {
|
type: Array,
|
},
|
Formlist: {
|
type: Array,
|
},
|
codeClassifyOid: {
|
type: String,
|
default: ''
|
},
|
attrFlagChiledren: {
|
type: Boolean,
|
default: false
|
},
|
crudArrayFlag: {
|
type: Boolean,
|
default: false
|
},
|
},
|
watch: {
|
crudOid: {
|
handler(newval, oldval) {
|
if (newval) {
|
this.editOpenFlag = false
|
}
|
}
|
},
|
crudArrayFlag: {
|
handler(newval, oldval) {
|
// console.log('crudArrayFlag', newval)
|
}
|
},
|
crudArray: {
|
handler(newval, oldval) {
|
if (newval != undefined) {
|
if (newval.length >= 1) {
|
this.crudArrayFlag = true
|
} else {
|
this.crudArrayFlag = false
|
}
|
}
|
},
|
deep: true,
|
immediate: true
|
},
|
Formlist: {
|
handler(newval, oldval) {
|
if (newval.length === 0) {
|
this.crudArrayFlag = false
|
return
|
}
|
}
|
},
|
ProData: {
|
handler(newval, oldval) {
|
if (newval) {
|
this.loading = true;
|
setTimeout(() => {
|
this.loading = false
|
}, 1000);
|
}
|
}
|
},
|
'injectOption.classifyInvokeAttr': function (newVal) {
|
if (newVal === "name") {
|
this.injectOption.classifyInvokeAttrName = '分类名称'
|
} else if (newVal === "id") {
|
this.injectOption.classifyInvokeAttrName = '分类代号'
|
}
|
return '';
|
},
|
editOpenFlag: {
|
handler(newval, oldval) {
|
// console.log('editOpenFlag', newval)
|
},
|
deep: true,
|
immediate: true
|
}
|
|
},
|
data() {
|
return {
|
//表格高度
|
dynamicHeight: '',
|
// 保存单元格状态
|
AddCellFlag: false,
|
//全屏编辑高度状态
|
editStyleFlag: false,
|
loading: false,
|
referConfigText: "",
|
referConfigVisble: false,
|
referConfigOption: {
|
referConfig: '',
|
},
|
screenWidth: document.documentElement.clientWidth, // 屏幕宽度
|
//当前单元格
|
CurrentCell: '',
|
// 新增
|
SelectValue: "",
|
SelectFInd: "",
|
SelectOption: [
|
{
|
value: 'name',
|
label: '属性中文名称'
|
},
|
{
|
value: 'id',
|
label: '属性英文名称'
|
}
|
],
|
//参照
|
referVisible: false,
|
crudArrayFlag: false,
|
editingRows: null,
|
editShows: "",
|
attrFlag: false,
|
referObject: {},
|
//编码申请预览option
|
applicationoption: {
|
column: []
|
},
|
// 编码申请预览data
|
applicationData: [],
|
//业务类型选择数组
|
busineSelectList: [],
|
//业务类型添加数据
|
busineAddList: {},
|
//表格单选数组
|
attrSelectList: [],
|
//表格oid
|
attrOid: "",
|
//场景变量
|
thisSceneTableData: [
|
{
|
formula: "lcstatus",
|
desc: "状态",
|
},
|
{
|
formula: "name",
|
desc: "集团码",
|
},
|
{
|
formula: "materialname",
|
desc: "部门名称",
|
},
|
{
|
formula: "parentcode",
|
desc: "上级部门编号",
|
},
|
{
|
formula: "parentname",
|
desc: "上级部门名称",
|
},
|
{
|
formula: "description",
|
desc: "描述",
|
},
|
],
|
// 系统变量
|
systemVariableTableData: [
|
{
|
formula: "#CURRENTUSER.OID#",
|
desc: "当前用户的主键",
|
},
|
{
|
formula: "#CURRENTUSER.ID",
|
desc: "当前用户的账户"
|
},
|
{
|
formula: "#CURRENTTIME#",
|
desc: "当前时间"
|
},
|
{
|
formula: "#CURRENTDATE#",
|
desc: "当前日期"
|
},
|
{
|
formula: "#CURRENTDATETIME#",
|
desc: "当前日期时间"
|
},
|
{
|
formula: "#CURRENTUSER_NAME#",
|
desc: "当前用户的姓名"
|
},
|
{
|
formula: "#CURRENTUSER.SECRETARIAT#",
|
desc: "当前用户密级"
|
},
|
{
|
formula: "#CURRENTUSER.IPSECRET#",
|
desc: "当前用户的IP密级"
|
},
|
{
|
formula: "#CURRENTUSER.BUSINESSUNIT#",
|
desc: "当前用户所属业务单元"
|
},
|
{
|
formula: "#CURRENTUSER.BUSINESSUNITNAME#",
|
desc: "当前用户所属业务单元名称"
|
},
|
{
|
formula: "#CURRENTUSER.GROUPOID#",
|
desc: "当前用户的部门主键"
|
},
|
{
|
formula: "#CURRENTUSER.GROUPNAME#",
|
desc: "当前用户所属部门名称"
|
},
|
{
|
formula: "#CURRENTUSER.EMAIL#",
|
desc: "当前用户邮件地址"
|
},
|
{
|
formula: "#CURRENTUSER.ROLENAME#",
|
desc: "当前用户所属角色名称 "
|
},
|
],
|
CascadeVisible: false,
|
attrEditVisible: false,
|
isShowformulaEdit: false,
|
// 级联单选
|
selectRow: '',
|
//级联单选数组
|
selectRowArr: [],
|
// 级联data
|
CascadeData: [],
|
// 级联option
|
CascadeOption: {
|
menu: false,
|
addBtn: false,
|
header: false,
|
align: 'center',
|
columnBtn: false,
|
menuAlign: 'center',
|
column: [{
|
label: '',
|
prop: 'radio',
|
width: 60,
|
hide: false,
|
},
|
{
|
label: '属性英文编号',
|
prop: 'id'
|
},
|
{
|
label: '属性中文名称',
|
prop: 'name'
|
},
|
{
|
label: '属性分组',
|
prop: 'attributeGroup'
|
},
|
{
|
label: '类型',
|
prop: 'attributeDataTypeText'
|
},
|
{
|
label: '列表宽度',
|
prop: 'attrTableWidth'
|
},
|
{
|
label: '关键属性',
|
prop: 'keyAttrFlag',
|
type: 'text',
|
dicData: [
|
{
|
label: "是",
|
value: 'true'
|
},
|
{
|
label: "否",
|
value: 'false'
|
}
|
]
|
},
|
{
|
label: '查询属性',
|
prop: 'queryAttrFlag',
|
type: 'text',
|
dicData: [
|
{
|
label: "是",
|
value: 'true'
|
},
|
{
|
label: "否",
|
value: 'false'
|
}
|
]
|
},
|
{
|
label: '高级查询属性',
|
prop: 'seniorQueryAttrFlag',
|
type: 'text',
|
dicData: [
|
{
|
label: "是",
|
value: 'true'
|
},
|
{
|
label: "否",
|
value: 'false'
|
}
|
]
|
},
|
{
|
label: '相似查重属性',
|
prop: 'sameRepeatAttrFlag',
|
type: 'text',
|
dicData: [
|
{
|
label: "是",
|
value: 'true'
|
},
|
{
|
label: "否",
|
value: 'false'
|
}
|
]
|
},
|
{
|
label: '一维码',
|
prop: 'OneDimensional'
|
},
|
{
|
label: '二维码',
|
prop: 'TwoDimensional'
|
},
|
{
|
label: '必输',
|
prop: 'requireFlag',
|
type: 'text',
|
dicData: [
|
{
|
label: "是",
|
value: 'true'
|
},
|
{
|
label: "否",
|
value: 'false'
|
}
|
]
|
},
|
{
|
label: "表单显示",
|
prop: "formDisplayFlag",
|
type: 'text',
|
dicData: [
|
{
|
label: "是",
|
value: 'true'
|
},
|
{
|
label: "否",
|
value: 'false'
|
}
|
]
|
},
|
{
|
label: "列表显示",
|
prop: "tableDisplayFlag",
|
type: 'text',
|
dicData: [
|
{
|
label: "是",
|
value: 'true'
|
},
|
{
|
label: "否",
|
value: 'false'
|
}
|
]
|
},
|
{
|
label: "只读",
|
prop: "readonlyFlag",
|
},
|
{
|
label: "列表排序",
|
prop: "sortAttrFlag",
|
type: 'text',
|
dicData: [
|
{
|
label: "是",
|
value: 'true'
|
},
|
{
|
label: "否",
|
value: 'false'
|
}
|
]
|
},
|
|
{
|
label: "多行文本",
|
prop: "textAreaFlag",
|
type: 'text',
|
dicData: [
|
{
|
label: "是",
|
value: 'true'
|
},
|
{
|
label: "否",
|
value: 'false'
|
}
|
]
|
},
|
{
|
label: "默认值",
|
prop: "defaultValue",
|
},
|
{
|
label: "前缀",
|
prop: "prefixValue",
|
},
|
{
|
label: "后缀",
|
prop: "suffixValue",
|
},
|
{
|
label: "组合规则",
|
prop: "componentRule",
|
},
|
{
|
label: "验证规则",
|
prop: "verifyRule",
|
},
|
{
|
label: "时间格式",
|
prop: "codeDateFormat",
|
},
|
{
|
label: "分类注入",
|
prop: "classifyInvokeLevel",
|
},
|
{
|
label: "枚举注入",
|
prop: "enumString",
|
},
|
{
|
label: "级联属性",
|
prop: "parentCode",
|
},
|
{
|
label: "参照配置",
|
prop: "referConfig",
|
width: 105
|
},
|
{
|
label: "级联查询属性",
|
prop: "parentQueryAttr",
|
},
|
{
|
label: "选择库标识",
|
prop: "libraryIdentification",
|
},
|
{
|
label: "填写提示",
|
prop: "explain",
|
},
|
{
|
label: "表单显示样式",
|
prop: "formDisplayStyle",
|
},
|
{
|
label: "表格显示样式",
|
prop: "tableDisplayStyle",
|
},
|
{
|
label: "表单超链接",
|
prop: "formHref",
|
},
|
{
|
label: "表格超链接",
|
prop: "tableHref",
|
},
|
{
|
label: "表格显示js",
|
prop: "tableDisplayJs",
|
},
|
{
|
label: "长度",
|
prop: "controlLength",
|
},
|
{
|
label: "小数精度",
|
prop: "precisionLength",
|
},
|
{
|
label: "取值范围",
|
prop: "valueArea",
|
}
|
]
|
},
|
// 存储表格数据
|
tableData: [],
|
// 存储正在编辑的行
|
editingRow: null,
|
editShow: "",
|
//枚举注入
|
enumVisible: false,
|
//枚举注入多选保存数组
|
enumRow: [],
|
// 分类注入弹出框
|
injectVisible: false,
|
// 添加弹出框
|
addVisible: false,
|
//验证规则弹出框
|
rulesVisible: false,
|
//属性分组弹出框
|
attrVisible: false,
|
//属性分组输入框
|
attrModel: "",
|
//当前单选模板属性
|
attrRow: {},
|
//编码申请预览弹出框
|
addvisible: false,
|
//分类注入option
|
injectOption: {
|
classifyInvokeAttrName: '分类名称',
|
classifyInvokeAttr: "name",
|
classifyInvokeEditFlag: "true",
|
classifyInvokeLevel: 'min',
|
//分类注入计数器
|
classifyNumber: 0,
|
},
|
// 属性验证输入框
|
RulesForm: {
|
expressionText: "",
|
TestContent: "",
|
ruleRowBds: ""
|
},
|
//属性验证规则配置
|
rulesOption: {
|
border: true,
|
menu: false,
|
addBtn: false,
|
refreshBtn: false,
|
columnBtn: false,
|
header: false,
|
toolBtn: [],
|
column: [
|
{
|
label: "表达式",
|
prop: "bds"
|
},
|
{
|
label: "使用说明",
|
prop: "description"
|
}
|
]
|
},
|
//属性验证规则data
|
rulesData: [
|
{bds: '[\u3000\uff01-\uff5f]+', description: '全角符号'},
|
{bds: '[^\u3000\uff01-\uff5f]+', description: '半角符号'},
|
{bds: '(([-|+]{1}[\\d]+℃～[-|+]{1}[\\d]+℃)|无)', description: '温度范围，示例 -55℃～+125℃'},
|
{bds: '[\\d]{15}|[\\d]{18}|[\\d]{17}X', description: '身份证号码(15或18位数字、17位数字X) '},
|
{bds: '男|女|男性|女性', description: '中文性别'},
|
{bds: '[\\d]+', description: '数字'},
|
{bds: '[a-zA-Z]+', description: '字母'},
|
{bds: '[A-Z]+', description: '大写字母'},
|
{bds: '[a-z]+', description: '小写字母'},
|
{bds: '[0-9a-zA-Z]+', description: '字母、数字组合'},
|
{bds: '((0[\\d]{3}-[\\d]{7})|(0[\\d]{2}-[\\d]{8})|([\\d]{7,8}))', description: '电话号码'},
|
{bds: '-?[1-9]\\d*', description: '整数'},
|
{bds: '[1-9]\\d*', description: '正整数'},
|
{bds: '-[1-9]\\d*', description: '负整数'},
|
{bds: '-[1-9]\\d*|0', description: '非正整数(负整数+0)'},
|
{bds: '[1-9]\\d*|0', description: '非负整数(正整数+0)'},
|
{bds: '-?([1-9]\\d*\\.\\d*|0\\.\\d*[1-9]\\d*|0?\\.0+|0)', description: '浮点数'},
|
{bds: '[1-9]\\d*\\.\\d*|0\\.\\d*[1-9]\\d*', description: '正浮点数'},
|
{bds: '-[1-9]\\d*\\.\\d*|0\\.\\d*[1-9]\\d*', description: '负浮点数'},
|
{bds: '[(-([1-9]\\d*\\.\\d*|0\\.\\d*[1-9]\\d*))|0?\\.0+|0', description: '非正浮点数（负浮点数 + 0）'},
|
{bds: '[1-9]\\d*\\.\\d*|0\\.\\d*[1-9]\\d*|0?\\.0+|0', description: '非负浮点数（正浮点数 + 0）'},
|
{bds: 'x', description: '字符 x'},
|
{bds: '\\\\', description: '反斜线字符'},
|
{bds: '\\0n', description: '带有八进制值 0 的字符 n (0 <= n <= 7)'},
|
{bds: '\\0nn', description: '带有八进制值 0 的字符 nn (0 <= n <= 7)'},
|
{bds: '\\0mnn', description: '带有八进制值 0 的字符 mnn（0 <= m <= 3、0 <= n <= 7）'},
|
{bds: '\\xhh', description: '带有十六进制值 0x 的字符 hh'},
|
{bds: '\\uhhhh', description: '带有十六进制值 0x 的字符 hhhh'},
|
{bds: '\\t', description: '制表符 (\'\u0009\')'},
|
{bds: '\\n', description: '新行（换行）符 (\'\u000A\')'},
|
{bds: '\\r', description: '回车符 (\'\u000D\')'},
|
{bds: '\\f', description: '换页符 (\'\u000C\')'},
|
{bds: '\\a', description: '报警 (bell) 符 (\'\u0007\')'},
|
{bds: '\\e', description: '转义符 (\'\u001B\')'},
|
{bds: '\\cx', description: '对应于 x 的控制符'},
|
{bds: '[abc]', description: 'a、b 或 c（简单类）'},
|
{bds: '[^abc]', description: '任何字符，除了 a、b 或 c（否定）'},
|
{bds: '[a-zA-Z]', description: 'a 到 z 或 A 到 Z，两头的字母包括在内（范围）'},
|
{bds: '[a-d[m-p]]', description: 'a 到 d 或 m 到 p：[a-dm-p]（并集）'},
|
{bds: '[a-z&&[def]]', description: '\td、e 或 f（交集）'},
|
{bds: '[a-z&&[^bc]]', description: 'a 到 z，除了 b 和 c：[ad-z]（减去）'},
|
{bds: '[a-z&&[^m-p]]', description: 'a 到 z，而非 m 到 p：[a-lq-z]（减去）'},
|
{bds: '.', description: '任何字符（与行结束符可能匹配也可能不匹配）'},
|
{bds: '\\d', description: '数字：[0-9]'},
|
{bds: '\\D', description: '非数字： [^0-9]'},
|
{bds: '\\s', description: '空白字符：[ \\t\\n\x0B\\f\\r]'},
|
{bds: '\\S', description: '非空白字符：[^\\s]'},
|
{bds: '\\w', description: '单词字符：[a-zA-Z_0-9]'},
|
{bds: '\\W', description: '非单词字符：[^\\w]'},
|
{bds: '\\p{Lower}', description: '小写字母字符：[a-z]'},
|
{bds: '\\p{Upper}', description: '大写字母字符：[A-Z]'},
|
{bds: '\\p{ASCII}', description: '所有 ASCII：[\x00-\x7F]'},
|
{bds: '\\p{Alpha}', description: '字母字符：[\\p{Lower}\\p{Upper}]'},
|
{bds: '\\p{Digit}', description: '十进制数字：[0-9]'},
|
{bds: '\\p{Alnum}', description: '字母数字字符：[\\p{Alpha}\\p{Digit}]'},
|
{bds: '\\p{Punct}', description: '标点符号：!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'},
|
{bds: '\\p{Graph}', description: '可见字符：[\\p{Alnum}\\p{Punct}]'},
|
{bds: '\\p{Print}', description: '可打印字符：[\\p{Graph}\x20]'},
|
{bds: '\\p{Blank}', description: '空格或制表符：[ \\t]'},
|
{bds: '\\p{Cntrl}', description: '控制字符：[\x00-\x1F\x7F]'},
|
{bds: '\\p{XDigit}', description: '十六进制数字：[0-9a-fA-F]'},
|
{bds: '\\p{Space}', description: '空白字符：[ \\t\\n\x0B\\f\\r]'},
|
{bds: '\\p{javaLowerCase}', description: '等效于 java.lang.Character.isLowerCase()'},
|
{bds: '\\p{javaUpperCase}', description: '等效于 java.lang.Character.isUpperCase()'},
|
{bds: '\\p{javaWhitespace}', description: '等效于 java.lang.Character.isWhitespace()'},
|
{bds: '\\p{javaMirrored}', description: '等效于 java.lang.Character.isMirrored()'},
|
{bds: '\\p{InGreek}', description: 'Greek 块（简单块）中的字符'},
|
{bds: '\\p{Lu}', description: '大写字母（简单类别）'},
|
{bds: '\\p{Sc}', description: '货币符号'},
|
{bds: '\\P{InGreek}', description: '所有字符，Greek 块中的除外（否定）'},
|
{bds: '[\\p{L}&&[^\\p{Lu}]]', description: '所有字母，大写字母除外（减去）'},
|
{bds: '^', description: '行的开头'},
|
{bds: '$', description: '行的结尾'},
|
{bds: '\\b', description: '单词边界'},
|
{bds: '\\B', description: '非单词边界'},
|
{bds: '\\A', description: '输入的开头'},
|
{bds: '\\G', description: '上一个匹配的结尾'},
|
{bds: '\\Z', description: '输入的结尾，仅用于最后的结束符（如果有的话）'},
|
{bds: '\\z', description: '输入的结尾'},
|
{bds: 'X ?', description: 'X，一次或一次也没有'},
|
{bds: 'X *', description: 'X，零次或多次'},
|
{bds: 'X +', description: 'X，一次或多次'},
|
{bds: 'X {n }', description: 'X，恰好 n 次'},
|
{bds: 'X {n ,}', description: 'X，至少 n 次'},
|
{bds: 'X {n ,m }', description: 'X，至少 n 次，但是不超过 m 次'},
|
{bds: 'X ??', description: 'X，一次或一次也没有'},
|
{bds: 'X *?', description: 'X，零次或多次'},
|
{bds: 'X +?', description: 'X，一次或多次'},
|
{bds: 'X {n }?', description: 'X，恰好 n 次'},
|
{bds: 'X {n ,}?', description: 'X，至少 n 次'},
|
{bds: 'X {n ,m }?', description: 'X，至少 n 次，但是不超过 m 次'},
|
{bds: 'X ?+', description: 'X，一次或一次也没有'},
|
{bds: 'X *+', description: 'X，零次或多次'},
|
{bds: 'X ++', description: 'X，一次或多次'},
|
{bds: 'X {n }+', description: 'X，恰好 n 次'},
|
{bds: 'X {n ,}+', description: 'X，至少 n 次'},
|
{bds: 'X {n ,m }+', description: 'X，至少 n 次，但是不超过 m 次'},
|
{bds: 'XY', description: 'X 后跟 Y'},
|
{bds: 'X |Y', description: 'X 或 Y'},
|
{bds: '(X )', description: 'X，作为捕获组'},
|
{bds: '\\n', description: '任何匹配的 n<sup>th</sup> 捕获组'},
|
{bds: '\\', description: 'Nothing，但是引用以下字符'},
|
{bds: '\\Q', description: 'Nothing，但是引用所有字符，直到 \\E'},
|
{bds: '\\E', description: 'Nothing，但是结束从 \\Q 开始的引用'},
|
{bds: '(?:X )', description: 'X，作为非捕获组'},
|
{bds: '(?idmsux-idmsux)', description: 'Nothing，但是将匹配标志由 on 转为 off'},
|
{bds: '(?idmsux-idmsux:X )', description: 'X，作为带有给定标志 on - off 的非捕获组'},
|
{bds: '(?=X )', description: 'X，通过零宽度的正 lookahead'},
|
{bds: '(?!X )', description: 'X，通过零宽度的负 lookahead'},
|
{bds: '(?<=X )', description: 'X，通过零宽度的正 lookbehind'},
|
{bds: '(?<!X )', description: 'X，通过零宽度的负 lookbehind'},
|
{bds: '(?>X )', description: 'X，作为独立的非捕获组'}
|
],
|
// 新增业务类型
|
businessData: [],
|
businessOption: {
|
indexClassName: "序号",
|
indexLabelClassName: '序号',
|
index: true,
|
border: true,
|
addBtn: false,
|
menu: false,
|
selection: true,
|
height: 500,
|
column: [
|
{
|
label: "属性英文名称",
|
prop: "id",
|
width: 100,
|
},
|
{
|
label: "属性中文名称",
|
prop: "name",
|
width: 100,
|
},
|
{
|
label: "长度",
|
prop: "attributeLength"
|
},
|
{
|
label: "数据类型",
|
prop: "attrDataType",
|
formatter: function (row, column) {
|
let vciFieldTypeMap = {
|
VTBoolean: "布尔型",
|
VTClob: "长文本",
|
VTDate: "日期",
|
VTDateTime: "日期时间",
|
VTTime: "时间",
|
VTLong: "长整型",
|
VTDouble: "金额/双精度",
|
VTInteger: "整形",
|
VTFilePath: "文件",
|
VTString: "字符串"
|
}
|
return vciFieldTypeMap[row.attrDataType];
|
}
|
},
|
{
|
label: "可空",
|
prop: "nullableFlag",
|
formatter: function (row, column) {
|
return row.nullableFlag == 'true' || row.nullableFlag == '1' ? '是' : '否'
|
}
|
},
|
{
|
label: "默认值",
|
prop: "defaultValue"
|
},
|
{
|
label: "小数精度",
|
prop: "precisionLength"
|
},
|
{
|
label: "小数刻度",
|
prop: "scaleLength"
|
},
|
{
|
label: "取值范围",
|
prop: "range"
|
},
|
{
|
label: "参照",
|
prop: "referFlag",
|
formatter: function (d) {
|
if (!d.referFlag) {
|
return '';
|
} else {
|
return d.referBtmTypeId
|
}
|
}
|
},
|
{
|
label: "枚举",
|
prop: "enumFlag",
|
formatter: function (d) {
|
if (!d.enumFlag) {
|
return '';
|
} else {
|
return d.enumId
|
}
|
}
|
},
|
]
|
},
|
//模板属性
|
data: [],
|
// 当前行
|
rowList: [],
|
// 当前单元格
|
rowCellList: [],
|
List: [],
|
option: {
|
index: false,
|
columnBtn: false,
|
border: true,
|
editBtn: false,
|
selection: true,
|
labelWidth: 110,
|
cellBtn: true,
|
cancelBtn: false,
|
addBtn: false,
|
width: 300,
|
defaultSort: {
|
prop: 'name',
|
order: 'descending'
|
},
|
column: [{
|
prop: 'orderNum',
|
label: '排序号',
|
sortable: true,
|
edit: 'number',
|
width: 90,
|
fixed: true
|
}, {
|
label: "属性英文编号",
|
prop: "id",
|
fixed: true,
|
cell: false,
|
labelWidth: 110,
|
width: 125,
|
sortable: false,
|
},
|
{
|
label: "属性中文名称",
|
prop: "name",
|
fixed: true,
|
cell: false,
|
width: 145,
|
edit: 'text',
|
sortable: true
|
},
|
{
|
label: "属性分组",
|
prop: "attributeGroup",
|
cell: false,
|
sortable: true,
|
edit: 'text',
|
width: 125,
|
},
|
{
|
label: "类型",
|
prop: "attributeDataTypeText",
|
cell: false,
|
sortable: true,
|
},
|
{
|
label: "列表宽度",
|
prop: "attrTableWidth",
|
cell: false,
|
sortable: true,
|
width: 105,
|
edit: 'number'
|
},
|
{
|
label: "关键属性",
|
prop: "keyAttrFlag",
|
cell: false,
|
edit: "switch"
|
},
|
{
|
label: "查询属性",
|
prop: "queryAttrFlag",
|
cell: false,
|
edit: "switch"
|
},
|
{
|
label: "高级查询属性",
|
prop: "seniorQueryAttrFlag",
|
width: 110,
|
cell: false,
|
edit: "switch"
|
},
|
{
|
label: "相似查重属性",
|
prop: "sameRepeatAttrFlag",
|
width: 110,
|
cell: false,
|
edit: "switch"
|
},
|
{
|
label: "必输",
|
prop: "requireFlag",
|
cell: false,
|
edit: "switch"
|
},
|
{
|
label: "表单显示",
|
prop: "formDisplayFlag",
|
cell: false,
|
edit: "switch"
|
},
|
{
|
label: "列表显示",
|
prop: "tableDisplayFlag",
|
cell: false,
|
edit: "switch"
|
},
|
{
|
label: "只读",
|
prop: "readonlyFlag",
|
cell: false,
|
edit: "switch"
|
},
|
{
|
label: "列表排序",
|
prop: "sortAttrFlag",
|
cell: false,
|
edit: "switch"
|
},
|
{
|
label: "多行文本",
|
prop: "textareaFlag",
|
cell: false,
|
edit: "switch"
|
},
|
{
|
label: "默认值",
|
prop: "defaultValue",
|
sortable: true,
|
cell: false,
|
edit: 'text',
|
width: 95,
|
},
|
{
|
label: "前缀",
|
prop: "prefixValue",
|
sortable: true,
|
edit: 'select',
|
width: 110,
|
editConfig: {
|
extraParams: {
|
code: 'codeclstempattr',
|
dictKey: 'prefix'
|
}
|
},
|
cell: false,
|
},
|
{
|
label: "后缀",
|
prop: "suffixValue",
|
sortable: true,
|
edit: 'select',
|
width: 110,
|
editConfig: {
|
extraParams: {
|
code: 'codeclstempattr',
|
dictKey: 'suffix'
|
}
|
},
|
cell: false,
|
},
|
{
|
label: "组合规则",
|
prop: "componentRule",
|
sortable: true,
|
cell: false,
|
edit: 'refer',
|
width: 105,
|
},
|
{
|
label: "验证规则",
|
prop: "verifyRule",
|
sortable: true,
|
cell: false,
|
edit: 'refer',
|
width: 105,
|
},
|
{
|
label: "时间格式",
|
prop: "codeDateFormat",
|
sortable: true,
|
width: 135,
|
edit: 'select',
|
editConfig: {
|
extraParams: {
|
code: 'codeclstempattr',
|
dictKey: 'dateFormates'
|
}
|
},
|
cell: false,
|
},
|
{
|
label: "分类注入",
|
prop: "classifyInvokeText",
|
cell: false,
|
edit: 'refer'
|
},
|
{
|
label: "枚举注入",
|
prop: "enumString",
|
cell: false,
|
edit: 'refer'
|
},
|
{
|
label: "级联属性",
|
prop: "parentCode",
|
cell: false,
|
edit: 'refer'
|
},
|
{
|
label: "参照配置",
|
prop: "referConfig",
|
cell: false,
|
edit: 'refer'
|
},
|
{
|
label: "级联查询属性",
|
prop: "parentQueryAttr",
|
width: 105,
|
cell: false,
|
edit: 'text'
|
},
|
{
|
label: "选择库标识",
|
prop: "libraryIdentification",
|
width: 105,
|
cell: false,
|
edit: 'text'
|
},
|
{
|
label: "填写提示",
|
prop: "explain",
|
cell: false,
|
edit: 'text'
|
},
|
{
|
label: "表单显示样式",
|
prop: "formDisplayStyle",
|
width: 105,
|
cell: false,
|
edit: 'text'
|
},
|
{
|
label: "表格显示样式",
|
prop: "tableDisplayStyle",
|
width: 105,
|
cell: false,
|
edit: 'text'
|
},
|
{
|
label: "表单超链接",
|
prop: "formHref",
|
width: 95,
|
cell: false,
|
edit: 'text'
|
},
|
{
|
label: "表格超链接",
|
prop: "tableHref",
|
width: 95,
|
cell: false,
|
edit: 'text'
|
},
|
{
|
label: "表格显示js",
|
prop: "tableDisplayJs",
|
width: 95,
|
cell: false,
|
edit: 'text'
|
},
|
{
|
label: "长度",
|
prop: "controlLength",
|
cell: false
|
},
|
{
|
label: "小数精度",
|
prop: "precisionLength",
|
cell: false
|
},
|
{
|
label: "取值范围",
|
prop: "valueArea",
|
sortable: true,
|
cell: false,
|
width: 105,
|
edit: 'text'
|
},
|
],
|
List: []
|
},
|
vciFieldTypeMap: {
|
VTBoolean: "布尔型",
|
VTClob: "长文本",
|
VTDate: "日期",
|
VTDateTime: "日期时间",
|
VTTime: "时间",
|
VTLong: "长整型",
|
VTDouble: "金额/双精度",
|
VTInteger: "整形",
|
VTFilePath: "文件",
|
VTString: "字符串"
|
},
|
//时间格式下拉框
|
codeDataFlag: false,
|
// 组合规单元格编辑回填
|
componentRuleText: "",
|
//模板属性下拉设置switch
|
selectoptions: [{
|
value: 'keyAttrFlag',
|
label: '关键属性'
|
}, {
|
value: 'queryAttrFlag',
|
label: '查询属性'
|
}, {
|
value: 'seniorQueryAttrFlag',
|
label: '高级查询属性'
|
}, {
|
value: 'sameRepeatAttrFlag',
|
label: '相似查重属性'
|
}, {
|
value: 'barcodeFlag',
|
label: '一维码'
|
}, {
|
value: 'qrcodeFlag',
|
label: '二维码'
|
}, {
|
value: 'requireFlag',
|
label: '必输'
|
}, {
|
value: 'formDisplayFlag',
|
label: '表单显示'
|
}, {
|
value: 'tableDisplayFlag',
|
label: '列表显示'
|
}, {
|
value: 'readonlyFlag',
|
label: '只读'
|
}, {
|
value: 'sortAttrFlag',
|
label: '列表排序'
|
}, {
|
value: 'textareaFlag',
|
label: '多行文本'
|
}, {
|
value: 'imageFlag',
|
label: '预览图'
|
}],
|
//模板属性下拉选中值
|
selectvalue: 'keyAttrFlag',
|
switchvalue: 'false'
|
}
|
},
|
computed: {
|
...mapGetters(["permission"]),
|
permissionList() {
|
return {
|
busineStatus: this.vaildData(this.permission.classifyTree.attr_add, false),
|
fullscreenStatus: this.vaildData(this.permission.classifyTree.attr_view_edit, false),
|
ruleStatus: this.vaildData(this.permission.classifyTree.attr_rule, false),
|
attrStatus: this.vaildData(this.permission.classifyTree.attr_group, false),
|
saveStatus: this.vaildData(this.permission.classifyTree.attr_save, false),
|
resetStatus: this.vaildData(this.permission.classifyTree.attr_reset, false),
|
injectStatus: this.vaildData(this.permission.classifyTree.attr_inject, false),
|
isShowStatus: this.vaildData(this.permission.classifyTree.attr_formrule, false),
|
enumStatus: this.vaildData(this.permission.classifyTree.attr_enum, false),
|
cascadStatus: this.vaildData(this.permission.classifyTree.attr_parentcode, false),
|
syncStatus: this.vaildData(this.permission.classifyTree.attr_sync, false),
|
applicationStatus: this.vaildData(this.permission.classifyTree.attr_application, false),
|
orderStatus: this.vaildData(this.permission.classifyTree.attr_sort, false),
|
removeStatus: this.vaildData(this.permission.classifyTree.attr_delete, false),
|
}
|
},
|
attrOids() {
|
let oids = [];
|
this.attrSelectList.forEach(ele => {
|
oids.push(ele.oid);
|
});
|
return oids.join(",");
|
},
|
busineOids() {
|
let oids = [];
|
this.busineSelectList.forEach(ele => {
|
oids.push(ele.oid);
|
});
|
return oids.join(",");
|
},
|
tableHeight() {
|
if (this.editStyleFlag) {
|
return '800px'
|
} else {
|
return 'calc(100vh - 595px)'
|
}
|
}
|
},
|
mounted() {
|
},
|
created() {
|
this.option.column.forEach((item, index) => {
|
if (item.edit == 'select') {
|
this.selectChangeHandler(item.editConfig, index)
|
}
|
})
|
},
|
methods: {
|
//新增搜索
|
AddFindHandler() {
|
if (this.SelectValue == 'id') {
|
const masterParameter = {
|
'conditionMap[id]': this.SelectFInd
|
}
|
this.BuineAttrByBtm(masterParameter);
|
this.SelectValue = ""
|
this.SelectFInd = ""
|
} else if (this.SelectValue == 'name') {
|
const masterParameter = {
|
'conditionMap[name]': this.SelectFInd
|
}
|
this.BuineAttrByBtm(masterParameter)
|
this.SelectValue = ""
|
this.SelectFInd = ""
|
}
|
},
|
//参照配置子组件
|
echoReferConfig(val) {
|
this.referObject = val
|
this.$set(this.CurrentCell, 'referConfig', JSON.stringify(val))
|
|
},
|
//可输可选下拉
|
selectChangeHandler(editConfig, index) {
|
let that = this;
|
listByFlag(editConfig.extraParams).then(res => {
|
that.option.column[index].data = res.data.data;
|
})
|
},
|
//属性分组按钮
|
attrVisibleHandle() {
|
if (this.attrSelectList < 1) {
|
this.$message.warning('请选择模板属性')
|
} else {
|
this.attrVisible = true;
|
}
|
},
|
//属性分组提交
|
attrHandle() {
|
this.attrSelectList.forEach(item => {
|
item.attributeGroup = this.attrModel
|
})
|
if (this.CurrentCell) {
|
this.$set(this.CurrentCell, 'attributeGroup', this.attrModel);
|
} else {
|
this.$set(this.attrSelectList[0], 'attributeGroup', this.attrModel)
|
}
|
this.attrClose()
|
},
|
//属性分组清空
|
attrRemove() {
|
this.attrModel = ""
|
},
|
attrClose() {
|
this.attrModel = "";
|
this.attrVisible = false
|
},
|
//表格数据
|
CrudRend() {
|
if (this.crudOid != '') {
|
gridCodeClassifyTemplateAttr({'conditionMap[classifyTemplateOid]': this.crudOid, limit: -1}).then(res => {
|
this.loading = true
|
setTimeout(() => {
|
this.ProData = res.data.data;
|
this.loading = false
|
}, 1000);
|
|
}).catch(res => {
|
this.$message.error(res)
|
})
|
}
|
},
|
//业务类型保存
|
busineAddHandle() {
|
if (this.busineSelectList.length == 0) {
|
this.$message.warning('请选择属性集');
|
return false;
|
}
|
let ordernum = this.ProData.length;
|
this.busineSelectList.forEach((citem) => {
|
let isCopy = false;
|
this.ProData.forEach((item) => {
|
if (citem.id == item.id) {
|
isCopy = true;
|
return false;
|
}
|
})
|
if (!isCopy) {
|
citem.oid = ''
|
this.busineAddList = Object.assign(citem, {
|
orderNum: ++ordernum,
|
attributeDataType: citem.attrDataType,
|
attributeDataTypeText: this.vciFieldTypeMap[citem.attrDataType],
|
controlLength: citem.attributeLength,
|
valueArea: citem.range,
|
referbtmid: citem.referBtmTypeId,
|
referbtmname: citem.referBtmTypeName,
|
referConfig: '',
|
enumid: citem.enumId,
|
precisionLength: (citem.precisionLength ? citem.precisionLength : '') + (citem.scaleLength ? '(' + citem.scaleLength + ')' : ''),
|
classifyTemplateOid: this.crudOid,
|
classifytemplateoid: this.crudOid,
|
formDisplayFlag: 'true',
|
tableDisplayFlag: 'true',
|
sortAttrFlag: 'false',
|
queryAttrFlag: 'true',
|
seniorQueryAttrFlag: 'true',
|
attrTableWidth: 120,
|
ts: ""
|
})
|
this.ProData.push(JSON.parse(JSON.stringify(this.busineAddList)))
|
}
|
})
|
this.addVisible = false;
|
},
|
//业务类型选择
|
businessSelect(selection, row) {
|
this.busineSelectList = selection;
|
},
|
// 从业务类型中选择数据弹窗
|
busineHandle() {
|
this.addVisible = true;
|
this.busineSelectList = []
|
this.busineAddList = [];
|
this.BuineAttrByBtm();
|
this.$nextTick(() => {
|
this.$refs.AddOriginPlace.doLayout();
|
})
|
},
|
//业务类型数据
|
BuineAttrByBtm(masterParameter) {
|
AttrByBtm({'conditionMap[oid]': this.crudOid, ...masterParameter}).then(res => {
|
this.businessData = res.data.data;
|
})
|
},
|
// 级联属性按钮
|
CascadeHandle() {
|
if (this.attrSelectList.length > 1) {
|
this.$message.warning('只能选择一条模板属性')
|
} else if (this.attrSelectList.length < 1) {
|
this.$message.warning('请选择一条模板属性')
|
} else if (this.attrSelectList.length === 1) {
|
this.CascadeVisible = true;
|
gridCodeClassifyTemplateAttr({
|
'conditionMap[classifyTemplateOid]': this.Formlist[0].oid,
|
'conditionMap[oid_notequal]': this.attrOid
|
}).then(res => {
|
this.CascadeData = res.data.data;
|
})
|
}
|
},
|
//级联保存
|
CascadeAddHandle() {
|
let CascadeString = "";
|
CascadeString = this.selectRowArr.id + (this.selectRowArr.name);
|
if (this.CurrentCell) {
|
this.$set(this.CurrentCell, 'parentCode', CascadeString)
|
} else {
|
this.$set(this.attrSelectList[0], 'parentCode', CascadeString)
|
}
|
this.CascadeVisible = false;
|
},
|
//级联属性清除
|
casRemove() {
|
this.selectRow = "";
|
this.$set(this.CurrentCell, 'parentCode', this.selectRow);
|
this.CascadeVisible = false;
|
|
},
|
// 级联属性行单选
|
CascaderowClick(row) {
|
this.selectRow = row.$index;
|
this.selectRowArr = row
|
},
|
// 排序预览按钮
|
orderHandle() {
|
this.$refs.referAttrCrud.sort("orderNum");
|
},
|
//表格单选
|
selectHandle(selection, row) {
|
this.attrOid = row.oid;
|
this.attrRow = row;
|
},
|
//表格选择
|
selectionChange(list) {
|
this.attrSelectList = list;
|
},
|
rowClick(row) {
|
this.$refs.referAttrCrud.clearSelection();
|
this.attrSelectList = [row];
|
this.$refs.referAttrCrud.setCurrentRow(row);
|
this.$refs.referAttrCrud.toggleRowSelection(row); //选中当前行
|
|
this.attrOid = row.oid;
|
this.attrRow = row;
|
},
|
//保存
|
addsHandler(event) {
|
this.$refs.referAttrCrud.sort("orderNum");
|
var ischeck = true;
|
this.ProData.forEach((item, index) => {
|
if ((item.requireFlag && item.requireFlag.toString() == 'true') && (item.readOnlyFlag && item.readOnlyFlag.toString() == 'true')) {
|
this.$message.warning(item.name + "(" + item.id + ")必输的属性不能是只读");
|
ischeck = false;
|
return;
|
}
|
var num = 0;
|
if (item.componentRule) {
|
//组合规则
|
num++
|
}
|
if (item.enumString || item.enumId) {
|
//枚举
|
num++
|
}
|
if (item.referConfig || item.referBtmId) {
|
//参照
|
num++
|
}
|
if (item.codeDateFormat) {
|
//时间格式
|
num++
|
}
|
//如果空后台返回none
|
if (item.classifyInvokeLevel && item.classifyInvokeLevel != 'none') {
|
//分类注入
|
num++
|
}
|
if (num > 1 && ischeck) {
|
this.$message({
|
showClose: true,
|
message: item.name + "(" + item.id + ") 属性只能是组合规则，枚举，参照，时间格式，分类注入中的一种",
|
type: 'warning'
|
});
|
ischeck = false;
|
return;
|
}
|
})
|
if (!ischeck) {
|
return;
|
}
|
// 新函数用于执行batchAddSave方法
|
const executeBatchAddSave = () => {
|
batchAddSave(JSON.parse(JSON.stringify(this.ProData))).then(res => {
|
this.$message.success('保存成功')
|
this.editOpenFlag = false;
|
// 调用父组件修改按钮状态
|
this.$emit('editCloseChildren')
|
this.AddCellFlag = true;
|
}).catch(() => {
|
this.$message.warning('保存失败，请查看控制台输出！')
|
});
|
}
|
// 所有if条件和逻辑通过后调用executeBatchAddSave函数
|
executeBatchAddSave();
|
},
|
//表格行编辑
|
handleCellClicks(row, column) {
|
if (this.editOpenFlag) {
|
this.editingRows = row;
|
this.editShows = column.property;
|
this.rowOid = row.oid;
|
this.CurrentCell = row;
|
this.$nextTick(() => {
|
const inputs = this.$refs['input' + row.oid];
|
const input = inputs && inputs.length > 0 ? inputs[0].$el : null;
|
if (input) {
|
input.focus();
|
}
|
});
|
const columnActions = {
|
referConfig: () => {
|
this.referConfigVisble = true;
|
this.referConfigOption = {
|
referConfig: this.CurrentCell.referConfig || '',
|
}
|
if (this.CurrentCell.referConfig == '') {
|
this.referConfigOption = {
|
referConfig: '',
|
}
|
}
|
},
|
classifyInvokeText: () => {
|
this.injectVisible = true;
|
if (this.CurrentCell.classifyInvokeAttr != '') {
|
this.injectOption = {
|
classifyInvokeAttr: this.CurrentCell.classifyInvokeAttr,
|
classifyInvokeAttrName: this.CurrentCell.classifyInvokeAttrName,
|
classifyInvokeEditFlag: this.CurrentCell.classifyInvokeEditFlag,
|
classifyInvokeLevel: this.CurrentCell.classifyInvokeLevel == 'min' ? 'min' : 'max',
|
classifyNumber: this.CurrentCell.classifyInvokeLevel == 'min' ? '' : this.CurrentCell.classifyInvokeLevel
|
};
|
}
|
},
|
componentRule: () => {
|
this.isShowformulaEdit = true;
|
},
|
enumString: () => {
|
this.enumVisible = true;
|
this.tableData = [];
|
if (this.CurrentCell.enumString != "") {
|
this.tableData = JSON.parse(this.CurrentCell.enumString)
|
return;
|
}
|
},
|
parentCode: () => {
|
gridCodeClassifyTemplateAttr({
|
'conditionMap[classifyTemplateOid]': this.Formlist[0].oid,
|
'conditionMap[oid_notequal]': this.CurrentCell.oid,
|
limit: -1
|
}).then(res => {
|
this.CascadeData = res.data.data;
|
})
|
this.CascadeVisible = true;
|
},
|
verifyRule: () => {
|
this.RulesForm.expressionTextt = this.CurrentCell.verifyRule;
|
this.rulesVisible = true;
|
},
|
attributeGroup: () => {
|
this.attrVisible = true;
|
if (this.CurrentCell.attributeGroup !== '') {
|
this.attrModel = this.CurrentCell.attributeGroup
|
}
|
}
|
};
|
|
if (column.property in columnActions) {
|
columnActions[column.property]();
|
}
|
}
|
},
|
saveRows() {
|
this.editingRows = null;
|
this.editShows = null;
|
// const inputElement = document.querySelector(`#inputRef${this.CurrentCell.oid}`);
|
// if (inputElement) {
|
// inputElement.blur();
|
// }
|
},
|
// 枚举注入添加一行空数据
|
addRow() {
|
this.tableData.push(JSON.parse(JSON.stringify({
|
key: "",
|
value: ""
|
})));
|
},
|
// 枚举注入监听单元格点击事件并存储正在编辑的行
|
handleCellClick(row, column) {
|
this.editingRow = row;
|
this.editShow = column.property
|
},
|
//枚举注入删除
|
enumDeleteRow(row) {
|
this.tableData.splice(row.$index, 1)
|
},
|
//枚举注入按钮
|
enumVisHandle() {
|
if (this.attrSelectList.length > 1) {
|
this.$message.warning('只能选择一条模板属性')
|
} else if (this.attrSelectList < 1) {
|
this.$message.warning('请选择一条模板属性')
|
} else if (this.attrSelectList.length === 1) {
|
this.enumVisible = true;
|
if (this.attrSelectList[0].enumString != "") {
|
this.tableData = JSON.parse(this.attrSelectList[0].enumString)
|
return
|
}
|
|
}
|
},
|
enumBeforeClose(done) {
|
this.tableData = []
|
done()
|
},
|
enumCancell() {
|
this.tableData = []
|
this.enumVisible = false;
|
},
|
//枚举注入多选框
|
handleSelectionChange(row) {
|
this.enumRow = JSON.parse(JSON.stringify(row));
|
},
|
//枚举注入保存
|
enumAddHandle() {
|
if (this.tableData.length >= 1) {
|
let hasError = false; // 添加一个变量
|
this.tableData.forEach((item, index) => {
|
if (item.key === '') {
|
this.$message.warning(`第${index + 1}行的选项值不能为空`);
|
hasError = true;
|
return;
|
} else if (item.value === '') {
|
this.$message.warning(`第${index + 1}行的选项中文标签不能为空`);
|
hasError = true;
|
return;
|
}
|
});
|
// 保存执行逻辑
|
if (!hasError) {
|
if (this.CurrentCell) {
|
this.$set(this.CurrentCell, 'enumString', JSON.stringify(this.tableData));
|
this.enumVisible = false;
|
} else {
|
this.$set(this.attrSelectList[0], 'enumString', JSON.stringify(this.tableData));
|
this.tableData = [];
|
this.enumVisible = false;
|
}
|
}
|
} else {
|
this.$message.warning('请添加枚举注入数据！')
|
}
|
},
|
// 将正在编辑的行的状态变为 null，即退出编辑状态
|
saveRow() {
|
this.editingRow = null;
|
},
|
//验证规则按钮
|
ruleAddHandler() {
|
if (this.attrSelectList < 1) {
|
this.$message.warning('请选择模板属性')
|
} else {
|
this.rulesVisible = true
|
}
|
|
},
|
//规则校验，双击表单事件
|
handleRulesRowDBLClick(row) {
|
this.ruleRowBds = row.bds
|
this.RulesForm.expressionText = row.bds
|
},
|
// 验证规则清除内容
|
rulesremove() {
|
this.RulesForm.expressionText = ""
|
this.RulesForm.TestContent = ""
|
this.$set(this.CurrentCell, 'verifyRule', '')
|
this.rulesVisible = false
|
},
|
// 验证规则确定
|
rulesHandle() {
|
if (this.CurrentCell) {
|
this.$set(this.CurrentCell, 'verifyRule', this.RulesForm.expressionText)
|
this.AddCellFlag = !this.AddCellFlag;
|
} else {
|
this.attrSelectList.forEach((item) => {
|
this.$set(item, 'verifyRule', this.RulesForm.expressionText)
|
})
|
this.rulesremove()
|
}
|
this.rulesVisible = false
|
},
|
//验证规则检查
|
rulesExamine() {
|
const regex = new RegExp(this.rulesData.ruleRowBds);
|
if (regex.test(this.RulesForm.TestContent)) {
|
this.$message.success('校验成功')
|
}
|
},
|
//点击分类注入按钮
|
injectBtn() {
|
if (this.attrSelectList.length > 1) {
|
this.$message.warning('只能选择一条模板数据')
|
} else if (this.attrSelectList.length < 1) {
|
this.$message.warning('请选择一条模板数据')
|
} else if (this.attrSelectList.length === 1) {
|
this.injectVisible = true;
|
}
|
},
|
//分类注入保存
|
injectAddHandle() {
|
const {
|
classifyInvokeAttr,
|
classifyInvokeAttrName,
|
classifyInvokeLevel,
|
classifyInvokeEditFlag,
|
classifyNumber
|
} = this.injectOption;
|
|
const data = {
|
"注入类型": classifyInvokeAttr,
|
"注入类型名称": classifyInvokeAttrName,
|
"层级设置": classifyInvokeLevel === 'max' ? classifyNumber : 'min',
|
"是否可修改": classifyInvokeEditFlag
|
};
|
for (const key in this.injectOption) {
|
this.attrSelectList[0][key] = this.injectOption[key];
|
if (classifyInvokeLevel !== 'min') {
|
this.attrSelectList[0].classifyInvokeLevel = classifyNumber;
|
} else {
|
this.attrSelectList[0].classifyInvokeLevel = 'min';
|
}
|
this.$set(this.attrSelectList[0], 'classifyInvokeText', data);
|
}
|
if (classifyInvokeLevel !== 'min') {
|
this.injectOption.classifyInvokeLevel = classifyNumber;
|
} else {
|
this.injectOption.classifyNumber = 0;
|
}
|
this.injectVisible = false;
|
},
|
//分类注入清空
|
injectHandleReset() {
|
this.$set(this.CurrentCell, 'classifyInvokeText', '')
|
this.$set(this.CurrentCell, 'classifyInvokeAttr:', '')
|
this.$set(this.CurrentCell, 'classitwInvokeAttrName', '')
|
this.$set(this.CurrentCell, 'classifyInvokeEditFlag', 'false')
|
this.$set(this.CurrentCell, 'classifyInvokeLevel', 'none')
|
this.injectVisible = false;
|
},
|
// 分类注入取消
|
injectRemove() {
|
this.injectVisible = false;
|
this.injectHandleReset()
|
},
|
//属性模板表格单元格点击事件
|
//表格操作栏删除
|
CrudRowDel(index) {
|
this.ProData.splice(index, 1)
|
},
|
//表格删除
|
CrudRemove() {
|
this.attrSelectList.forEach((item) => {
|
const index = this.ProData.indexOf(item);
|
this.ProData.splice(index, 1)
|
})
|
},
|
//表格重置
|
resetHandler() {
|
this.CrudRend()
|
},
|
//同步到其他模板
|
syncHandle() {
|
if (this.attrSelectList.length > 1) {
|
this.$message.warning('只能选择一条模板属性数据')
|
} else if (this.attrSelectList.length < 1) {
|
this.$message.warning('请选择一条模板属性数据')
|
} else if (this.attrSelectList.length === 1) {
|
copyto({oid: this.attrRow.oid}).then(res => {
|
this.$message.success('同步成功')
|
})
|
}
|
},
|
//编码申请预览
|
applicationHandle() {
|
this.addvisible = true;
|
},
|
//组合规则
|
isShowHandler() {
|
if (this.attrSelectList.length > 1) {
|
this.$message.warning('只能选择一条模板属性数据')
|
} else if (this.attrSelectList.length < 1) {
|
this.$message.warning('请选择一条模板属性数据')
|
} else if (this.attrSelectList.length === 1) {
|
this.isShowformulaEdit = true
|
}
|
},
|
//全屏编辑
|
fullscreenHandle() {
|
if (this.crudArray.length < 1) {
|
this.$message.warning('请选择一个模板')
|
} else {
|
this.editStyleFlag = true;
|
this.attrEditVisible = true;
|
this.attrFlag = true;
|
this.AddCellFlag = true;
|
}
|
|
},
|
//退出全屏编辑
|
escEdit() {
|
this.attrFlagChiledren = false;
|
this.attrEditVisible = false;
|
this.editStyleFlag = false;
|
},
|
//组合规则确定
|
updataFormlaContent(val) {
|
if (this.CurrentCell) {
|
this.$set(this.CurrentCell, 'componentRule', val.replace(/"/g, ''))
|
this.componentRuleText = this.CurrentCell.componentRule
|
} else {
|
this.$set(this.attrRow, 'componentRule', val.replace(/"/g, ''))
|
}
|
|
},
|
setReferConfigValue(content) {
|
let submitFormJson = JSON.stringify(content);
|
this.referConfigText = submitFormJson
|
if (this.CurrentCell) {
|
this.$set(this.CurrentCell, 'referConfig', JSON.stringify(content))
|
} else {
|
this.$set(this.attrRow, 'referConfig', JSON.stringify(content))
|
}
|
},
|
// 排序 this.AddCellFlag=false;
|
sortChange(val) {
|
// console.log(val)
|
},
|
//开启编辑
|
editOpen() {
|
this.editOpenFlag = true;
|
this.AddCellFlag = false;
|
},
|
//定义一个关闭编辑的方法供子组件使用
|
editClose() {
|
this.editOpenFlag = false;
|
},
|
//批量设置switch
|
batchSetFlag(value) {
|
this.attrSelectList.forEach(item => {
|
item[this.selectvalue] = value;
|
})
|
}
|
}
|
}
|
</script>
|
|
<style lang="scss" scoped>
|
//固定列高度
|
/deep/ .el-table__fixed {
|
height: calc(100vh - 612px) !important;
|
}
|
|
///deep/ .el-table__fixed[v-if='editStyleFlag'] {
|
// height: calc(100vh - 152px)!important; // 编辑状态下的高度
|
//}
|
// 滚动条样式修改
|
// 滚动条的宽度
|
/deep/ .el-table__body-wrapper::-webkit-scrollbar {
|
height: 15px; // 纵向滚动条 必写
|
background: white;
|
border: white;
|
width: 10px;
|
|
}
|
|
// 滚动条的滑块
|
/deep/ .el-table__body-wrapper::-webkit-scrollbar-thumb {
|
background-color: #ececec;
|
border-radius: 20px;
|
border: #ececec;
|
}
|
|
.app {
|
/deep/ .el-button {
|
//margin: 0 10px 10px 0;
|
}
|
}
|
|
.el-button-group {
|
margin-right: 10px;
|
margin-bottom: 10px;
|
}
|
</style>
|
