代码提交

 Source/UBCS-WEB/src/api/system/user.js

@@ -148,3 +148,14 @@
    }
  })
}

// 用户map列表查询
export const getByRoleUserList =(roleName) => {
  return request({
    url: '/api/ubcs-user/getByRoleUserList',
    method: 'get',
    params:{
      roleName
    }
  })
}

 Source/UBCS-WEB/src/components/code-dialog-page/referConfigFormDialog.vue

@@ -628,16 +628,18 @@
                                        // console.log(this.form);
                                    },
                                },{
                                    label: '是否开启持久化',
                                    label: '是否持久化参照配置',
                                    prop: 'isPersistence',
                                    labelWidth: '142',
                                    tip: 'true:开启持久化，对当前定义的参照配置进行持久化存储，下次可直接选取；false:仅对当前次码段新增生效。',
                                    tipPlacement: 'bottom',
                                    span: 6,
                                    type: 'switch',
                                },{
                                    display: this.form.isPersistence | this.form.isPersistence=='true',
                                    label: '编号',
                                    label: '参照配置编号',
                                    prop: 'id',
                                    tip: '设置该参照配置持久化存储时的编号。',
                                    rules: [{
                                        required: true,
                                        message: "(开启持久化时编号)必填项不能为空",
@@ -646,8 +648,9 @@
                                    span: 6,
                                },{
                                    display: this.form.isPersistence | this.form.isPersistence=='true',
                                    label: '名称',
                                    label: '参照配置名称',
                                    prop: 'name',
                                    tip: '设置该参照配置持久化存储时的名称。',
                                    rules: [{
                                        required: true,
                                        message: "(开启持久化时名称)必填项不能为空",

 Source/UBCS-WEB/src/views/code/code.vue

@@ -227,6 +227,27 @@
        <el-button @click="cloneOtherCodeRuleSettingBox = false">取 消</el-button>
      </div>
    </el-dialog>
    
    <!-- 编码规则,转移所有者对话框 -->
    <el-dialog
      :visible.sync="escapeOwnerVisible"
      append-to-body
      title="转移所有者"
      width="30%">
      <el-select v-model="ruleOwner" placeholder="请选择" class="selects">
        <el-option
          v-for="item in ruleAdminUserList"
          :key="item.VALUE"
          :label="item.LABLE"
          :value="item.VALUE"
          class="seloption">
        </el-option>
      </el-select>
        <span slot="footer" class="dialog-footer">
          <el-button @click="escapeOwnerVisible = false">取 消</el-button>
          <el-button type="primary" @click="escapeOwnerConfirm">确 定</el-button>
        </span>
    </el-dialog>

    <!-- 基础码段展示区域 -->
    <basic-container class="code-basicsec-container">
@@ -690,11 +711,11 @@
          </span>
        </el-form>
      </div>
      <!-- 第一层对话框的按钮和，线条 -->
      <!-- 第一层对话框的按钮和分隔线条 -->
      <el-divider class="horizontal-line" direction="horizontal"></el-divider>
      <div slot="footer" class="dialog-footer">
        <el-button type="primary" @click="saveOrEditBasicCode" v-show="showbtn">保 存</el-button>
        <el-button @click="addBasicCodeSettingBox = false" v-show="showbtn">取 消</el-button>
        <el-button type="primary" @click="saveOrEditBasicCode" :disabled="!showbtn">保 存</el-button>
        <el-button @click="addBasicCodeSettingBox = false">取 消</el-button>
      </div>

      <!--  第二层对话框,属性码段，属性选择对话框 -->
@@ -832,7 +853,7 @@
  import fixedValueOption from "@/const/code/fixedValueMgrDialog";
  import {mapGetters} from "vuex";
  import func from "@/util/func";
  import {MasterTable} from "@/api/GetItem";
  import {getByRoleUserList} from "@/api/system/user";

  export default {
      data() {
@@ -866,6 +887,10 @@
          cloneBasicOption: cloneBasicOption,
          cloneCodeRuleOption: cloneCodeRuleOption,
          selectionOtherCloneCodeBasicList: [], // 当前选中的基础码段
          /** 转移所有者对话框 */
          escapeOwnerVisible: false,
          ruleAdminUserList: [], //规则管理员列表
          ruleOwner: '', // 当前要转移给哪个规则管理员的ID

          /*使用范围对话框显示控制*/
          codeRangeSettingBox: false,
@@ -1108,6 +1133,37 @@
      },
      methods: {

        /** 转移规则所有者对话框 */
        escapeOwner(){
          if (this.selectionList.length === 0) {
            this.$message.warning("请选择一条编码规则！");
            return;
          }
          this.escapeOwnerVisible = true;
          getByRoleUserList("规则管理员").then(res=>{
            this.ruleAdminUserList = res.data.data;
          });
        },
        /** 确认转移所有者 */
        escapeOwnerConfirm(){
          if(!this.ruleOwner){
            this.$message.warning("请选择您要转移的规则管理员！");
            return;
          }
          this.selectionList[0].owner = this.ruleOwner;
          let data = this.selectionList[0];
          update(data).then(() => {
            this.onLoad(this.page);
            this.$message({
              type: "success",
              message: "规则转移成功!"
            });
            this.escapeOwnerVisible = false;
          }, error => {
            console.log(error);
          });
        },

        /** 高级查询对话框组件,组件返回的值是condtionMap[field]形式的查询条件，保留了和之前一样的方式 */
        echoSeniorContionMap(conditionMaps){
          //console.log(conditionMaps);
@@ -1133,7 +1189,6 @@
          //转换成JSON字符串进行父组件回显
          let submitFormJson = JSON.stringify(content);
          this.form.referConfig = submitFormJson || '';
          this.form.referValueInfo = submitFormJson || '';
        },
        /** 引用码段为【参照引用的业务类型】选取值之后的内容回显时调用 */
        echoReferBtmType(content){
@@ -1643,434 +1698,6 @@
          return currentRowClassOid!=updateClassOid;
        },


        /** 基础码段相关方法 */
        //防止打开过编辑窗口之后表单中存在值，所以需要清空,并初始化form表单属性
        clearBasicAddForm(){
          this.form = this.$options.data().form;
          // this.changeSectypeFormItems(null);
        },
        // 打开新增窗口
        openAddBasicCodeSec(){
          if(!this.tipsMessage(this.selectionList)){
            return;
          }
          if(this.selectionList[0].lcStatus != 'Editing'){
            this.$message.warning('编码规则状态不是"编辑中"，不允许编辑码段!');
            return;
          }
          this.openBasicDialog('add',null);
          this.loadCodeSecType();
        },
        // 打开新增或编辑基础码段对话框
        openBasicDialog(condition,row){
          //console.log(row);
          if(condition == 'add') {
            this.basicSecDialogTitle = '添加码段信息';
            this.showbtn = true;
            this.basicSecOnlyRead = false;
          }else if(condition == 'edit'){
            if(this.selectionList.length!=1){
              this.$message.warning('请选择一条编码规则数据!');
              return;
            }
            this.basicSecDialogTitle = '修改码段信息';
            this.showbtn = true;
            this.basicSecOnlyRead = false;
            //为form绑定值
          }else{
            this.basicSecDialogTitle = '查看码段信息';
            this.showbtn = false;
            this.basicSecOnlyRead = true;
          }
          //console.log(this.form);
          this.changeSectypeFormItems(condition == 'add' ? null:row);
          this.addBasicCodeSettingBox = true;
        },
        // 新增基础码段
        async saveOrEditBasicCode(){
          if(this.selectionList[0].oid == null ||  this.selectionList[0].oid == ''){
            this.$message.warning('缺失必要参数，请重新选择编码规则后再试!');
            return;
          }
          this.form.pkCodeRule = this.selectionList[0].oid;
          if(this.form.oid == '' || this.form.oid == null){
            if(this.checkForm()){
              await addSave(this.form).then(() => {
                this.$message({
                  type: "success",
                  message: "操作成功!"
                });
              }, error => {
                window.console.log(error);
              });
              // 关闭对话框
              this.addBasicCodeSettingBox = false
            }
            // 点击新增基础码段,关闭窗口之后触发重新加载
            this.loadBasic(this.selectionList[0]);
          }else{
            // 可能参照引用的业务类型会发生改变所以这儿直接对referConfig的json进行改变
            if(this.form.referConfig === "coderefersec" || this.form.referConfig != undefined){
              let referConfig = JSON.parse(this.form.referConfig);
              referConfig.referType = this.form.referBtmId;
              referConfig.referTypeName = this.form.referBtmName;
              this.form.referConfig = JSON.stringify(referConfig);
              let referValueInfo = JSON.parse(this.form.referValueInfo);
              referValueInfo.referType = this.form.referBtmId;
            }
            editSave(this.form).then(() => {
              this.$message({
                type: "success",
                message: "操作成功!"
              });
              }, error => {
                window.console.log(error);
            });
            this.loadBasic(this.selectionList[0]);
            // 关闭对话框
            this.addBasicCodeSettingBox = false
          }
        },
        // 因为elementui的表单校验设置不上所以采用判断的方式来做表单检验方式
        checkForm(){
          let form = this.form;
          //console.log(form);
          const regNumber = /^[0-9]+\.{0,1}[0-9]*$/; //数字或小数正则校验
          const regPos =  /^[0-9]*[1-9][0-9]*$/; //非负整数正则校验
          const tipsMsg = "必填项不能为空";
          if(form.id == ''){
            this.$message.warning("(码段编号)"+tipsMsg);
            this.$refs.id.$el.querySelector('input').focus();
            return false;
          }
          if(form.name == ''){
            this.$message.warning("(码段名称)"+tipsMsg);
            this.$refs.name.$el.querySelector('input').focus();
            return false;
          }
          if(form.secType == ''){
            this.$message.warning("(码段类型)"+tipsMsg);
            this.$refs.secType.$el.querySelector('select').focus();
            return false;
          }
          if(form.secType==='codefixedsec'){
            //固定码段
            if(form.codeSecLengthType == ''){
              this.$message.warning("(码段长度类型)"+tipsMsg);
              // this.$refs.codeSecLengthType.$el.querySelector('select').focus();
              return false;
            }
            if(form.codeSecLength == ''){
              this.$message.warning("(码段长度)"+tipsMsg);
              this.$refs.codeSecLength.$el.querySelector('input').focus();
              return false;
            }
            if(!regNumber.test(form.codeSecLength)){
              this.$message.warning("码段的长度必须为数字值");
              this.$refs.codeSecLength.$el.querySelector('input').focus();
              return false;
            }
          }else if(this.form.secType==='codeattrsec'){
            //属性码段
            if(form.referAttributeId == ''){
              this.$message.warning('(属性)'+tipsMsg);
              this.$refs.referAttributeId.$el.querySelector('input').focus();
              return false;
            }
          }else if(this.form.secType==='codeserialsec'){
            //console.log(form.codeFillType);
            //流水码段
            if(form.codeSecLength == ''){
              this.$message.warning('(码段的长度)'+tipsMsg);
              this.$refs.seriaCodeSecLength.$el.querySelector('input').focus();
              return false;
            }
            if(!regNumber.test(form.codeSecLength)){
              this.$message.warning('码段的长度必须为数字值');
              this.$refs.seriaCodeSecLength.$el.querySelector('input').focus();
              return false;
            }
            if(!regNumber.test(form.serialStart)){
              this.$message.warning('流水号的起始值必须为数字值');
              this.$refs.serialStart.$el.querySelector('input').focus();
              return false;
            }
            if(!regNumber.test(form.serialStep)){
              this.$message.warning('流水的步长必须为数字值');
              this.$refs.serialStep.$el.querySelector('input').focus();
              return false;
            }
            if(form.codeFillType == ''){
              this.$message.warning('(编码补位方式)'+tipsMsg);
              return false;
            }
            if(form.codeFillType != '不补位' && form.codeFillSeparator == ''){
              this.$message.warning('当补位方式为左补位或者右补位的时候，补位字符不能为空');
              return false;
            }
            if(form.codeFillLength == ''){
              this.$message.warning('填充长度不能为空');
              this.$refs.codeFillLength.$el.querySelector('input').focus();
              return false;
            }
            if(!regNumber.test(form.codeFillLength)){
              this.$message.warning('填充长度必须为数字值');
              this.$refs.codeFillLength.$el.querySelector('input').focus();
              return false;
            }
            if(form.codeFillLimit == ''){
              this.$message.warning('(流水上限)'+tipsMsg);
              this.$refs.codeFillLimit.$el.querySelector('input').focus();
              return false;
            }
            if(!regNumber.test(form.codeFillLimit)){
              this.$message.warning('流水上限必须为数字值');
              this.$refs.codeFillLimit.$el.querySelector('input').focus();
              return false;
            }
            // if(form.codeFillFlag == '' || ){
            //   this.$message.warning('(流水是否补码)'+tipsMsg);
            //   return false;
            // }
          }else if(this.form.secType==='codelevelsec'){
            //层级码段
            if(form.codeLevelType == ''){
              this.$message.warning('(层级类型)'+tipsMsg);
              return false;
            }
            if(form.codeLevelType != 'code_level_min'&& !regNumber.test(form.codeLevelValue)){
              this.$message.warning('(层级的值)只能填写数字');
              this.$refs.codeLevelValue.$el.querySelector('input').focus();
              return false;
            }
            if(form.valueCutType == ''){
              this.$message.warning('(字符截取类型)'+tipsMsg);
              // this.$refs.valueCutType.$el.querySelector('select').focus();
              return false;
            }
            if(form.valueCutType != 'code_cut_none' && !regPos.test(form.valueCutLength)){
              this.$message.warning('(值截取长度)只能填写正整数');
              this.$refs.valueCutLength.$el.querySelector('input').focus();
              return false;
            }
          }else if(this.form.secType==='coderefersec'){
            //引用码段
            if(form.referBtmId == ''){
              this.$message.warning('(参照引用的业务类型)'+tipsMsg);
              this.$refs.referBtmId.$el.querySelector('input').focus();
              return false;
            }
            if(form.referConfig == ''){
              this.$message.warning('(参照配置)'+tipsMsg);
              this.$refs.referConfig.$el.querySelector('input').focus();
              return false;
            }
          }else if(this.form.secType==='codedatesec'){
            //日期码段
            if(form.codeDateFormatStr == ''){
              this.$message.warning('(日期格式)'+tipsMsg);
              this.$refs.codeDateFormatStr.$el.querySelector('input').focus();
              return false;
            }
          }else if(this.form.secType==='codeclassifysec'){
            //分类码段
            if(form.codeSecLengthType == ''){
              this.$message.warning('(码段长度类型)'+tipsMsg);
              return false;
            }
            if(form.codeSecLength == ''){
              this.$message.warning('(码段长度)'+tipsMsg);
              this.$refs.classCodeSecLength.$el.querySelector('input').focus();
              return false;
            }
            if(!regNumber.test(form.codeSecLength)){
              this.$message.warning('码段的长度必须为数字值');
              this.$refs.classCodeSecLength.$el.querySelector('input').focus();
              return false;
            }
          }else if(this.form.secType==='codevariablesec'){
            //可变码段
            if(form.codeSecLength == ''){
              this.$message.warning('(码段长度)'+tipsMsg);
              this.$refs.varCodeSecLength.$el.querySelector('input').focus();
              return false;
            }
            if(!regNumber.test(form.codeSecLength)){
              this.$message.warning('码段的长度必须为数字值');
              this.$refs.classCodeSecLength.$el.querySelector('input').focus();
              return false;
            }
            if(form.codeFillType == ''){
              this.$message.warning('(编码补位方式)'+tipsMsg);
              return false;
            }
            // console.log(form);
            if(form.codeFillType != 'code_fill_none' && form.codeFillSeparator == ''){
              this.$message.warning('当补位方式为左补位或者右补位的时候，补位字符不能为空');
              return false;
            }
          }
          return true;
        },
        // 判断数据是否选择以及只能选择单条数据
        tipsMessage(list){
          if(list.length != 1){
            this.$message.warning("请选择一条编码规则数据!");
            return false;
          }
          return true;
        },
        // 基础码段删除
        deleteBasicCode(){
          if(!this.tipsMessage(this.selectionBasicList)){
            return;
          }
          let oid = this.selectionBasicList[0].oid;
          this.$confirm("是否删除这条数据？如果被引用将不能被删除！", {
            confirmButtonText: "确定",
            cancelButtonText: "取消",
            type: "warning"
          })
          .then(() => {
            let ts = new Date(this.selectionBasicList[0].ts).getTime();
            return deleteData({"oid": oid,"ts": ts});
          })
          .then(() => {
            this.loadBasic({"oid":this.currentCodeRuleOid == null || this.currentCodeRuleOid == '' ? this.selectionList[0].oid:this.currentCodeRuleOid});
            this.$message({
              type: "success",
              message: "操作成功!"
            });
            this.$refs.crudBasic.toggleSelection();
          });
        },
        // 点击触发加载基础码段信息
        loadBasic(row){
          if(this.cloneSettingBox){
            this.cloneTableLoading = true;
          }else{
            this.loadingBasic = true;
          }
          // console.log(row.oid);
          //存储当前关联的编码规则相关信息
          if(row!='' || row!=null){
            this.currentCodeRuleOid = row.oid;
            this.currentRuleLcStatus = row.lcStatus;
            this.sendGridCodeBasicSec({"pkCodeRule":row.oid},false);
          }
        },
        // 发送加载基础码段的请求
        sendGridCodeBasicSec(condition,isAdancedQuery/** 是否高级查询 */){
          // 如果当前基础码段表中的搜索按钮被隐藏，就需要在此开启
          if(this.selectionList.length>=0 && !this.$refs.crudBasic.option.column[0].search){
            this.hideBasicTable(true);
          }
          let conditionMaps = {};
          if(condition && !isAdancedQuery){
            Object.keys(condition).forEach(key=>{
              conditionMaps['conditionMap['+key+']'] = condition[key].trim();
            });
          }
          if(isAdancedQuery){
            condition['conditionMap[pkCodeRule]'] = this.currentCodeRuleOid == null || this.currentCodeRuleOid == ''
            ? this.selectionList[0].oid:this.currentCodeRuleOid;
          }
          gridCodeBasicSec(1, -1,isAdancedQuery ? condition:conditionMaps).then(res => {
            const data = res.data.data;
            if(this.cloneSettingBox){
              this.cloneData = data.records;
              // console.log(tihs.cloneData);
              this.cloneTableLoading = false;
            }else {
              this.basicData = data.records;
              // console.log(this.basicData);
              this.loadingBasic = false;
            }
          });
        },
        // 基础码段选中时触发
        selectionBasicChange(list) {
          this.selectionBasicList = list;
          this.$refs.crudBasic.setCurrentRow(this.selectionBasicList[list.length-1]);
          //console.log(this.selectionBasicList);
        },
        // 基础码段被单击表格行时触发
        codeBasicSecRowClick(row){
          this.$refs.crudBasic.toggleSelection();
          this.selectionBasicList = row;
          this.$refs.crudBasic.setCurrentRow(row);
          this.$refs.crudBasic.toggleRowSelection(row); //选中当前行
        },
        basicSearchChange(params, done){
          //console.log(this.$refs.crudBasic);
          this.sendGridCodeBasicSec(Object.assign(params,{"pkCodeRule":this.selectionList[this.selectionList.length-1].oid}),false);
          done();
        },
        basicSearchReset(){
          this.sendGridCodeBasicSec({"pkCodeRule":this.selectionList[this.selectionList.length-1].oid},false);
        },
        // 上移下移基础码段
        async upOrderNum(row){
          if(!this.tipsMessage(this.selectionList)){
            return;
          }
          if (this.selectionList[0].lcStatus != 'Editing') {
            this.$message.warning("只有编码规则的状态是 [编辑中] 的时候，才能调整码段顺序!");
            return;
          }
          if(row.oid==null || row.oid==''){
            this.$message.warning("未获取到必填参数!");
            return;
          }
          await upOrderNum(row.oid).then(() => {
            this.loadBasic(this.selectionList[0]);
            this.$message({
              type: "success",
              message: "操作成功!"
            });
          })
        },
        downOrderNum(row){
          //console.log(row.oid);
          if(!this.tipsMessage(this.selectionList)){
            return;
          }
          let codeRuleOid = this.selectionList[0].oid;
          //console.log(this.selectionList);
          if (this.selectionList[0].lcStatus != 'Editing') {
            this.$message.warning("只有编码规则的状态是 [编辑中] 的时候，才能调整码段顺序!");
            return;
          }
          if(row.oid==null || row.oid==''){
            this.$message.warning("未获取到必填参数!");
            return;
          }
          downOrderNum(row.oid).then(() => {
            this.loadBasic({"oid":codeRuleOid});
            this.$message({
              type: "success",
              message: "操作成功!"
            });
          })
        },
        // 基础码段刷新时查询
        refreshChangeBasicSec(){
          this.loadBasic(this.selectionList.at(-1));
        },
        // 操作基础码段中搜索清空等按钮的显示/隐藏
        hideBasicTable(hideBoolean){
          this.$refs.crudBasic.option.refreshBtn = hideBoolean;
          this.$refs.crudBasic.option.columnBtn = hideBoolean;
          this.$refs.crudBasic.option.column[0].search = hideBoolean;
          this.$refs.crudBasic.option.column[1].search = hideBoolean;
          if(!hideBoolean){
            this.selectionList = [];
            this.basicData = [];
          }
        },


        /** 编码规则相关方法 */
        // 打开高级查询窗口
        openAdvancedQuery(condition){
@@ -2424,15 +2051,6 @@
            this.loadBasic(this.selectionList[list.length-1]);
          }
        },
        changeCutType(value){
          if (value != 'code_cut_none'){
            if(this.form.valueCutLength == ''){
              this.form.valueCutLength = 1;
            }
          }else{
            this.form.valueCutLength = '';
          }
        },
        // 单击编码规则实现行选择
        codeRuleRowClick (row) {
          // console.log(this.currentRuleLcStatus);
@@ -2480,6 +2098,442 @@
          });
        },


        /** 基础码段相关方法 */
        //防止打开过编辑窗口之后表单中存在值，所以需要清空,并初始化form表单属性
        clearBasicAddForm(){
          this.form = this.$options.data().form;
          // this.changeSectypeFormItems(null);
        },
        // 打开新增窗口
        openAddBasicCodeSec(){
          if(!this.tipsMessage(this.selectionList)){
            return;
          }
          if(this.selectionList[0].lcStatus != 'Editing'){
            this.$message.warning('编码规则状态不是"编辑中"，不允许编辑码段!');
            return;
          }
          this.openBasicDialog('add',null);
          this.loadCodeSecType();
        },
        // 打开新增或编辑基础码段对话框
        openBasicDialog(condition,row){
          //console.log(row);
          if(condition == 'add') {
            this.basicSecDialogTitle = '添加码段信息';
            this.showbtn = true;
            this.basicSecOnlyRead = false;
          }else if(condition == 'edit'){
            if(this.selectionList.length!=1){
              this.$message.warning('请选择一条编码规则数据!');
              return;
            }
            this.basicSecDialogTitle = '修改码段信息';
            this.showbtn = true;
            this.basicSecOnlyRead = false;
            //为form绑定值
          }else{
            this.basicSecDialogTitle = '查看码段信息';
            this.showbtn = false;
            this.basicSecOnlyRead = true;
          }
          //console.log(this.form);
          this.changeSectypeFormItems(condition == 'add' ? null:row);
          this.addBasicCodeSettingBox = true;
        },
        // 新增基础码段
        async saveOrEditBasicCode(){
          if(this.selectionList[0].oid == null ||  this.selectionList[0].oid == ''){
            this.$message.warning('缺失必要参数，请重新选择编码规则后再试!');
            return;
          }
          this.form.pkCodeRule = this.selectionList[0].oid;
          if(this.form.oid == '' || this.form.oid == null){
            if(this.checkForm()){
              await addSave(this.form).then(() => {
                this.$message({
                  type: "success",
                  message: "操作成功!"
                });
              }, error => {
                window.console.log(error);
              });
              // 关闭对话框
              this.addBasicCodeSettingBox = false
            }
            // 点击新增基础码段,关闭窗口之后触发重新加载
            this.loadBasic(this.selectionList[0]);
          }else{
            // 可能参照引用的业务类型会发生改变所以这儿直接对referConfig的json进行改变
            if(this.form.referConfig === "coderefersec" || this.form.referConfig != undefined){
              let referConfig = JSON.parse(this.form.referConfig);
              referConfig.referType = this.form.referBtmId;
              referConfig.referTypeName = this.form.referBtmName;
              this.form.referConfig = JSON.stringify(referConfig);
              // let referValueInfo = JSON.parse(this.form.referValueInfo);
              // referValueInfo.referType = this.form.referBtmId;
            }
            editSave(this.form).then(() => {
              this.$message({
                type: "success",
                message: "操作成功!"
              });
              }, error => {
                window.console.log(error);
            });
            this.loadBasic(this.selectionList[0]);
            // 关闭对话框
            this.addBasicCodeSettingBox = false
          }
        },
        // 因为elementui的表单校验设置不上所以采用判断的方式来做表单检验方式
        checkForm(){
          let form = this.form;
          //console.log(form);
          const regNumber = /^[0-9]+\.{0,1}[0-9]*$/; //数字或小数正则校验
          const regPos =  /^[0-9]*[1-9][0-9]*$/; //非负整数正则校验
          const tipsMsg = "必填项不能为空";
          if(form.id == ''){
            this.$message.warning("(码段编号)"+tipsMsg);
            this.$refs.id.$el.querySelector('input').focus();
            return false;
          }
          if(form.name == ''){
            this.$message.warning("(码段名称)"+tipsMsg);
            this.$refs.name.$el.querySelector('input').focus();
            return false;
          }
          if(form.secType == ''){
            this.$message.warning("(码段类型)"+tipsMsg);
            this.$refs.secType.$el.querySelector('select').focus();
            return false;
          }
          if(form.secType==='codefixedsec'){
            //固定码段
            if(form.codeSecLengthType == ''){
              this.$message.warning("(码段长度类型)"+tipsMsg);
              // this.$refs.codeSecLengthType.$el.querySelector('select').focus();
              return false;
            }
            if(form.codeSecLength == ''){
              this.$message.warning("(码段长度)"+tipsMsg);
              this.$refs.codeSecLength.$el.querySelector('input').focus();
              return false;
            }
            if(!regNumber.test(form.codeSecLength)){
              this.$message.warning("码段的长度必须为数字值");
              this.$refs.codeSecLength.$el.querySelector('input').focus();
              return false;
            }
          }else if(this.form.secType==='codeattrsec'){
            //属性码段
            if(form.referAttributeId == ''){
              this.$message.warning('(属性)'+tipsMsg);
              this.$refs.referAttributeId.$el.querySelector('input').focus();
              return false;
            }
          }else if(this.form.secType==='codeserialsec'){
            //console.log(form.codeFillType);
            //流水码段
            if(form.codeSecLength == ''){
              this.$message.warning('(码段的长度)'+tipsMsg);
              this.$refs.seriaCodeSecLength.$el.querySelector('input').focus();
              return false;
            }
            if(!regNumber.test(form.codeSecLength)){
              this.$message.warning('码段的长度必须为数字值');
              this.$refs.seriaCodeSecLength.$el.querySelector('input').focus();
              return false;
            }
            if(!regNumber.test(form.serialStart)){
              this.$message.warning('流水号的起始值必须为数字值');
              this.$refs.serialStart.$el.querySelector('input').focus();
              return false;
            }
            if(!regNumber.test(form.serialStep)){
              this.$message.warning('流水的步长必须为数字值');
              this.$refs.serialStep.$el.querySelector('input').focus();
              return false;
            }
            if(form.codeFillType == ''){
              this.$message.warning('(编码补位方式)'+tipsMsg);
              return false;
            }
            if(form.codeFillType != '不补位' && form.codeFillSeparator == ''){
              this.$message.warning('当补位方式为左补位或者右补位的时候，补位字符不能为空');
              return false;
            }
            if(form.codeFillLength == ''){
              this.$message.warning('填充长度不能为空');
              this.$refs.codeFillLength.$el.querySelector('input').focus();
              return false;
            }
            if(!regNumber.test(form.codeFillLength)){
              this.$message.warning('填充长度必须为数字值');
              this.$refs.codeFillLength.$el.querySelector('input').focus();
              return false;
            }
            if(form.codeFillLimit == ''){
              this.$message.warning('(流水上限)'+tipsMsg);
              this.$refs.codeFillLimit.$el.querySelector('input').focus();
              return false;
            }
            if(!regNumber.test(form.codeFillLimit)){
              this.$message.warning('流水上限必须为数字值');
              this.$refs.codeFillLimit.$el.querySelector('input').focus();
              return false;
            }
            // if(form.codeFillFlag == '' || ){
            //   this.$message.warning('(流水是否补码)'+tipsMsg);
            //   return false;
            // }
          }else if(this.form.secType==='codelevelsec'){
            //层级码段
            if(form.codeLevelType == ''){
              this.$message.warning('(层级类型)'+tipsMsg);
              return false;
            }
            if(form.codeLevelType != 'code_level_min'&& !regNumber.test(form.codeLevelValue)){
              this.$message.warning('(层级的值)只能填写数字');
              this.$refs.codeLevelValue.$el.querySelector('input').focus();
              return false;
            }
            if(form.valueCutType == ''){
              this.$message.warning('(字符截取类型)'+tipsMsg);
              // this.$refs.valueCutType.$el.querySelector('select').focus();
              return false;
            }
            if(form.valueCutType != 'code_cut_none' && !regPos.test(form.valueCutLength)){
              this.$message.warning('(值截取长度)只能填写正整数');
              this.$refs.valueCutLength.$el.querySelector('input').focus();
              return false;
            }
          }else if(this.form.secType==='coderefersec'){
            //引用码段
            if(form.referBtmId == ''){
              this.$message.warning('(参照引用的业务类型)'+tipsMsg);
              this.$refs.referBtmId.$el.querySelector('input').focus();
              return false;
            }
            if(form.referConfig == ''){
              this.$message.warning('(参照配置)'+tipsMsg);
              this.$refs.referConfig.$el.querySelector('input').focus();
              return false;
            }
          }else if(this.form.secType==='codedatesec'){
            //日期码段
            if(form.codeDateFormatStr == ''){
              this.$message.warning('(日期格式)'+tipsMsg);
              this.$refs.codeDateFormatStr.$el.querySelector('input').focus();
              return false;
            }
          }else if(this.form.secType==='codeclassifysec'){
            //分类码段
            if(form.codeSecLengthType == ''){
              this.$message.warning('(码段长度类型)'+tipsMsg);
              return false;
            }
            if(form.codeSecLength == ''){
              this.$message.warning('(码段长度)'+tipsMsg);
              this.$refs.classCodeSecLength.$el.querySelector('input').focus();
              return false;
            }
            if(!regNumber.test(form.codeSecLength)){
              this.$message.warning('码段的长度必须为数字值');
              this.$refs.classCodeSecLength.$el.querySelector('input').focus();
              return false;
            }
          }else if(this.form.secType==='codevariablesec'){
            //可变码段
            if(form.codeSecLength == ''){
              this.$message.warning('(码段长度)'+tipsMsg);
              this.$refs.varCodeSecLength.$el.querySelector('input').focus();
              return false;
            }
            if(!regNumber.test(form.codeSecLength)){
              this.$message.warning('码段的长度必须为数字值');
              this.$refs.classCodeSecLength.$el.querySelector('input').focus();
              return false;
            }
            if(form.codeFillType == ''){
              this.$message.warning('(编码补位方式)'+tipsMsg);
              return false;
            }
            // console.log(form);
            if(form.codeFillType != 'code_fill_none' && form.codeFillSeparator == ''){
              this.$message.warning('当补位方式为左补位或者右补位的时候，补位字符不能为空');
              return false;
            }
          }
          return true;
        },
        // 判断数据是否选择以及只能选择单条数据
        tipsMessage(list){
          if(list.length != 1){
            this.$message.warning("请选择一条编码规则数据!");
            return false;
          }
          return true;
        },
        // 基础码段删除
        deleteBasicCode(){
          if(!this.tipsMessage(this.selectionBasicList)){
            return;
          }
          let oid = this.selectionBasicList[0].oid;
          this.$confirm("是否删除这条数据？如果被引用将不能被删除！", {
            confirmButtonText: "确定",
            cancelButtonText: "取消",
            type: "warning"
          })
          .then(() => {
            let ts = new Date(this.selectionBasicList[0].ts).getTime();
            return deleteData({"oid": oid,"ts": ts});
          })
          .then(() => {
            this.loadBasic({"oid":this.currentCodeRuleOid == null || this.currentCodeRuleOid == '' ? this.selectionList[0].oid:this.currentCodeRuleOid});
            this.$message({
              type: "success",
              message: "操作成功!"
            });
            this.$refs.crudBasic.toggleSelection();
          });
        },
        // 点击触发加载基础码段信息
        loadBasic(row){
          if(this.cloneSettingBox){
            this.cloneTableLoading = true;
          }else{
            this.loadingBasic = true;
          }
          // console.log(row.oid);
          //存储当前关联的编码规则相关信息
          if(row!='' || row!=null){
            this.currentCodeRuleOid = row.oid;
            this.currentRuleLcStatus = row.lcStatus;
            this.sendGridCodeBasicSec({"pkCodeRule":row.oid},false);
          }
        },
        // 发送加载基础码段的请求
        sendGridCodeBasicSec(condition,isAdancedQuery/** 是否高级查询 */){
          // 如果当前基础码段表中的搜索按钮被隐藏，就需要在此开启
          if(this.selectionList.length>=0 && !this.$refs.crudBasic.option.column[0].search){
            this.hideBasicTable(true);
          }
          let conditionMaps = {};
          if(condition && !isAdancedQuery){
            Object.keys(condition).forEach(key=>{
              conditionMaps['conditionMap['+key+']'] = condition[key].trim();
            });
          }
          if(isAdancedQuery){
            condition['conditionMap[pkCodeRule]'] = this.currentCodeRuleOid == null || this.currentCodeRuleOid == ''
            ? this.selectionList[0].oid:this.currentCodeRuleOid;
          }
          gridCodeBasicSec(1, -1,isAdancedQuery ? condition:conditionMaps).then(res => {
            const data = res.data.data;
            if(this.cloneSettingBox){
              this.cloneData = data.records;
              // console.log(tihs.cloneData);
              this.cloneTableLoading = false;
            }else {
              this.basicData = data.records;
              // console.log(this.basicData);
              this.loadingBasic = false;
            }
          });
        },
        // 基础码段选中时触发
        selectionBasicChange(list) {
          this.selectionBasicList = list;
          this.$refs.crudBasic.setCurrentRow(this.selectionBasicList[list.length-1]);
          //console.log(this.selectionBasicList);
        },
        // 基础码段被单击表格行时触发
        codeBasicSecRowClick(row){
          this.$refs.crudBasic.toggleSelection();
          this.selectionBasicList = row;
          this.$refs.crudBasic.setCurrentRow(row);
          this.$refs.crudBasic.toggleRowSelection(row); //选中当前行
        },
        basicSearchChange(params, done){
          //console.log(this.$refs.crudBasic);
          this.sendGridCodeBasicSec(Object.assign(params,{"pkCodeRule":this.selectionList[this.selectionList.length-1].oid}),false);
          done();
        },
        basicSearchReset(){
          this.sendGridCodeBasicSec({"pkCodeRule":this.selectionList[this.selectionList.length-1].oid},false);
        },
        // 上移下移基础码段
        async upOrderNum(row){
          if(!this.tipsMessage(this.selectionList)){
            return;
          }
          if (this.selectionList[0].lcStatus != 'Editing') {
            this.$message.warning("只有编码规则的状态是 [编辑中] 的时候，才能调整码段顺序!");
            return;
          }
          if(row.oid==null || row.oid==''){
            this.$message.warning("未获取到必填参数!");
            return;
          }
          await upOrderNum(row.oid).then(() => {
            this.loadBasic(this.selectionList[0]);
            this.$message({
              type: "success",
              message: "操作成功!"
            });
          })
        },
        downOrderNum(row){
          //console.log(row.oid);
          if(!this.tipsMessage(this.selectionList)){
            return;
          }
          let codeRuleOid = this.selectionList[0].oid;
          //console.log(this.selectionList);
          if (this.selectionList[0].lcStatus != 'Editing') {
            this.$message.warning("只有编码规则的状态是 [编辑中] 的时候，才能调整码段顺序!");
            return;
          }
          if(row.oid==null || row.oid==''){
            this.$message.warning("未获取到必填参数!");
            return;
          }
          downOrderNum(row.oid).then(() => {
            this.loadBasic({"oid":codeRuleOid});
            this.$message({
              type: "success",
              message: "操作成功!"
            });
          })
        },
        // 基础码段刷新时查询
        refreshChangeBasicSec(){
          this.loadBasic(this.selectionList.at(-1));
        },
        // 操作基础码段中搜索清空等按钮的显示/隐藏
        hideBasicTable(hideBoolean){
          this.$refs.crudBasic.option.refreshBtn = hideBoolean;
          this.$refs.crudBasic.option.columnBtn = hideBoolean;
          this.$refs.crudBasic.option.column[0].search = hideBoolean;
          this.$refs.crudBasic.option.column[1].search = hideBoolean;
          if(!hideBoolean){
            this.selectionList = [];
            this.basicData = [];
          }
        },
        changeCutType(value){
          if (value != 'code_cut_none'){
            if(this.form.valueCutLength == ''){
              this.form.valueCutLength = 1;
            }
          }else{
            this.form.valueCutLength = '';
          }
        },

        /** 第一层对话框相关方法 */
        // 打开二层对话框方法
        openAttrSelectOrGetValue(condition){
@@ -2506,14 +2560,21 @@

        // 当前已存在编辑过的参照配置，所以直接打开参照配置界面
        openReconfigInterFace(preReferConfigForm){
          // console.log(preReferConfigForm);
          const form = preReferConfigForm;
          // 编辑码段时referConfig可能会在为【参照引用的业务类型】选取值之后改变
          let referConfigValue =JSON.parse(form.referConfig);
          if(referConfigValue.referType != form.referBtmId){
            referConfigValue.referType = form.referBtmId || '';
            referConfigValue.referTypeName = form.referBtmName || form.referBtmId;
            this.form.referConfig = JSON.stringify(referConfigValue);
          }
          let data = {
            referTypeName: form.referBtmName,
            referType: form.referBtmId,
            referConfig: this.form.referConfig,
          }
          this.$refs.referConfigFormDialog.isShowReferConfigForm = true;
              let value = {
                referTypeName: preReferConfigForm.referBtmName,
                referType: preReferConfigForm.referBtmId,
                referConfig: preReferConfigForm.referConfig,
              }
              this.$refs.referConfigFormDialog.initPageData(value);
          this.$refs.referConfigFormDialog.initPageData(data);
        },
        // 打开自定义参照配置或直接选择参照配置的提示框
        openTipsChooseOrCust(){
@@ -2865,4 +2926,8 @@
    padding: 5px 10px 10px;
 }

 .seloption{
  margin-left: 10px;
}

</style>

 Source/UBCS-WEB/src/views/system/user.vue

@@ -154,9 +154,9 @@
            </el-option>
          </el-select>
            <span slot="footer" class="dialog-footer">
            <el-button @click="passVisible = false">取 消</el-button>
            <el-button type="primary" @click="passhandle">确 定</el-button>
  </span>
              <el-button @click="passVisible = false">取 消</el-button>
              <el-button type="primary" @click="passhandle">确 定</el-button>
            </span>
        </el-dialog>
      </basic-container>
    </el-col>

 Source/UBCS/ubcs-service-api/ubcs-system-api/src/main/java/com/vci/ubcs/system/feign/ISysClient.java

@@ -70,6 +70,7 @@
    String STRATEGYBYID = API_PREFIX + "/query-userid";
    String REGEX = API_PREFIX + "/combination-regex";
    String REGEXONE = API_PREFIX + "/combination-regex-one";

    /**
     * 获取菜单
     *

 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeBasicSecServiceImpl.java

@@ -272,7 +272,7 @@
                throw new VciBaseException("引用码段的时候，参照配置的内容的格式不正确,",new String[0],e);
            }
            // 判断是否为引用码段，如果是应用码段的话，为了适配前端组件，这里要对表进行处理一下，按照以前的参照格式进行转换
            codeBasicSecDO.setReferValueInfo(referConfigTOUIUiTable(codeReferConfigVO));
            codeBasicSecDO.setReferValueInfo(referConfigToUIUiTable(codeReferConfigVO));
            if(codeReferConfigVO.getIsPersistence()=="true"){
                codeReferConfigService.insert(codeReferConfigVO);
            }
@@ -296,7 +296,7 @@
     * @param codeReferConfig
     * @return
     */
    private String referConfigTOUIUiTable(CodeReferConfigVO codeReferConfig){
    private String referConfigToUIUiTable(CodeReferConfigVO codeReferConfig){
        // 拷贝为以前的老对象
        UIReferConfigFormVO uiFormReferVO = new UIReferConfigFormVO();
        BeanUtil.copy(codeReferConfig,uiFormReferVO);
@@ -366,16 +366,23 @@
                && StringUtils.isBlank(codeBasicSecDO.getCodeFillSeparator())){
                throw new VciBaseException("当补位方式为左补位或者右补位的时候，补位字符不能为空");
            }
            CodeReferConfigVO codeReferConfigVO = null;
            //引用码段的时候，需要判断参照的信息是否正确
            if(CodeSecTypeEnum.CODE_REFER_SEC.getValue().equalsIgnoreCase(codeBasicSecDO.getSecType())){
                if(StringUtils.isBlank(codeBasicSecDO.getReferConfig())){
                    throw new VciBaseException("引用码段的时候，需要填写 参照配置 的内容");
                    throw new VciBaseException("引用码段的时候，需要填写参照配置的内容");
                }
                try{
                    JSONObject.parseObject(codeBasicSecDO.getReferConfig(), UIFormReferVO.class);
                    // JSONObject.parseObject(codeBasicSecDO.getReferConfig(), UIFormReferVO.class);
                    codeReferConfigVO = JSONObject.parseObject(codeBasicSecDO.getReferConfig(), CodeReferConfigVO.class);
                }catch (Throwable e){
                    throw new VciBaseException("引用码段的时候，参照配置的内容的格式不正确,",new String[0],e);
                }
                // 判断是否为引用码段，如果是应用码段的话，为了适配前端组件，这里要对表进行处理一下，按照以前的参照格式进行转换
                codeBasicSecDO.setReferValueInfo(referConfigToUIUiTable(codeReferConfigVO));
                if(codeReferConfigVO.getIsPersistence()=="true"){
                    codeReferConfigService.insert(codeReferConfigVO);
                }
            }
            revisionModelUtil.copyFromDTOIgnore(codeBasicSecDTO, codeBasicSecDO);
            resBoolean = codeBasicSecMapper.updateById(codeBasicSecDO)>0;

 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeClassifyServiceImpl.java

@@ -197,11 +197,11 @@
     * @return  数据对象
     */
    private CodeClassify selectByOid(String oid){
        CodeClassify codeClassifyEntity = codeClassifyMapper.selectClassifyByKeyAndReseRel("'"+oid.trim()+"'").get(0);
        if(codeClassifyEntity == null || StringUtils.isBlank(codeClassifyEntity.getOid())){
        List<CodeClassify> codeClassifyEntityList = codeClassifyMapper.selectClassifyByKeyAndReseRel("'" + oid.trim() + "'");
        if (codeClassifyEntityList.isEmpty() || codeClassifyEntityList.get(0) == null || StringUtils.isBlank(codeClassifyEntityList.get(0).getOid())) {
            throw new ServiceException("dataOidNotExist");//根据主键id未查到相关数据
        }
        return codeClassifyEntity;
        return codeClassifyEntityList.get(0);
    }

    /**

 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeClassifyTemplateAttrServiceImpl.java

@@ -714,7 +714,7 @@
        //这个业务类型下的所有属性
        R<BtmTypeVO> btmTypeVOR = btmTypeClient.getAllAttributeByBtmId(codeClassifyTemplateDO.getBtmTypeId());
        if(btmTypeVOR.getCode() != 200){
            throw new ServiceException("业务类型feign调用失败！");
            throw new ServiceException("业务类型feign调用错误！");
        }

        //这个模板下已经有的属性

 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/CodeRuleServiceImpl.java

@@ -203,6 +203,9 @@
        //将DTO转换为DO
        CodeRule codeRule = selectByOid(codeRuleDTO.getOid());
        revisionModelUtil.copyFromDTOIgnore(codeRuleDTO, codeRule);
        if(!codeRule.getOwner().equals(codeRuleDTO.getOwner())){
            codeRule.setOwner(codeRuleDTO.getOwner());
        }
        DefaultAttrAssimtUtil.updateDefaultAttrAssimt(codeRule);
        return R.status(codeRuleMapper.updateById(codeRule)>0);
    }

 Source/UBCS/ubcs-service/ubcs-code/src/main/java/com/vci/ubcs/code/service/impl/MdmEngineServiceImpl.java

@@ -3379,7 +3379,7 @@

        String lcstatusSql = "";
        if (StringUtils.isNotBlank(baseQueryObject.getConditionMap().get("lcstatus"))) {
            lcstatusSql = "lcstatus =" + VciBaseUtil.toInSql(baseQueryObject.getConditionMap().get("lcstatus"));
            lcstatusSql = "and lcstatus =" + VciBaseUtil.toInSql(baseQueryObject.getConditionMap().get("lcstatus"));
        }
//        String where = "";

@@ -3392,7 +3392,7 @@

        List<Map> maps = commonsMapper.selectBySql("select * from ( select rownum rn, t.* from (select * from " + listR.getData().get(0).getTableName() + SPACE
                + (StringUtils.isNotBlank(listR.getData().get(0).getRevisionRuleId()) ? (" where lastr = " + VciBaseUtil.toInSql(baseQueryObject.getConditionMap().get("lastr").toString())
                + " and lastv =" + VciBaseUtil.toInSql(baseQueryObject.getConditionMap().get("lastv").toString())) + " and" : "where") + SPACE + "1=1 and "
                + " and lastv =" + VciBaseUtil.toInSql(baseQueryObject.getConditionMap().get("lastv").toString())) + " and" : "where") + SPACE + "1=1 "
                + lcstatusSql + namesql + codesql + ") t where rownum <=" + num1 + ") where rn >=" + num2
        );
        List<BaseModel> baseModels = new ArrayList<>();
@@ -3436,7 +3436,7 @@
        }
        int total = commonsMapper.queryCountBySql("select count(*) from " + listR.getData().get(0).getTableName() + SPACE
                + (StringUtils.isNotBlank(listR.getData().get(0).getRevisionRuleId()) ? (" where lastr = " + VciBaseUtil.toInSql(baseQueryObject.getConditionMap().get("lastr").toString())
                + "and lastv = " + VciBaseUtil.toInSql(baseQueryObject.getConditionMap().get("lastv").toString())) + " and" : "where") + SPACE + "1=1 and "
                + "and lastv = " + VciBaseUtil.toInSql(baseQueryObject.getConditionMap().get("lastv").toString())) + " and" : "where") + SPACE + "1=1 "
                + lcstatusSql + namesql + codesql
        );
        IPage<BaseModel> objectDataGrid = new Page<>();

 Source/UBCS/ubcs-service/ubcs-system/src/main/java/com/vci/ubcs/system/service/impl/RoleServiceImpl.java

@@ -166,7 +166,7 @@
        if (roleList != null && roleList.size() > 0) {
            return roleList.stream().map(role -> Func.toStr(role.getId())).distinct().collect(Collectors.joining(","));
        }
        return null;
        return "";
    }

    @Override

 Source/UBCS/ubcs-service/ubcs-user/src/main/java/com/vci/ubcs/system/user/controller/UserController.java

@@ -369,8 +369,8 @@
     */
    @GetMapping("/getByRoleUserList")
    @ApiOperationSupport(order = 21)
    @ApiOperation(value = "获取到指定身份权限的用户列表", notes = "传入id")
    public R<List<UserVO>> getByRoleUserList(BladeUser user,@Valid @RequestParam String roleName){
    @ApiOperation(value = "获取到指定身份权限的用户列表", notes = "传入roleName")
    public R<List<Map<String,String>>> getByRoleUserList(BladeUser user,@Valid @RequestParam String roleName){
        return R.data(userService.getByRoleUserList(user,roleName));
    }


 Source/UBCS/ubcs-service/ubcs-user/src/main/java/com/vci/ubcs/system/user/mapper/UserMapper.java

@@ -21,9 +21,11 @@
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.vci.ubcs.system.user.entity.User;
import com.vci.ubcs.system.user.excel.UserExcel;
import org.apache.ibatis.annotations.MapKey;
import org.apache.ibatis.annotations.Param;

import java.util.List;
import java.util.Map;

/**
 * Mapper 接口
@@ -62,6 +64,13 @@
     */
    List<UserExcel> exportUser(@Param("ew") Wrapper<User> queryWrapper);

    List<User> getByRoleUserList(@Param("tenantId") String tenantId, @Param("roleName") String roleName);
    /**
     * 根据角色id查询当前用户以外的所有用户
     * @param roleId
     * @param userId
     * @return 键值队形式
     */
    @MapKey("ID")
    List<Map<String,String>> getUserMap(@Param("roleId") String roleId, @Param("userId") String userId);

}

 Source/UBCS/ubcs-service/ubcs-user/src/main/java/com/vci/ubcs/system/user/service/IUserService.java

@@ -30,6 +30,7 @@
import org.springblade.core.secure.BladeUser;

import java.util.List;
import java.util.Map;

/**
 * 服务类
@@ -251,6 +252,6 @@
     * @param roleName 要查询的角色身份
     * @return
     */
    List<UserVO> getByRoleUserList(BladeUser user, String roleName);
    List<Map<String,String>> getByRoleUserList(BladeUser user, String roleName);

}

 Source/UBCS/ubcs-service/ubcs-user/src/main/java/com/vci/ubcs/system/user/service/impl/UserServiceImpl.java

@@ -58,6 +58,8 @@
import org.springframework.util.DigestUtils;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import static com.vci.ubcs.common.constant.CommonConstant.DEFAULT_PARAM_PASSWORD;

@@ -535,11 +537,28 @@
        return this.update(Wrappers.<User>lambdaUpdate().in(User::getId, userIds).set(User::getStrategyUpdateStatus,CommonConstant.IS_DEFAULT));
    }

    /**
     * 获取到指定身份权限的用户列表
     * @param user 用户查询的用户信息，如租户信息，通常为自动注入，前端可选择不传
     * @param roleName 要查询的角色身份
     * @return
     */
    @Override
    public List<UserVO> getByRoleUserList(BladeUser user, String roleName) {


        return null;
    public List<Map<String,String>> getByRoleUserList(BladeUser user, String roleName) {
        // 考虑到一个用户可以拥有多种角色权限，而用户关联角色权限是用role_id字段用逗号分隔角色id的，直接采用子查询来in查询不能实现，所以先查询角色id
        R<String> roleIds = sysClient.getRoleIds(user.getTenantId(), roleName);
        if(roleIds.getCode() != 200){
            throw new ServiceException("系统服务feign接口调用错误！");
        }
        if(Func.isBlank(roleIds.getData())){
            return new ArrayList<>();
        }
        List<Map<String,String>> list = new ArrayList<>();
        Arrays.stream(roleIds.getData().split(",")).forEach(item->{
            list.addAll(this.baseMapper.getUserMap(item,user.getUserId().toString()));
        });
        // 去除重复
        return list.stream().distinct().collect(Collectors.toList());
    }

    /**

 Source/UBCS/ubcs-service/ubcs-user/src/main/resources/mapper/UserMapper.xml

@@ -99,9 +99,18 @@
            where id = #{userId} and is_deleted = 0
    </select>

    <select id="getByRoleUserList" resultType="com.vci.ubcs.system.user.entity.User">


    <select id="getUserMap" resultType="map">
        SELECT
            PCR.ID as value,
            PCR.ACCOUNT as lable
        FROM
            PL_ORG_USER PCR
        WHERE
            instr(PCR.ROLE_ID,#{roleId}) > 0
        AND
            PCR.ID != #{userId}
        AND
            PCR.IS_DELETED = 0
    </select>

</mapper>