诊断依据初始

src/api/index.js

@@ -4,7 +4,7 @@ import config from './config.js';
 axios.default.timeout = 500000;
 axios.defaults.headers.post['Content-Type'] = "application/json;charset=utf-8";
 // axios.defaults.baseURL = 'http://192.168.2.236:5050';
-axios.defaults.baseURL = 'http://192.168.2.241';
+axios.defaults.baseURL = 'http://192.168.2.236';
 // axios.defaults.baseURL = 'http://192.168.3.117:5050';
 
 const urls = config.urls;

src/api/zskDiagBase.js

@@ -0,0 +1,20 @@
+import axios from 'axios';
+const urls = {
+    'zskDiagBase':'/api/cdssman/klDiagnose/getDiagnosePage',    //知识库诊断依据维护
+    'zskAddDiagBase':'/api/cdssman/klDiagnose/saveDiagnoseAll',
+    'zskDelDiagBase':'/api/cdssman/klDiagnose/clearDiagnoseAll',
+    'zskStrDiagBase':'/api/cdssman/klDiagnose/startDiagnose',
+    'zskStopDiagBase':'/api/cdssman/klDiagnose/disableDiagnose',
+    'zskDiagBaseDetail':'/api/cdssman/klDiagnose/getByIdDiagnoseAll',
+};
+export default {
+    diagBasePage(param){
+        return axios.post(urls.zskDiagBase, param)
+    },
+    diagBaseDelete(param){ //诊断依据--删除
+        return axios.post(urls.zskDelDiagBase, param)
+    },
+    diagBaseGetDetail(param){ //诊断依据--获取详情
+        return axios.post(urls.zskDiagBaseDetail, param)
+    },
+}

src/components/knowledgeExtra/AddDiagBase.vue

@@ -0,0 +1,415 @@
+<template>
+    <div>
+        <crumbs :title="title" :param="$route.params" linkTo="ZskDiagBase"></crumbs>
+        <div class="contents">
+            <div class="content">
+                <el-form ref="form" :label-position="labelPosition" class="add-new-form" label-width="130px" :model="form" :rules="rules">
+                    <el-form-item label="疾病名称：" prop="conceptName">
+                        <el-input v-model.trim = "form.conceptName"></el-input>
+                    </el-form-item>
+                    <el-form-item label="诊断依据描述：" prop="description" class="description">
+                        <el-input type="textarea" :rows="3" placeholder="请输入诊断依据描述" v-model.trim="form.description"></el-input>
+                    </el-form-item>
+                    <el-form-item label="诊断依据内容：" prop="remind" class="discDesc is-required">
+                        <DiagBaseType v-for="(group,i) in subGroups"
+                                       ref="groups"
+                                       :data="group"
+                                       :baseTypes="baseTypeList"
+                                       :inx="i"
+                                       :maxNum="subRuleMaxNum"
+                                       :firstPlace="firstPlace"
+                                       :isLast="subGroups.length===1"
+                                       @addGroup="addGroup"
+                                       @delGroup="delGroup"></DiagBaseType>
+                    </el-form-item>
+                    <el-button class="disclButn" size="small" type="primary" @click="confirm">保存</el-button>
+                </el-form>
+            </div>
+        </div>
+    </div>
+</template>
+<script type="text/javascript">
+    import api from '@api/knowledgeLib.js';
+    import DiagBaseType from './DiagBaseType'
+    export default {
+        name:'AddZskDiagBase',
+        data(){
+            return{
+                labelPosition:'left',
+                isFirst:true,
+                isCopy:false,
+                dict:'',        //规则内容固定的类型
+                msgDict:'',     //显示附加信息的类型
+                title:'诊断依据维护-添加诊断依据',
+                ruleTermTypeList:[],
+                ruleTypeList:[],
+                conceptList:[],
+                baseTypeList:[],
+                conceptName:'',
+                subRuleMaxNum:null,     //规则内容中规则的限制个数
+                firstPlace:null,
+                subGroups:[[{
+                    subDescription:'',
+                    parRuleType:'',
+                    subConceptId:'',
+                    subType:'',
+                    subMaxOperator:'',
+                    subMaxUnit:'',
+                    subMaxValue:'',
+                    subMinOperator:'',
+                    subMinUnit:'',
+                    subMinValue:'',
+                    subEqValue:'',
+                    subLenCode:'',
+                    dataType:'',
+                }]],
+                form:{
+                    parDescription:'',
+                    parRuleType:'',
+                    parConceptId:'',
+                    parlibName:'',
+                    parLenName:'',
+                    parHasSub:undefined,
+                    parLenCode:'',
+                    parMsg:'',
+                    klRuleInfoSaveSub:[],
+                },
+                parId:null,
+                rules:{
+                    conceptName:[{ required: true, message: '请输入疾病名称',trigger: ['blur'] }],
+                    description:[{ required: true, message: '请输入诊断依据描述',trigger: ['blur'] },{
+                        validator: (rule,value,callback)=>{
+                            if(value.length>100){
+                                callback(new Error('诊断依据描述不能超过100字'));
+                            }else{
+                                callback();
+                            }}, trigger: 'change'
+                    }],
+                }
+            }
+        },
+        created(){
+            this.getTypeList();
+            this.setDict();
+            const param = this.$route.params;
+            let info = param.data;
+            if(info){
+                this.parId = info.parId;
+                this.isCopy=param.copy;
+                this.title = "诊断依据维护-"+(this.isCopy?'复制':'修改')+"诊断依据";
+                this.form=Object.assign({},this.form,info);
+                this.conceptList=[{conceptName:this.form.parlibName,conceptId:this.form.parConceptId}];
+                this.subGroups=this.formatGroupDatas(info.klRuleByIdSub);
+
+            }
+        },
+        watch:{
+            'form.parRuleType':function(val){
+                const obj = this.ruleTypeList.find((it)=>it.id===val);
+                this.ruleTermTypeList = obj.subMenuList;
+            },
+            'form.parLenCode':function(val){
+                if(!val){
+                    this.baseTypeList = [];
+                    return ;
+                }
+                const obj = this.ruleTermTypeList.find((it)=>it.code===val);
+                this.baseTypeList = obj.subMenuList;
+                this.subRuleMaxNum=obj.number;
+            },
+            'form.parConceptId':function(val){
+                if(val&&this.checkFirstPlace&&this.conceptList) {
+                    this.firstPlace = this.conceptList.find((it) => it.conceptId === val);
+                    this.firstPlace['checkedType']=this.ruleTermCodeStr;
+                }else if(!val){
+                    this.setInitGroupData();
+                    this.firstPlace =null;
+                }else{
+                    this.firstPlace =null;
+                }
+            }
+        },
+        components:{
+            DiagBaseType
+        },
+        computed:{
+            ruleTermCodeStr:function(){
+                return this.form.parRuleType+"-"+this.form.parLenCode
+            },
+            checkFirstPlace:function(){
+                return this.dict.indexOf(this.ruleTermCodeStr)>-1;
+            },
+            showMsg:function(){
+                return this.ruleTermCodeStr.length>1&&this.msgDict.indexOf(this.ruleTermCodeStr)>-1;
+            },
+            showHasSub:function(){
+                return this.subDict.indexOf(this.ruleTermCodeStr)>-1;
+            }
+        },
+        methods:{
+            hasSubChange(val){
+                if(val){
+                    this.setInitGroupData();
+                }
+            },
+            setDict(){
+                this.dict = localStorage.getItem("zskDicts");
+                this.msgDict = localStorage.getItem("zskMsgDict");
+                this.subDict = localStorage.getItem("zskSubDict");
+            },
+            showConfirmDialog(msg,resolve){
+                this.$alert(msg, '提示', {
+                    confirmButtonText: '确定',
+                    type: 'warning'
+                }).then(() => {
+                    resolve();
+                }).catch(() => {});
+            },
+            formatGroupDatas(data){
+                let arr=[];
+                data.map((it)=>{
+                    if(!arr[it.groupType]){arr[it.groupType]=[];}
+                    if(it.subMaxOperator||it.subMinOperator){
+                        it.dataType='1';
+                    }else if(it.subEqValue){
+                        it.dataType='2';
+                    }
+                    arr[it.groupType].push(it);
+                });
+                arr = arr.filter((it)=>{if(it)return it});
+                return arr;
+            },
+            searchConcept(val){
+                const param = {
+                    excludedConceptIds:[this.form.parRuleType],
+                    libType:this.form.parLenCode,
+                    name:val,
+                };
+                api.searchConcept(param).then((res) => {
+                    if (res.data.code == '0') {
+                        const data = res.data.data;
+                        this.conceptList = data;
+                    }
+                }).catch((error) => {
+                    console.log(error);
+                });
+            },
+            ruleTypeChange(val){       //规则类型选中
+                this.form.parRuleType=val;
+                this.form.parLenCode='';
+                const obj = this.ruleTypeList.find((it)=>it.id===val);//console.log(val)
+                this.ruleTermTypeList = obj.subMenuList;
+                this.setInitGroupData();
+            },
+            ruleTermChange(val){        //规则术语类型选中
+                this.form.parLenCode=val;
+                const obj = this.ruleTermTypeList.find((it)=>it.code===val);
+                this.form.parLenName=obj.name;
+                this.baseTypeList = obj.subMenuList;
+                this.subRuleMaxNum = obj.number;
+                this.setInitGroupData();
+                this.form.parHasSub=obj.subMenuList.length?1:0;
+            },
+            getTypeList(){
+                const typeListData = JSON.parse(localStorage.getItem("zskTypesList"));
+                this.ruleTypeList = typeListData;
+            },
+            setInitGroupData(){
+                this.subGroups = [[{
+                    subDescription:'',
+                    parRuleType:'',
+                    subConceptId:'',
+                    subType:'',
+                    subMaxOperator:'',
+                    subMaxUnit:'',
+                    subMaxValue:'',
+                    subMinOperator:'',
+                    subMinUnit:'',
+                    subMinValue:'',
+                    subEqValue:'',
+                    subLenCode:'',
+                    dataType:'',
+                }]];
+                this.form.parConceptId='';//医学标准术语清空
+                this.conceptList=[];  //下拉列表清空
+            },
+            addGroup(){
+                let temp = {
+                    subDescription:'',
+                    subConceptId:'',
+                    subType:'',
+                    subLenCode:'',
+                    dataType:'',
+                    subMaxOperator:'',
+                    subMaxUnit:'',
+                    subMaxValue:'',
+                    subMinOperator:'',
+                    subMinUnit:'',
+                    subMinValue:'',
+                    subEqValue:'',
+                };
+                if(this.checkFirstPlace){
+                    const obj=this.subGroups[0][0];
+                    temp = {
+                        subDescription:obj.subConceptName,
+                        subConceptId:obj.subConceptId,
+                        subConceptName:obj.subConceptName,
+                        subLenCode:this.form.parLenCode,
+                        subLenName: this.form.parLenName,
+                        subLibName: this.form.parlibName,
+                        subType:obj.subType,
+                        dataType:'',
+                        subMaxOperator:'',
+                        subMaxUnit:'',
+                        subMaxValue:'',
+                        subMinOperator:'',
+                        subMinUnit:'',
+                        subMinValue:'',
+                        subEqValue:'',
+                    };
+                }
+                this.subGroups.push([temp]);
+            },
+            delGroup(i){
+                this.subGroups.splice(i,1);
+            },
+            saveRule(params){
+                api.saveRule(params).then((res)=>{
+                    if(res.data.code==0){
+                        this.$message({
+                            message:"操作成功",
+                            type:'success'
+                        });
+                        this.$router.push({name: 'ZskRuleManager'});
+                    }else{
+                        this.$message({
+                            message:res.data.msg,
+                            type:'warning'
+                        });
+                    }
+                })
+            },
+            formatGroups(){
+                let obj = [];
+                this.subGroups.map((item,i)=>{
+                    item.map((it)=>{
+                        obj.push({...it,groupType:i});
+                    })
+                });
+                return obj
+            },
+            validateForms(callBack){
+                this.$refs['form'].validate((valid) => {
+                    if (valid) {
+                        const groupsRef = this.$refs['groups'];
+                        if(!groupsRef||groupsRef.length===0){
+                            callBack();
+                            return;
+                        }
+                        let groupRef=null,goOn=true;
+                        for(let i=0;i<groupsRef.length;i++){
+                            groupRef=groupsRef[i].$refs['group'];
+                            for(let j=0;j<groupRef.length;j++){
+                                groupRef[j].$refs['groupData'].validate((valid)=>{
+                                    if(!valid){
+                                        goOn=false;
+                                    }
+                                })
+                            }
+                        }
+                        if(goOn){
+                            callBack();
+                        }
+                    } else {
+                        return false;
+                    }
+                });
+            },
+            confirm(){
+                const _this=this;
+                this.validateForms(function(){
+                    delete _this.form.klRuleByIdSub;
+                    _this.form.klRuleInfoSaveSub = _this.form.parHasSub?_this.formatGroups():undefined;
+                    let params = _this.form;
+                    if(_this.parId){//修改/复制
+                        params = Object.assign({},_this.form,{parId:_this.isCopy?undefined:_this.parId,parStatus:_this.isCopy?1:_this.form.parStatus})
+                    }
+                    console.log(params)
+                    _this.saveRule(params);
+                });
+            },
+        }
+    }
+</script>
+<style lang="less">
+    @import "../../less/admin.less";
+    .content{
+        background: #fff;
+        // padding: 20px 20px 30px;
+        padding: 20px 20px 50px;
+        color: #545455;
+        min-width: 980px;
+        position: relative;
+        .tip-text{
+            color:#F56C6C;
+            margin-left: 10px;
+        }
+        .conceptItem{
+            padding: 0 10px;
+            cursor: pointer;
+            height: 32px;
+            line-height: 32px;
+            &:hover{
+                background: #ebedf1;
+            }
+        }
+        .discDesc{
+            margin-bottom: 20px;
+        }
+        .disclButn{
+            position: absolute;
+            right: 80px;
+            bottom: 10px;
+        }
+    }
+    .add-new-form{
+        .el-form-item__label{
+            text-align: right;
+        }
+        .addDepartFormItem {
+            position: relative;
+        }
+        .itemList {
+            position: absolute;
+            // display: none;
+            background: #fff;
+            width: 188px;
+            max-height: 160px;
+            border: 1px solid #DCDFE6;
+            left: 0;
+            top: 37px;
+            z-index: 2;
+            overflow-y: auto;
+        }
+        .indexList {
+            left: 42px;
+            top: 78px;
+        }
+        .el-input__prefix, .el-input__suffix{
+            /*top:-2px;*/
+            right: 3px;
+        }
+        .el-input--suffix .el-input__inner{
+            padding-right: 22px;
+        }
+        .el-input,.el-input__inner{
+            width: 190px;
+            line-height: 32px;
+            height: 32px;
+        }
+        .el-input__icon{
+            line-height: 32px;
+        }
+    }
+
+</style>

src/components/knowledgeExtra/DiagBase.vue

@@ -0,0 +1,368 @@
+<template>
+    <div>
+        <crumbs title="诊断依据维护" :minWidth="titleWidth" class="knowledgeTitle">
+            <el-form :inline="true" class="demo-form-inline">
+                <el-form-item label="疾病名称：">
+                    <el-input size="mini" v-model="filter.conceptName" placeholder="输入疾病名称" clearable></el-input>
+                </el-form-item>
+                <el-form-item>
+                    <el-button size="mini" @click="filterDatas">确认</el-button>
+                </el-form-item>
+                <el-form-item>
+                    <el-button size="mini" @click="addRule" type="warning" style="margin:0 10px">+ 新增诊断依据</el-button>
+                    <el-button size="mini" @click="update">更新数据</el-button>
+                </el-form-item>
+            </el-form>
+        </crumbs>
+        <div class="contents knowledgeContents">
+            <el-table :data="list"
+                      border
+                      style="width: 100%">
+                <el-table-column
+                        type="index"
+                        :index="indexMethod"
+                        label="编号"
+                        width="60">
+                </el-table-column>
+                <el-table-column
+                        prop="conceptName"
+                        label="疾病名称"
+                        width="160">
+                    <template slot-scope="scope">
+                        <el-tooltip v-if="scope.row.conceptName.length>8" class="item" effect="dark" :content="scope.row.conceptName" placement="top">
+                            <span>{{scope.row.conceptName.slice(0,8)+'...'}}</span>
+                        </el-tooltip>
+                        <span v-if="scope.row.conceptName.length<9">{{scope.row.conceptName}}</span>
+                    </template>
+                </el-table-column>
+                <el-table-column
+                        prop="description"
+                        label="描述"
+                        width="160">
+                    <template slot-scope="scope">
+                        <el-tooltip v-if="scope.row.description.length>8" class="item" effect="dark" :content="scope.row.description" placement="top">
+                            <span>{{scope.row.description.slice(0,8)+'...'}}</span>
+                        </el-tooltip>
+                        <span v-if="scope.row.description.length<9">{{scope.row.description}}</span>
+                    </template>
+                </el-table-column>
+                <el-table-column
+                        label="状态">
+                    <template slot-scope="scope">
+                          <span>
+                            {{scope.row.status === 0?'禁用':'启用'}}
+                          </span>
+                    </template>
+                </el-table-column>
+                <el-table-column
+                        prop="modifierName"
+                        label="操作人">
+                </el-table-column>
+                <el-table-column
+                        prop="gmtModified"
+                        label="操作时间"
+                        width="180">
+                </el-table-column>
+                <el-table-column
+                        label="操作"
+                        width="180" fixed="right">
+                    <template slot-scope="scope">
+                        <el-button type="text" size="small" @click="editData(scope.row.conceptId)">修改</el-button>
+                        <span style="margin:0 3px;">|</span>
+                        <el-button type="text" size="small" @click="editData(scope.row.conceptId,true)">复制</el-button>
+                        <span style="margin:0 3px;">|</span>
+                        <el-button type="text" size="small" :class="scope.row.status === 0?'':'unvailable'" @click="showDelDialog(scope.row)">{{scope.row.status === 0?'启用':'禁用'}}</el-button>
+                        <span style="margin:0 3px;">|</span>
+                        <el-button type="text" size="small" class="delete" @click="showDelDialog(scope.row,1)">删除</el-button>
+                    </template>
+                </el-table-column>
+            </el-table>
+            <el-pagination :current-page.sync="currentPage"
+                           @current-change="currentChange"
+                           background
+                           :page-size="pageSize"
+                           :page-sizes="pageSizeArr"
+                           @size-change="handleSizeChange"
+                           :layout="pageLayout"
+                           :total="total">
+            </el-pagination>
+        </div>
+
+    </div>
+</template>
+
+<script>
+    import api from '@api/zskDiagBase.js';
+    import config from '@api/config.js';
+    import utils from '@api/utils.js';
+
+    export default {
+        name: 'ZskDiagBase',
+        data: function () {
+            return {
+                list: [],
+                stateSelect:[
+                    {id:1,name:'启用'},
+                    {id:0,name:'禁用'},
+                ],
+                ruleTypeList:[],
+                searched: false,
+                filter:{
+                    conceptName:'',
+                },
+                cacheData: {},
+                currentPage: 1,
+                pageSize: config.pageSize,
+                pageSizeArr:config.pageSizeArr,
+                pageLayout:config.pageLayout,
+                total: 0,
+                titleWidth:'1070px' //头部最小宽度
+            }
+        },
+        created() {
+            const param = this.$route.params;
+            if(param.currentPage){
+                this.inCurrentPage = param.currentPage
+                this.filter = param.filter
+            }
+            this.getTypeList();
+            const that = this;
+            //返回时避免参数未赋值就获取列表
+            setTimeout(function(){
+                that.getDataList();
+            });
+        },
+        watch: {
+            'filter': {
+                handler: function () {
+                    this.searched = false;
+                },
+                deep: true
+            }
+        },
+        // beforeRouteEnter(to, from, next) {
+        //     next(vm => {
+        //         //const pm = to.param;
+        //         Object.assign(vm, to.params);
+        //         vm.inCurrentPage=to.params.currentPage;
+        //     })
+        // },
+        methods: {
+            statusTrans(type){
+                const obj = this.ruleTypeList.find((it)=>it.type===type);
+                return obj&&obj.name;
+            },
+            getTypeList(){
+                const typeListData = JSON.parse(localStorage.getItem("zskTypesList"));
+                if(typeListData){
+                    this.ruleTypeList = typeListData;
+                    return;
+                }
+                api.getTypesList({planCode:'rule'}).then((res) => {
+                    if (res.data.code == '0') {
+                        const data = res.data.data;
+                        this.ruleTypeList = data;
+                        localStorage.setItem("zskTypesList",JSON.stringify(data));
+                    }
+                }).catch((error) => {
+                    console.log(error);
+                });
+            },
+            handleSizeChange(val){
+                this.pageSize = val;
+                this.currentPage = utils.getCurrentPage(this.currentPage, this.total, this.pageSize);
+                this.getDataList();
+            },
+            addRule(){
+                const pam = this.searched ? {
+                    currentPage: this.currentPage,
+                    pageSize:this.pageSize,
+                    filter: this.filter
+                } : {currentPage: this.currentPage,
+                    pageSize:this.pageSize};
+                this.$router.push({name: 'AddZskDiagBase', params: pam});
+            },
+            filterDatas(){
+                this.currentPage = 1;
+                this.getDataList(1);
+            },
+            getDataList(flag,isTurnPage) {
+                const params = this.getFilterItems(isTurnPage);
+                this.searched = true;
+                const loading = this.$loading({
+                    lock: true,
+                    text: 'Loading',
+                    spinner: 'el-icon-loading',
+                    background: 'rgba(0, 0, 0, 0.7)'
+                });
+                api.diagBasePage(params).then((res) => {
+                    loading.close();
+                    if (res.data.code == '0') {
+                        const data = res.data.data;
+                        for(let j = 0;j < data.records.length;j++){
+                            data.records[j].condition = (data.records[j].parStatus == '1'?'启用':'禁用')
+                        }
+                        this.list = data.records;
+                        if(!flag){//搜索时不缓存
+                            this.cacheData[params.current] = data.records;
+                        }else{
+                            this.cacheData = {}
+                        }
+                        this.total = data.total;
+                        if(this.inCurrentPage!==undefined){
+                            this.currentPage=this.inCurrentPage;
+                            this.inCurrentPage = undefined;
+                        }
+                    }else{
+                        this.warning(res.data.msg||'获取列表数据失败');
+                    }
+                }).catch((error) => {
+                    loading.close();
+                    console.log(error);
+                });
+            },
+            getFilterItems(isTurnPage) {
+                //翻页时筛选条件没点确定则清空
+                if(isTurnPage&&!this.searched){
+                    this.clearFilter();
+                };
+                const param = {
+                    current: this.inCurrentPage||this.currentPage,
+                    size: this.pageSize,
+                    conceptName: this.filter.conceptName,
+                };
+                return param;
+            },
+            indexMethod(index) {
+                return ((this.currentPage - 1) * this.pageSize) + index + 1;
+            },
+            currentChange(next) {
+                this.currentPage = next;
+                /*if (this.cacheData[next]) {       //如果已请求过该页数据，则使用缓存不重复请求
+                  this.list = this.cacheData[next];
+                } else {*/
+                this.getDataList(1,true);
+                //}
+            },
+            warning(msg,type){
+                this.$message({
+                    showClose: true,
+                    message:msg,
+                    type:type||'warning'
+                })
+            },
+            showConfirmDialog(msg,resolve){
+                this.$alert(msg, '提示', {
+                    confirmButtonText: '确定',
+                    type: 'warning'
+                }).then(() => {
+                    resolve();
+                }).catch(() => {});
+            },
+            editData(id,isCopy){
+                const pam = this.searched ? {
+                    currentPage: this.currentPage,
+                    pageSize:this.pageSize,
+                    filter: this.filter
+                } : {currentPage: this.currentPage,
+                    pageSize:this.pageSize};
+                api.ruleDetail({id}).then((res) => {
+                    if (res.data.code == '0') {
+                        const data = res.data.data;
+                        this.$router.push({name:'AddZskRule',params:{...pam,data,copy:isCopy}});
+                    }
+                }).catch((error) => {
+                    this.warning('获取详情失败，请重试')
+                });
+            },
+            showDelDialog(row,isDelete){
+                const params = {
+                    id:row.parId
+                };
+                const txt=row.parStatus===0?'重新启用':'禁用';
+                const warningTxt = isDelete?'是否删除该规则？可能对现有系统造成影响':'是否'+txt+'该条数据？';
+                const handleFn = isDelete?api.deleteRule:(row.parStatus===0?api.saveRuleApply:api.deleteRuleApply);
+                this.showConfirmDialog(warningTxt,()=>{
+                    handleFn(params).then((res)=>{
+                        if(res.data.code=='0'){
+                            if(!this.searched){
+                                //未点确认时清空搜索条件
+                                this.clearFilter();
+                            }
+                            if(isDelete){       //恢复成功后跳转到筛选条件的首页
+                                this.currentPage = 1;
+                            } else {
+                                if (this.filter.status!==''&&this.list.length === 1){
+                                    //有启用状态筛选条件且当前页只有最后一条数据删除时，删除成功后跳转到前一页
+                                    this.currentPage = this.currentPage===1?1:this.currentPage-1;
+                                }
+                            }
+                            this.warning(res.data.msg||'操作成功','success');
+                            this.getDataList();
+                        }else{
+                            this.warning(res.data.msg);
+                        }
+                    }).catch((error)=>{
+                        this.warning(error);
+                    })
+                });
+            },
+            clearFilter(){
+                this.filter={
+                    conceptName:'',
+                };
+            },
+            update(){
+                const loading = this.$loading({
+                    lock: true,
+                    text: 'Loading',
+                    spinner: 'el-icon-loading',
+                    background: 'rgba(0, 0, 0, 0.7)'
+                });
+                api.zskUpdateAll().then((res) => {
+                    loading.close();
+                    if (res.data.code == '0') {
+                        this.warning('更新成功','success');
+                        this.getDataList();
+                    }
+                }).catch((error) => {
+                    loading.close();
+                    this.warning('更新失败，请重试')
+                });
+            },
+        }
+    }
+</script>
+
+<style lang="less" scoped>
+    @import "../../less/admin.less";
+    /deep/ .container.knowledgeTitle {
+        height: 80px;
+        min-width: 970px!important;
+    }
+    .demo-form-inline{
+        margin: 30px 20px 0 0;
+    }
+    /deep/ .contents.knowledgeContents {
+        padding: 104px 20px 0;
+    }
+    .delete{
+        color: red;
+    }
+    .review{
+        color: #22ccc8;
+    }
+    .el-table .cell{
+        overflow: hidden;
+        white-space: nowrap;
+    }
+    #upFile{
+        display: none !important;
+    }
+    .unvailable{
+        color: #FE7D3D;
+        &:hover{
+            color: #f19061;
+        }
+    }
+</style>

src/components/knowledgeExtra/DiagBaseGroup.vue

@@ -0,0 +1,117 @@
+<template>
+    <div class="sub-groups">
+        <DiagBaseItem v-for="(rules,i) in data"
+                       ref="group"
+                       :groupData="rules"
+                       :isLast="data.length===1"
+                       :ind="i"
+                       :showAdd="data.length<maxNum"
+                       :baseTypes="baseTypes"
+                       :firstPlace="firstPlace"
+                       :disabled="i===0&&disable"
+                       @changeVal="handleInput"
+                       @addRule="addRule"
+                       @delRule="delRule"></DiagBaseItem>
+        <div class="group-oper">
+            <el-button size="small" @click="addGroup">+新增分组</el-button>
+            <el-button :disabled="isLast" size="small" type="danger" plain @click="delGroup">-删除分组</el-button>
+        </div>
+    </div>
+</template>
+<script>
+    import DiagBaseItem from './DiagBaseItem.vue';
+    export default {
+        name:'SubRulesGroup',
+        props:['data','inx','isLast','baseTypes','maxNum','firstPlace'],
+        data(){
+            return {
+            }
+        },
+        computed:{
+            'disable':function(){
+                return Object.keys(this.firstPlace||{}).length>0;
+            }
+        },
+        methods:{
+            handleInput(val,i){
+                this.data[i]=val;
+            },
+            addRule(){
+                let temp={
+                    subDescription:'',
+                    subConceptId:'',
+                    subType:'',
+                    subLenName:'',
+                    subLenCode:'',
+                    subLibName:'',
+                    subMaxOperator:'',
+                    subMaxUnit:'',
+                    subMaxValue:'',
+                    subMinOperator:'',
+                    subMinUnit:'',
+                    subMinValue:'',
+                    subEqValue:'',
+                    dataType:'',
+                };
+                this.data.push(temp);
+            },
+            delRule(i){
+                if(i===0&&this.data.length===1){
+                    this.$emit("delGroup",this.inx);
+                    return;
+                }
+                this.data.splice(i,1);
+            },
+            addGroup(){
+                this.$emit("addGroup");
+            },
+            delGroup(){
+                this.$emit("delGroup",this.inx);
+            },
+            warning(msg,type){
+                this.$message({
+                    showClose: true,
+                    message:msg,
+                    type:type||'warning'
+                })
+            },
+            showConfirmDialog(msg,resolve){
+                this.$alert(msg, '提示', {
+                    confirmButtonText: '确定',
+                    type: 'warning'
+                }).then(() => {
+                    resolve();
+                }).catch(() => {
+                    this.warning("删除失败，请重试！")
+                });
+            },
+        },
+        components:{
+            DiagBaseItem
+        }
+    }
+</script>
+<style lang="less" scoped>
+    .sub-groups{
+        background: #F5F5F5;
+        padding: 20px;
+    }
+    .group-oper{
+        text-align: center;
+        padding: 11px 0;
+        border-top: 4px solid #F5F5F5;
+        background: #fff;
+    }
+    .el-button--danger.is-plain:focus, .el-button--danger.is-plain:hover{
+        color: #fbc4c4;
+        border-color:#fbc4c4;
+    }
+    .el-button--danger.is-plain{
+        background: none;
+        &.is-disabled{
+            color: #f9a7a7;
+            background-color: #fef0f0;
+            border-color: #fde2e2;
+        }
+    }
+</style>

src/components/knowledgeExtra/DiagBaseItem.vue

@@ -0,0 +1,453 @@
+<template>
+    <div class="groups-cont">
+        <el-form ref="groupData" label-width="150px" class="sub-condition-form" :model="groupData" :rules="rules">
+            <span v-if="!disabled&&!isLast" class="del-btn"  @click="delRule">删除</span><!--:class="isLast?'disable del-btn':'del-btn'"-->
+            <el-form-item label="基础依据名称：" prop="subDescription">
+                <el-input v-model.trim = "groupData.subDescription" :disabled="disabled"></el-input>
+            </el-form-item>
+            <el-form-item label="基础依据类型：" prop="subType">
+                <el-select v-model="groupData.subType"
+                           :disabled="disabled"
+                           placeholder="请选择"
+                           size="small"
+                           @change="subTypeChange">
+                    <el-option
+                            v-for="item in baseTypes"
+                            :key="item.id"
+                            :label="item.name"
+                            :value="item.type">
+                    </el-option>
+                </el-select>
+            </el-form-item>
+            <el-form-item label="基础依据术语类型：" prop="subLenCode">
+                <el-select v-model="groupData.subLenCode"
+                           :disabled="disabled"
+                           placeholder="请选择"
+                           size="small" @change="subCodeChange">
+                    <el-option
+                            v-for="item in baseTermTypeList"
+                            :key="item.id"
+                            :label="item.name"
+                            :value="item.code">
+                    </el-option>
+                </el-select>
+            </el-form-item>
+            <el-form-item  class="addDepartFormItem" label="医学标准术语：" prop="subConceptId">
+                <el-select clearable remote filterable :disabled="disabled" :remote-method="searchConcept" v-model.trim="groupData.subConceptId">
+                    <el-option
+                            v-for="item in conceptList"
+                            :key="item.conceptId"
+                            :label="item.conceptName"
+                            :value="item.conceptId">
+                    </el-option>
+                </el-select>
+            </el-form-item>
+            <el-form-item v-if="groupData.subType===2&&showDataType" label="选择类型：" prop="dataType">
+                <el-select v-model="groupData.dataType"
+                           placeholder="请选择"
+                           size="small" @change="dataTypeChange">
+                    <el-option
+                            v-for="item in dataTypes"
+                            :key="item.id"
+                            :label="item.name"
+                            :value="item.id">
+                    </el-option>
+                </el-select>
+            </el-form-item>
+            <el-form-item class="min-margin" v-if="groupData.dataType==='1'" label="最大值：">
+                <div class="select-item clearfix">
+                    <el-col :span="3">
+                        <el-form-item prop="subMaxOperator">
+                            <el-select v-model="groupData.subMaxOperator"
+                                       placeholder="请选择"
+                                       size="small" clearable>
+                                <el-option
+                                        v-for="item in operMaxList"
+                                        :key="item.key"
+                                        :label="item.name"
+                                        :value="item.key">
+                                </el-option>
+                            </el-select>
+                        </el-form-item>
+                    </el-col>
+                    <el-col :span="3">
+                        <el-form-item prop="subMaxValue">
+                            <el-input type="text" v-model="groupData.subMaxValue" placeholder="填写数值"/>
+                        </el-form-item>
+                    </el-col>
+                    <el-col :span="3">
+                        <el-form-item prop="subMaxUnit">
+                            <el-input  type="text" v-model.trim="groupData.subMaxUnit" placeholder="填写单位"/>
+                        </el-form-item>
+                    </el-col>
+                </div>
+            </el-form-item>
+            <el-form-item class="min-margin" v-if="groupData.dataType==='1'" label="最小值：">
+                <div class="select-item clearfix">
+                    <el-col :span="3">
+                        <el-form-item prop="subMinOperator">
+                            <el-select v-model="groupData.subMinOperator"
+                                       placeholder="请选择"
+                                       size="small" clearable>
+                                <el-option
+                                        v-for="item in operMinList"
+                                        :key="item.name"
+                                        :label="item.name"
+                                        :value="item.name">
+                                </el-option>
+                            </el-select>
+                        </el-form-item>
+                    </el-col>
+                    <el-col :span="3">
+                        <el-form-item prop="subMinValue">
+                            <el-input type="text" v-model="groupData.subMinValue" placeholder="填写数值"/>
+                        </el-form-item>
+                    </el-col>
+                    <el-col :span="3">
+                        <el-form-item prop="subMinUnit">
+                            <el-input  type="text" v-model.trim="groupData.subMinUnit" placeholder="填写单位"/>
+                        </el-form-item>
+                    </el-col>
+                </div>
+            </el-form-item>
+            <el-form-item v-if="groupData.subType!==6&&groupData.dataType==='2'" label="医学内容：" prop="subEqValue" class="discDesc is-required">
+                <el-input type="textarea" rows="3" placeholder="请输入医学内容" v-model.trim="groupData.subEqValue"></el-input>
+            </el-form-item>
+            <el-form-item v-if="groupData.subType===6" label="正则表达式：" prop="subEqValue" class="discDesc is-required">
+                <el-input type="textarea" rows="3" placeholder="请输入正则表达式" v-model.trim="groupData.subEqValue"></el-input>
+            </el-form-item>
+        </el-form>
+        <div class="inner-oper" v-if="showAdd">
+            <span>新增基础依据：</span>
+            <span class="add-btn" @click="addRule"><img src="../../images/add.png" alt="新增基础依据"></span>
+        </div>
+    </div>
+</template>
+<script>
+    import api from '@api/knowledgeLib.js';
+    export default {
+        name:'DiagBaseItem',
+        props:['groupData','ind','isLast','baseTypes','firstPlace','disabled','showAdd'],
+        data(){
+            return {
+                baseTermTypeList:[],
+                typeList:[],
+                numTypes:'',    //只有数值类型的类型id
+                operMaxList:[
+                    {name:'<=',key:'<='},
+                    {name:'<',key:'<'},
+                ],
+                operMinList:[{name:'>',key:'>'},
+                    {name:'>=',key:'>='},
+                ],
+                dataTypes:[{id:'1',name:'数值类型'},{id:'2',name:'文本类型'}],
+                conceptList:[],
+                rules:{
+                    subDescription:[{ required: true, message: '请输入基础规则名称',trigger: ['blur'] },{
+                        validator: (rule,value,callback)=>{
+                            if(value.length>100){
+                                callback(new Error('规则名称不能超过100字'));
+                            }else{
+                                callback();
+                            }}, trigger: 'change'
+                    }],
+                    subType:[{ required: true, message: '请选择基础规则类型',trigger: ['change'] }],
+                    subLenCode:[{ required: true, message: '请选择基础规则术语类型',trigger: ['change'] }],
+                    subConceptId:[{ required: true, message: '请输入医学标准术语',trigger: ['blur'] }],
+                    dataType:[{ required: true, message: '请选择类型',trigger: ['change'] }],
+                    subMaxOperator:[{
+                        validator: (rule,value,callback)=>{
+                            const {subMaxValue,subMinOperator,subMinValue}=this.groupData;
+                            const val=value+subMinOperator+subMinValue+subMaxValue;
+                            if(!val||(!value&&subMaxValue!=='')){
+                                callback(new Error('最大值和最小值至少完整填写一个，单位不必填'));
+                            }else{
+                                callback();
+                            }}, trigger: 'blur'
+                    }],
+                    subMinOperator:[{
+                        validator: (rule,value,callback)=>{
+                            const {subMaxValue,subMaxOperator,subMinValue}=this.groupData;
+                            const val=value+subMaxOperator+subMinValue+subMaxValue;
+                            if(!val||(!value&&subMinValue!=='')){
+                                callback(new Error('最大值和最小值至少完整填写一个，单位不必填'));
+                            }else{
+                                callback();
+                            }}, trigger: 'blur'
+                    }],
+                    subMaxValue:[{
+                        validator: (rule,value,callback)=>{
+                            const {subMaxOperator,subMinOperator,subMinValue}=this.groupData;
+                            const val=value+subMaxOperator+subMinValue+subMinOperator;
+                            const isNum=/^(\-|\+)?\d+(\.\d+)?$/.test(value);
+                            if(!val||(value==''&&subMaxOperator)){
+                                callback(new Error('最大值和最小值至少完整填写一个，单位不必填'));
+                            }else if(value!==''&&!isNum){
+                                callback(new Error('只能输入数字'));
+                            }else{
+                                callback();
+                            }}, trigger: 'blur'
+                    }],
+                    subMinValue:[{
+                        validator: (rule,value,callback)=>{
+                            const {subMaxValue,subMinOperator,subMaxOperator}=this.groupData;
+                            const val=value+subMaxOperator+subMaxValue+subMinOperator;
+                            const isNum=/^(\-|\+)?\d+(\.\d+)?$/.test(value);
+                            if(!val||(value==''&&subMinOperator)){
+                                callback(new Error('最大值和最小值至少完整填写一个，单位不必填'));
+                            }else if(value!==''&&!isNum){
+                                callback(new Error('只能输入数字'));
+                            }else{
+                                callback();
+                            }}, trigger: 'blur'
+                    }],
+                    subEqValue:[{
+                        validator: (rule,value,callback)=>{
+                            if(value===''){
+                                callback(new Error('请输入'+this.textName));
+                            }else if(value.length>200){
+                                callback(new Error(this.textName+'不能超过200字'));
+                            }else{
+                                callback();
+                            }}, trigger: 'blur'
+                    }],
+                },
+            }
+        },
+        watch:{
+            'groupData':{
+                handler:function(val){
+                    this.$emit("changeVal",val,this.ind);
+                },
+                deep:true
+            },
+            'baseTypes':{
+                handler:function(val){
+                    if(!this.groupData.subType){
+                        this.baseTermTypeList =[];
+                        return;
+                    }
+                    const obj = val.find((it)=>it.type===this.groupData.subType);
+                    this.baseTermTypeList = obj.subMenuList;
+                },
+                deep:true
+            },
+            'firstPlace':{
+                handler:function(val) {
+                    if (this.ind!==0||!val) return;
+                    const dict = localStorage.getItem("zskDicts").match(new RegExp(val.checkedType+'-\\d+','g'))||[];
+                    const types = dict[0].split("-");
+                    const sub = this.baseTypes.find((it) => it.ruleType === +types[0] && it.type === +types[2]);
+                    this.groupData.subType = sub.type;
+                    this.baseTermTypeList = sub.subMenuList;
+                    this.groupData.subLenCode = (this.baseTermTypeList.find((it) => it.ruleType === +types[0])||{}).code;
+                    this.conceptList = [val];
+                    this.groupData.subDescription = val.conceptName;
+                    this.groupData.subConceptId = val.conceptId;
+                    this.groupData.subConceptName = val.conceptName;
+                },
+                deep:true
+            }
+        },
+        created(){
+            this.numTypes = localStorage.getItem("zskNumDict");
+            this.conceptList=[{conceptName:this.groupData.subLibName||this.groupData.subConceptName,conceptId:this.groupData.subConceptId}];
+            if(this.groupData.subLenCode){
+                this.baseTermTypeList=[{name:this.groupData.subLenName,code:this.groupData.subLenCode}];
+            }
+        },
+        computed:{
+            showDataType:function(){
+                return (this.numTypes+',').indexOf(this.groupData.subLenCode+',')===-1;
+            },
+            textName:function(){
+                return this.groupData.subType!==6&&this.groupData.dataType==='2'?'医学内容':'正则表达式';
+            }
+        },
+        methods:{
+            dataTypeChange(val){
+                this.groupData.subEqOperator=(val==='2'?'=':'');
+                this.clearNumText();
+                delete this.groupData.dataType;     //触发更新
+                this.$set(this.groupData,'dataType',val);
+            },
+            subTypeChange(val){        //基础规则类型修改
+                this.groupData.subLenCode='';
+                this.groupData.dataType='';
+                this.clearConcept();
+                this.clearNumText();
+                if(!val){
+                    this.baseTermTypeList =[];
+                    return;
+                }
+                const obj = this.baseTypes.find((it)=>it.type===val);
+                this.baseTermTypeList = obj.subMenuList;
+            },
+            subCodeChange(val){        //基础规则术语类型修改
+                this.groupData.subLenCode=val;
+                if((this.numTypes+',').indexOf(val+',')>-1){
+                    this.groupData.dataType='1';
+                }else{
+                    this.groupData.dataType='';
+                }
+                this.clearConcept();
+                this.clearNumText();
+            },
+            clearConcept(){
+                this.groupData.subConceptId='';
+                this.conceptList=[];
+            },
+            clearNumText(){
+                this.groupData.subMaxOperator='';
+                this.groupData.subMaxValue='';
+                this.groupData.subMaxUnit='';
+                this.groupData.subMinOperator='';
+                this.groupData.subMinValue='';
+                this.groupData.subMinUnit='';
+                this.groupData.subEqValue='';
+                this.groupData.subEqOperator='';
+            },
+            searchConcept(val){
+                const param = {
+                    excludedConceptIds:[this.groupData.subType],
+                    libType:this.groupData.subLenCode,
+                    name:val,
+                };
+                api.searchConcept(param).then((res) => {
+                    if (res.data.code == '0') {
+                        const data = res.data.data;
+                        this.conceptList = data;
+                    }
+                }).catch((error) => {
+                    console.log(error);
+                });
+            },
+            addRule(){
+                this.$emit("addRule");
+            },
+            delRule(){
+                if(this.isLast){
+                    this.warning("初始状态规则不能删除~");
+                    return;
+                }
+                //this.showConfirmDialog("是否删除该条规则，可能对现有系统会造成影响",()=>{
+                this.$emit("delRule",this.ind);
+                //});
+
+            },
+            warning(msg,type){
+                this.$message({
+                    showClose: true,
+                    message:msg,
+                    type:type||'warning'
+                })
+            },
+            showConfirmDialog(msg,resolve){
+                this.$alert(msg, '提示', {
+                    confirmButtonText: '确定',
+                    type: 'warning'
+                }).then(() => {
+                    resolve();
+                }).catch(() => {});
+            },
+        }
+    }
+</script>
+<style lang="less">
+    .groups-cont{
+        background: #fff;
+        .conceptItem{
+            padding: 0 10px;
+            cursor: pointer;
+            height: 32px;
+            line-height: 32px;
+            &:hover{
+                background: #ebedf1;
+            }
+        }
+        .inner-oper{
+            padding: 15px 0 15px 21px;
+            .add-btn {
+                cursor: pointer;
+                img {
+                    vertical-align: middle;
+                }
+            }
+        }
+        .sub-condition-form{
+            padding: 20px;
+            position: relative;
+            border-bottom:2px solid #F5F5F5;
+            .del-btn{
+                color: #FF5B5B;
+                cursor: pointer;
+                position: absolute;
+                right: 20px;
+                top:20px;
+                z-index: 1;
+                &.disable{
+                    color: #B8B8B8;
+                }
+            }
+        }
+        .el-input__icon{
+            line-height: 32px;
+        }
+        .select-item{
+            &>div{
+                float: left;
+                margin-right: 10px;
+            }
+            .el-input{
+                width: auto;
+            }
+            input{
+                width: 95px;
+                line-height: 32px;
+                height: 32px;
+            }
+        }
+        .el-input,.el-input__inner{
+            width: 190px;
+            line-height: 32px;
+            height: 32px;
+        }
+        .el-button--danger.is-plain{
+            background: none;
+        }
+        .itemList {
+            position: absolute;
+            // display: none;
+            background: #fff;
+            width: 188px;
+            max-height: 160px;
+            border: 1px solid #DCDFE6;
+            left: 0;
+            top: 37px;
+            z-index: 2;
+            overflow-y: auto;
+        }
+        .el-form-item{
+            margin-bottom: 22px;
+            &.min-margin{
+                margin-bottom: 0;
+            }
+        }
+        .el-form-item__error{
+            top: auto;
+            white-space: nowrap;
+            background: #fff;
+        }
+        .el-input-number{
+            width: 95px;
+        }
+        .el-input-number.is-controls-right .el-input-number__decrease, .el-input-number.is-controls-right .el-input-number__increase{
+            width: 25px;
+            height: 15px;
+            line-height: 16px;
+        }
+        .el-col-3 {
+            width: 94px;
+        }
+    }
+</style>

src/components/knowledgeExtra/DiagBaseType.vue

@@ -0,0 +1,63 @@
+<template>
+    <el-form ref="form" class="add-new-form" label-width="130px" :model="form" :rules="rules">
+            <el-form-item label="诊断依据类型：" prop="conditionType">
+                <el-select v-model="form.conditionType"
+                           placeholder="请选择"
+                           size="small" @change="typeChange">
+                    <el-option
+                            v-for="item in typeList"
+                            :key="item.id"
+                            :label="item.name"
+                            :value="item.id">
+                    </el-option>
+                </el-select>
+            </el-form-item>
+            <DiagBaseGroup v-for="(group,i) in subGroups"
+                       ref="groups"
+                       :data="group"
+                       :baseTypes="baseTypeList"
+                       :inx="i"
+                       :maxNum="subRuleMaxNum"
+                       :firstPlace="firstPlace"
+                       :isLast="subGroups.length===1"
+                       @addGroup="addGroup"
+                       @delGroup="delGroup"></DiagBaseGroup>
+    </el-form>
+</template>
+<script>
+    import DiagBaseGroup from './DiagBaseGroup';
+    export default {
+        name:'DiagBaseType',
+        props:['subGroups'],
+        data(){
+            return {
+                form:{},
+                conditionType:'',
+                typeList:[{name:'确诊',id:1},{name:'拟诊',id:2},{name:'警惕',id:3}],
+                baseTypeList:[],
+                subRuleMaxNum:'',
+                firstPlace:{},
+                rules:{}
+            }
+        },
+        methods:{
+            typeChange(){
+
+            },
+            addGroup(){
+
+            },
+            delGroup(){
+
+            }
+        },
+        components:{
+            DiagBaseGroup
+        }
+    }
+</script>
+<style lang="less" scoped>
+    .add-new-form{
+        background: #F5F5F5;
+    }
+</style>

src/routes.js

@@ -210,6 +210,8 @@ import AboutDisease from '@components/knowledgeExtra/AboutDisease.vue'
 import DiseaseTree from '@components/knowledgeExtra/DiseaseTree.vue'   
 import AutoKnowledgeMapRuleTest from '@components/autoTest/AutoKnowledgeMapRuleTest.vue';
 import AutoBillCommonTest from '@components/autoTest/AutoBillCommonTest.vue';
+import ZskDiagBase from '@components/knowledgeExtra/DiagBase.vue';      //知识库拓展-诊断依据维护
+import AddZskDiagBase from '@components/knowledgeExtra/AddDiagBase.vue';
 
 export default [
     {
@@ -516,21 +518,21 @@ export default [
                 component: DisclaimerDetailCDSS,
                 name: 'DisclaimerDetailCDSS',
             }, //免责声明维护--新增编辑
-            // {
-            //     path: 'LT-YYSYZDHCS-ZSTPGZCS',
-            //     component: KnowledgeMapRuleTest,
-            //     name: 'KnowledgeMapRuleTest',
-            // }, //知识图谱规则测试
+            {
+                path: 'LT-YYSYZDHCS-ZSTPGZCS',
+                component: KnowledgeMapRuleTest,
+                name: 'KnowledgeMapRuleTest',
+            }, //知识图谱规则测试
             {
                 path: 'LT-YYSYZDHCS-JTZSYSCS',
                 component: StaticKnowledgeMapTest,
                 name: 'StaticKnowledgeMapTest',
             }, //静态知识映射测试
-            // {
-            //     path: 'LT-YYSYZDHCS-ZSTPGZCS-TYGZCS',
-            //     component: BillCommonTest,
-            //     name: 'BillCommonTest',
-            // },
+            {
+                path: 'LT-YYSYZDHCS-ZSTPGZCS-TYGZCS',
+                component: BillCommonTest,
+                name: 'BillCommonTest',
+            },
             {
                 path: 'LT-YYSYZDHCS-ZSTPGZCS-SXGZCS',
                 component: BillFusionTest,
@@ -606,105 +608,16 @@ export default [
                 component: AddZskRule,
                 name: 'AddZskRule',
             },
-
-    { path: 'LT-CDSSSJWH-YYGL', component: HospitalCDSS, name: 'HospitalCDSS' }, //医院管理
-    { path: 'LT-CDSSSJWH-YYGLEDIT', component: AddHospitalCDSS, name: 'AddHospitalCDSS' }, //医院管理--新增编辑
-    { path: 'LT-CDSSSJWH-YYYHGL', component: HospitalUserCDSS, name: 'HospitalUserCDSS' }, //医院用户管理
-    {
-        path: 'LT-CDSSSJWH-YYYHGLEDIT',
-        component: AddHospitalUserCDSS,
-        name: 'AddHospitalUserCDSS',
-    }, //医院用户管理--添加用户
-    { path: 'LT-CDSSSJWH-BBWH', component: VersionCDSS, name: 'VersionCDSS' }, //CDSS版本信息维护
-    { path: 'LT-CDSSSJWH-BBWHEDIT', component: AddVersionCDSS, name: 'AddVersionCDSS' }, //CDSS版本信息维护--新增编辑
-    { path: 'LT-CDSSSJWH-BBWHDETAIL', component: VersionDetailCDSS, name: 'VersionDetailCDSS' }, //CDSS版本信息维护--详情
-    { path: 'LT-CDSSSJWH-MZSMWH', component: DisclaimerCDSS, name: 'DisclaimerCDSS' }, //免责声明维护
-    { path: 'LT-CDSSSJWH-MZSMWHEDIT', component: AddDisclaimerCDSS, name: 'AddDisclaimerCDSS' }, //免责声明维护--新增编辑
-    {
-        path: 'LT-CDSSSJWH-MZSMWHDETAIL',
-        component: DisclaimerDetailCDSS,
-        name: 'DisclaimerDetailCDSS',
-    }, //免责声明维护--新增编辑
-    // {
-    //     path: 'LT-YYSYZDHCS-ZSTPGZCS',
-    //     component: KnowledgeMapRuleTest,
-    //     name: 'KnowledgeMapRuleTest',
-    // }, //知识图谱规则测试
-    {
-        path: 'LT-YYSYZDHCS-JTZSYSCS',
-        component: StaticKnowledgeMapTest,
-        name: 'StaticKnowledgeMapTest',
-    }, //静态知识映射测试
-    // {
-    //     path: 'LT-YYSYZDHCS-ZSTPGZCS-TYGZCS',
-    //     component: BillCommonTest,
-    //     name: 'BillCommonTest',
-    // },
-    {
-        path: 'LT-YYSYZDHCS-ZSTPGZCS-SXGZCS',
-        component: BillFusionTest,
-        name: 'BillFusionTest',
-    },
-    {
-        path: 'LT-YYSYZDHCS-ZSTPGZCS-SYSJCGZCS',
-        component: CriticalLabTest,
-        name: 'CriticalLabTest',
-    },
-    {
-        path: 'LT-YYSYZDHCS-ZSTPGZCS-FZJCGZCS',
-        component: CriticalAuxTest,
-        name: 'CriticalAuxTest',
-    },
-    {
-        path: 'LT-YYSYZDHCS-ZSTPGZCS-GWYPGZCS',
-        component: HighRiskDrugTest,
-        name: 'HighRiskDrugTest',
-    },
-    {
-        path: 'LT-YYSYZDHCS-ZSTPGZCS-GWSSZHGZCS',
-        component: HighRiskOperationTest,
-        name: 'HighRiskOperationTest',
-    },
-    {
-        path: 'LT-YYSYZDHCS-ZSTPGZCS-QTHYGZCS',
-        component: OtherAssayRuleTest,
-        name: 'OtherAssayRuleTest',
-    },
-    {
-        path: 'LT-YYSYZDHCS-ZSTPGZCS-QTFJGZCS',
-        component: OtherAuxRuleTest,
-        name: 'OtherAuxRuleTest',
-    },
-    {
-        path: 'LT-YYSYZDHCS-ZSTPGZCS-QTFXGZCS',
-        component: OtherFusionRuleTest,
-        name: 'OtherFusionRuleTest',
-    },
-    {
-        path: 'LT-YYSYZDHCS-JTZSYSCS-WYSZD',
-        component: LessStaticOrNoMap,
-        name: 'LessStaticOrNoMap',
-    },
-    {
-        path: 'LT-ZSKJCWH-JCSYWH',
-        component: BasicTermsMaintenance,
-        name: 'BasicTermsMaintenance',
-    },
-    {
-        path: 'LT-ZSKJCWH-JCCXWH',
-        component: BasicPartOfSpeech,
-        name: 'BasicPartOfSpeech',
-    },
-    {
-        path: 'LT-ZSKJCWH-JCGXLXWH',
-        component: BasicRelationship,
-        name: 'BasicRelationship',
-    },
-    {
-        path: 'LT-ZSKJCWH-JCSYWH-EDIT',
-        component: AddTerm,
-        name: 'AddTerm',
-    },
+            {
+                path: 'LT-ZSKKZWH-ZUYJ',
+                component: ZskDiagBase,
+                name: 'ZskDiagBase',
+            },
+            {
+                path: 'LT-ZSKKZWH-TJZDYJ',
+                component: AddZskDiagBase,
+                name: 'AddZskDiagBase',
+            },
     {
         path: 'LT-ZSKKZWH-JTXXWH',
         component: StaticInfo,