三院知识库后台配置接口开发完成

business/base-service/src/main/java/com/yihu/jw/knowledge/dao/BaseKnowledgDictDao.java

@@ -1,14 +0,0 @@
package com.yihu.jw.knowledge.dao;
import com.yihu.jw.entity.knowledge.BaseKnowledgeDict;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
/**
 * 知识库-字典dao
 * @wangzhinan
 */
public interface BaseKnowledgDictDao extends JpaRepository<BaseKnowledgeDict, String>, JpaSpecificationExecutor<BaseKnowledgeDict> {
}

business/base-service/src/main/java/com/yihu/jw/knowledge/dao/BaseKnowledgDictRelationDao.java

@@ -1,14 +0,0 @@
package com.yihu.jw.knowledge.dao;
import com.yihu.jw.entity.knowledge.BaseKnowledgeDictRelation;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
/**
 * 知识库-字典关联dao
 * @wangzhinan
 */
public interface BaseKnowledgDictRelationDao extends JpaRepository<BaseKnowledgeDictRelation, String>, JpaSpecificationExecutor<BaseKnowledgeDictRelation> {
}

business/base-service/src/main/java/com/yihu/jw/knowledge/dao/BaseKnowledgFlowConfigurationDao.java

@@ -1,14 +0,0 @@
package com.yihu.jw.knowledge.dao;
import com.yihu.jw.entity.knowledge.BaseKnowledgeFlowConfiguration;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
/**
 * 知识库-流程问题配置dao
 * @wangzhinan
 */
public interface BaseKnowledgFlowConfigurationDao extends JpaRepository<BaseKnowledgeFlowConfiguration, String>, JpaSpecificationExecutor<BaseKnowledgeFlowConfiguration> {
}

business/base-service/src/main/java/com/yihu/jw/knowledge/dao/BaseKnowledgFlowConfigurationRelationDao.java

@@ -1,15 +0,0 @@
package com.yihu.jw.knowledge.dao;
import com.yihu.jw.entity.knowledge.BaseKnowledgeFlowConfiguration;
import com.yihu.jw.entity.knowledge.BaseKnowledgeFlowConfigurationRelation;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
/**
 * 知识库-流程问题配置关联dao
 * @wangzhinan
 */
public interface BaseKnowledgFlowConfigurationRelationDao extends JpaRepository<BaseKnowledgeFlowConfigurationRelation, String>, JpaSpecificationExecutor<BaseKnowledgeFlowConfigurationRelation> {
}

business/base-service/src/main/java/com/yihu/jw/knowledge/dao/BaseKnowledgQuestionDao.java

@@ -1,17 +0,0 @@
package com.yihu.jw.knowledge.dao;
import com.yihu.jw.entity.knowledge.BaseKnowledgeQuestion;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import java.util.List;
/**
 * 知识库-常见问题dao
 * @wangzhinan
 */
public interface BaseKnowledgQuestionDao extends JpaRepository<BaseKnowledgeQuestion, String>, JpaSpecificationExecutor<BaseKnowledgeQuestion> {
}

business/base-service/src/main/java/com/yihu/jw/knowledge/dao/BaseKnowledgQuestionsDao.java

@@ -1,14 +0,0 @@
package com.yihu.jw.knowledge.dao;
import com.yihu.jw.entity.knowledge.BaseKnowledgeQuestions;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
/**
 * 知识库-问题集dao
 * @wangzhinan
 */
public interface BaseKnowledgQuestionsDao extends JpaRepository<BaseKnowledgeQuestions, String>, JpaSpecificationExecutor<BaseKnowledgeQuestions> {
}

business/base-service/src/main/java/com/yihu/jw/knowledge/dao/BaseKnowledgQuestionsRelationDao.java

@@ -1,15 +0,0 @@
package com.yihu.jw.knowledge.dao;
import com.yihu.jw.entity.knowledge.BaseKnowledgeDict;
import com.yihu.jw.entity.knowledge.BaseKnowledgeQuestionsRelation;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
/**
 * 知识库-常见问题集关联关系dao
 * @wangzhinan
 */
public interface BaseKnowledgQuestionsRelationDao extends JpaRepository<BaseKnowledgeQuestionsRelation, String>, JpaSpecificationExecutor<BaseKnowledgeQuestionsRelation> {
}

business/base-service/src/main/java/com/yihu/jw/knowledge/dao/BaseKnowledgeDictDao.java

@@ -0,0 +1,24 @@
package com.yihu.jw.knowledge.dao;
import com.yihu.jw.entity.knowledge.BaseKnowledgeDict;
import com.yihu.jw.entity.knowledge.BaseKnowledgeQuestion;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.transaction.annotation.Transactional;
/**
 * 知识库-字典dao
 * @wangzhinan
 */
@Transactional
public interface BaseKnowledgeDictDao extends JpaRepository<BaseKnowledgeDict, String>, JpaSpecificationExecutor<BaseKnowledgeDict> {
    @Modifying
    @Query("update BaseKnowledgeDict p set p.del = ?2 where p.id = ?1")
    void updateDelById(String id,Integer del);
    @Query("from BaseKnowledgeDict p where p.sort = ?1 ")
    BaseKnowledgeDict selectBySort(Integer sort);
}

business/base-service/src/main/java/com/yihu/jw/knowledge/dao/BaseKnowledgeDictRelationDao.java

@@ -0,0 +1,27 @@
package com.yihu.jw.knowledge.dao;
import com.yihu.jw.entity.knowledge.BaseKnowledgeDictRelation;
import com.yihu.jw.entity.knowledge.BaseKnowledgeQuestionsRelation;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
/**
 * 知识库-字典关联dao
 * @wangzhinan
 */
@Transactional
public interface BaseKnowledgeDictRelationDao extends JpaRepository<BaseKnowledgeDictRelation, String>, JpaSpecificationExecutor<BaseKnowledgeDictRelation> {
    @Query("from BaseKnowledgeDictRelation p where p.dictId = ?1 ")
    List<BaseKnowledgeDictRelation> selectByDictId(String dictId);
    @Modifying
    @Query("delete from BaseKnowledgeDictRelation p where p.dictId=?1 ")
    void deleteByDictId(String dictId);
}

business/base-service/src/main/java/com/yihu/jw/knowledge/dao/BaseKnowledgeFlowConfigurationRelationDao.java

@@ -0,0 +1,22 @@
package com.yihu.jw.knowledge.dao;
import com.yihu.jw.entity.knowledge.BaseKnowledgeFlowConfigurationRelation;
import com.yihu.jw.entity.knowledge.BaseKnowledgeQuestionsRelation;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Query;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
/**
 * 知识库-流程问题配置关联dao
 * @wangzhinan
 */
@Transactional
public interface BaseKnowledgeFlowConfigurationRelationDao extends JpaRepository<BaseKnowledgeFlowConfigurationRelation, String>, JpaSpecificationExecutor<BaseKnowledgeFlowConfigurationRelation> {
    @Query("from BaseKnowledgeFlowConfigurationRelation p where p.questionId = ?1 ")
    List<BaseKnowledgeFlowConfigurationRelation> selectByQuestionId(String questionId);
}

business/base-service/src/main/java/com/yihu/jw/knowledge/dao/BaseKnowledgeQuestionDao.java

@@ -0,0 +1,28 @@
package com.yihu.jw.knowledge.dao;
import com.yihu.jw.entity.knowledge.BaseKnowledgeQuestion;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.transaction.annotation.Transactional;
/**
 * 知识库-常见问题dao
 * @wangzhinan
 */
@Transactional
public interface BaseKnowledgeQuestionDao extends JpaRepository<BaseKnowledgeQuestion, String>, JpaSpecificationExecutor<BaseKnowledgeQuestion> {
    @Modifying
    @Query("update BaseKnowledgeQuestion p set p.del = ?2 where p.id = ?1")
    void updateDelById(String id,Integer del);
    @Modifying
    @Query("update BaseKnowledgeQuestion p set p.flag = ?2 where p.id = ?1")
    void updateFlagById(String id,Integer flag);
    @Query("from BaseKnowledgeQuestion p where p.sort = ?1 ")
    BaseKnowledgeQuestion selectBySort(Integer sort);
}

business/base-service/src/main/java/com/yihu/jw/knowledge/dao/BaseKnowledgeQuestionsDao.java

@@ -0,0 +1,24 @@
package com.yihu.jw.knowledge.dao;
import com.yihu.jw.entity.knowledge.BaseKnowledgeQuestion;
import com.yihu.jw.entity.knowledge.BaseKnowledgeQuestions;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.transaction.annotation.Transactional;
/**
 * 知识库-问题集dao
 * @wangzhinan
 */
@Transactional
public interface BaseKnowledgeQuestionsDao extends JpaRepository<BaseKnowledgeQuestions, String>, JpaSpecificationExecutor<BaseKnowledgeQuestions> {
    @Query("from BaseKnowledgeQuestions p where p.sort = ?1 ")
    BaseKnowledgeQuestions selectBySort(Integer sort);
    @Modifying
    @Query("update BaseKnowledgeQuestions p set p.del = ?2 where p.id = ?1")
    void updateDelById(String id,Integer del);
}

business/base-service/src/main/java/com/yihu/jw/knowledge/dao/BaseKnowledgeQuestionsRelationDao.java

@@ -0,0 +1,27 @@
package com.yihu.jw.knowledge.dao;
import com.yihu.jw.entity.knowledge.BaseKnowledgeQuestion;
import com.yihu.jw.entity.knowledge.BaseKnowledgeQuestionsRelation;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
/**
 * 知识库-常见问题集关联关系dao
 * @wangzhinan
 */
@Transactional
public interface BaseKnowledgeQuestionsRelationDao extends JpaRepository<BaseKnowledgeQuestionsRelation, String>, JpaSpecificationExecutor<BaseKnowledgeQuestionsRelation> {
    @Query("from BaseKnowledgeQuestionsRelation p where p.questionsId = ?1 ")
    List<BaseKnowledgeQuestionsRelation> selectByQuestionsId(String questionsId);
    @Modifying
    @Query("delete from BaseKnowledgeQuestionsRelation p where p.questionsId=?1 ")
    void deleteByQuestionsId(String questionsId);
}

business/base-service/src/main/java/com/yihu/jw/knowledge/service/BaseKnowledgeDictService.java

@@ -0,0 +1,213 @@
package com.yihu.jw.knowledge.service;
import com.yihu.jw.dict.dao.DictHospitalDeptDao;
import com.yihu.jw.doctor.dao.BaseDoctorDao;
import com.yihu.jw.entity.base.dict.DictHospitalDeptDO;
import com.yihu.jw.entity.base.doctor.BaseDoctorDO;
import com.yihu.jw.entity.knowledge.BaseKnowledgeDict;
import com.yihu.jw.entity.knowledge.BaseKnowledgeDictRelation;
import com.yihu.jw.entity.knowledge.BaseKnowledgeQuestion;
import com.yihu.jw.knowledge.dao.*;
import com.yihu.jw.mysql.query.BaseJpaService;
import com.yihu.jw.restmodel.web.MixEnvelop;
import com.yihu.jw.utils.hibernate.HibenateUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
 * 字典中心
 *
 * @wangzhinan
 */
@Service
public class BaseKnowledgeDictService extends BaseJpaService<BaseKnowledgeDict, BaseKnowledgeDictDao> {
    private org.slf4j.Logger logger = LoggerFactory.getLogger(BaseKnowledgeDictService.class);
    @Autowired
    private BaseKnowledgeDictDao dictDao;
    @Autowired
    private BaseKnowledgeDictRelationDao dictRelationDao;
    @Autowired
    private HibenateUtils hibenateUtils;
    @Autowired
    private DictHospitalDeptDao hospitalDeptDao;
    @Autowired
    private BaseDoctorDao doctorDao;
    /**
     * 新增及修改字典
     * @param knowledgeDict
     * @return
     */
    public BaseKnowledgeDict insertAndUpdateDict(BaseKnowledgeDict knowledgeDict){
        if (StringUtils.isNoneBlank(knowledgeDict.getId())){
            BaseKnowledgeDict dict = dictDao.findById(knowledgeDict.getId()).get();
            knowledgeDict.setDel(dict.getDel());
            knowledgeDict.setSort(dict.getSort());
            knowledgeDict.setStatus(dict.getStatus());
            knowledgeDict.setUpdateTime(new Date());
        }else {
            knowledgeDict.setDel(1);
            knowledgeDict.setSort(maxSort("base_knowledge_dict")+1);
            knowledgeDict.setStatus(0);
            knowledgeDict.setCreateTime(new Date());
            knowledgeDict.setUpdateTime(new Date());
        }
        return dictDao.save(knowledgeDict);
    }
    /**
     * 获取排序的序号
     *
     * @param tableName
     * @return
     */
    public  Integer maxSort(String tableName){
        String sql = "SELECT MAX(sort) as sort from "+tableName+" where del=1  ";
        List<Map<String, Object>> rstotal = hibenateUtils.createSQLQuery(sql);
        Integer count = 0;
        if (rstotal != null && rstotal.size() > 0) {
            if (rstotal.get(0).get("sort")!=null){
                count = Integer.parseInt(rstotal.get(0).get("sort").toString());
            }
        }
        return count;
    }
    /**
     * 删除字典
     * @param id
     * @return
     */
    public void deleteDict(String id){
        dictDao.updateDelById(id, 0);
    }
    /**
     * 查询字典列表
     * @param name
     * @param type
     * @param status
     */
    public MixEnvelop selectDictList(String name, String type, String status, Integer page, Integer size){
        String condition = " and del = 1 order by sort asc,create_time desc ";
        String sql = "SELECT\n" +
                "\tid,\n" +
                "\ttype,\n" +
                "\tname,\n" +
                "\tdescription,\n" +
                "\tstatus,\n" +
                "\tsort\n" +
                "FROM\n" +
                "\tbase_knowledge_dict where 1=1 ";
        if (StringUtils.isNoneBlank(name)){
            condition +=" and NAME like '%"+name+"%' ";
        }
        if (StringUtils.isNoneBlank(type)){
            condition +=" and type ='"+type+"' ";
        }
        if (StringUtils.isNoneBlank(status)){
            condition +=" and status ='"+type+"' ";
        }
        List<Map<String, Object>> list = hibenateUtils.createSQLQuery(sql+condition, page, size);
        String sqlCount ="select COUNT(1) as total from base_knowledge_dict where 1=1 ";
        List<Map<String, Object>> rstotal = hibenateUtils.createSQLQuery(sqlCount+condition);
        Long count = 0L;
        if (rstotal != null && rstotal.size() > 0) {
            count = Long.parseLong(rstotal.get(0).get("total").toString());
        }
        return MixEnvelop.getSuccessListWithPage("success", list, page, size, count);
    }
    /**
     * 根据id查询某一个字典详情(关联数据)
     * @param id
     * @return
     */
    public BaseKnowledgeDict selectById(String id){
        BaseKnowledgeDict dict = dictDao.findById(id).get();
        if (dict.getStatus()==1){
            List<BaseKnowledgeDictRelation> dictRelations = dictRelationDao.selectByDictId(dict.getId());
            for (BaseKnowledgeDictRelation dictRelation:dictRelations){
                String dept = dictRelation.getDept();
                String doctor = dictRelation.getDoctor();
                String deptstr[]= dept.split(",");
                String doctorstr[]= doctor.split(",");
                List<DictHospitalDeptDO> hospitalDeptDOS = new ArrayList<>();
                List<BaseDoctorDO> doctorDOS = new ArrayList<>();
                for (int i=0;i<deptstr.length-1;i++){
                    DictHospitalDeptDO hospitalDeptDO = hospitalDeptDao.findByCode(deptstr[i]);
                    hospitalDeptDOS.add(hospitalDeptDO);
                }
                for (int i=0;i<doctorstr.length-1;i++){
                    BaseDoctorDO doctorDO = doctorDao.findById(doctorstr[i]).get();
                    doctorDOS.add(doctorDO);
                }
                dictRelation.setDeptDOS(hospitalDeptDOS);
                dictRelation.setDoctorDOS(doctorDOS);
            }
            dict.setDictRelations(dictRelations);
        }
        return dict;
    }
    /**
     * 字典设置排序
     * @param id
     * @param flag 1上移2下移
     */
    public BaseKnowledgeDict setDictSortById(String id,Integer flag){
        BaseKnowledgeDict knowledgeDict = dictDao.findById(id).get();
        int sort = 0;
        if (flag==1){
            sort = knowledgeDict.getSort()-1;
            BaseKnowledgeDict knowledgeDict1= dictDao.selectBySort(sort);
            if (knowledgeDict1!=null){
                knowledgeDict1.setSort(knowledgeDict.getSort()+1);
                dictDao.save(knowledgeDict1);
            }
        }else if (flag==2){
            sort = knowledgeDict.getSort()+1;
            BaseKnowledgeDict knowledgeDict1= dictDao.selectBySort(sort);
            if (knowledgeDict1!=null){
                knowledgeDict1.setSort(knowledgeDict.getSort()-1);
                dictDao.save(knowledgeDict1);
            }
        }
        if (sort!=0){
            knowledgeDict.setSort(sort);
        }
        return dictDao.save(knowledgeDict);
    }
    public void setDictRelation(BaseKnowledgeDictRelation baseKnowledgeDictRelation,Integer status){
        if (status==0){
            dictRelationDao.deleteByDictId(baseKnowledgeDictRelation.getDictId());
        }else {
            baseKnowledgeDictRelation.setUpdateTime(new Date());
            baseKnowledgeDictRelation.setCreateTime(new Date());
            dictRelationDao.save(baseKnowledgeDictRelation);
        }
        BaseKnowledgeDict dict = dictDao.findById(baseKnowledgeDictRelation.getDictId()).get();
        dict.setStatus(status);
        dictDao.save(dict);
    }
}

business/base-service/src/main/java/com/yihu/jw/knowledge/service/BaseKnowledgeQuestionService.java

@@ -0,0 +1,347 @@
package com.yihu.jw.knowledge.service;
import com.yihu.jw.entity.knowledge.*;
import com.yihu.jw.knowledge.dao.*;
import com.yihu.jw.mysql.query.BaseJpaService;
import com.yihu.jw.restmodel.web.MixEnvelop;
import com.yihu.jw.rm.hospital.BaseHospitalRequestMapping;
import com.yihu.jw.utils.hibernate.HibenateUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
 * 常见问题
 * @wangzhinan
 */
@Service
public class BaseKnowledgeQuestionService extends BaseJpaService<BaseKnowledgeQuestion, BaseKnowledgeQuestionDao> {
    private org.slf4j.Logger logger = LoggerFactory.getLogger(BaseKnowledgeQuestionService.class);
    @Autowired
    private BaseKnowledgeQuestionDao questionDao;
    @Autowired
    private BaseKnowledgeQuestionsDao questionsDao;
    @Autowired
    private BaseKnowledgeQuestionsRelationDao questionsRelationDao;
    @Autowired
    private BaseKnowledgeDictDao dictDao;
    @Autowired
    private BaseKnowledgeFlowConfigurationRelationDao flowConfigurationRelationDao;
    @Autowired
    private HibenateUtils hibenateUtils;
    /**
     * 新增常见问题
     * @param knowledgeQuestion
     * @return
     */
    public BaseKnowledgeQuestion insertAndUpdateQuestion(BaseKnowledgeQuestion knowledgeQuestion){
        if (StringUtils.isNoneBlank(knowledgeQuestion.getId())){
            BaseKnowledgeQuestion question = questionDao.findById(knowledgeQuestion.getId()).get();
            knowledgeQuestion.setDel(question.getDel());
            knowledgeQuestion.setSort(question.getSort());
            knowledgeQuestion.setUpdateTime(new Date());
        }else {
            knowledgeQuestion.setDel(1);
            knowledgeQuestion.setSort(maxSort("base_knowledge_question")+1);
            knowledgeQuestion.setCreateTime(new Date());
            knowledgeQuestion.setUpdateTime(new Date());
        }
        return questionDao.save(knowledgeQuestion);
    }
    /**
     * 获取排序的序号
     *
     * @param tableName
     * @return
     */
    public  Integer maxSort(String tableName){
        String sql = "SELECT MAX(sort) as sort from "+tableName+" where del=1  ";
        List<Map<String, Object>> rstotal = hibenateUtils.createSQLQuery(sql);
        Integer count = 0;
        if (rstotal != null && rstotal.size() > 0) {
            if (rstotal.get(0).get("sort")!=null){
                count = Integer.parseInt(rstotal.get(0).get("sort").toString());
            }
        }
        return count;
    }
    /**
     * 删除常见问题
     * @param id
     * @return
     */
    public void deleteQuestion(String id){
        questionDao.updateDelById(id, 0);
    }
    /**
     * 查询问题列表
     * @param name
     * @param type
     * @param status
     */
    public MixEnvelop selectQuestionList(String name,String type,String status,Integer page,Integer size){
        String condition = " and del = 1 order by sort asc,create_time desc ";
        String sql = "SELECT\n" +
                "\tid,\n" +
                "\ttype,\n" +
                "\tquestion_name AS questionName,\n" +
                "\tsimilar_question_name AS similarQuestionName,\n" +
                "\tanswer,\n" +
                "\tstatus,\n" +
                "\ttime,\n" +
                "\tsort\n" +
                "FROM\n" +
                "\tbase_knowledge_question where 1=1 ";
        if (StringUtils.isNoneBlank(name)){
            condition +=" and question_name like '"+name+"' ";
        }
        if (StringUtils.isNoneBlank(type)){
            condition +=" and type ='"+type+"' ";
        }
        if (StringUtils.isNoneBlank(status)){
            condition +=" and status ='"+type+"' ";
        }
        List<Map<String, Object>> list = hibenateUtils.createSQLQuery(sql+condition, page, size);
        String sqlCount ="select COUNT(1) as total from base_knowledge_question where 1=1 ";
        List<Map<String, Object>> rstotal = hibenateUtils.createSQLQuery(sqlCount+condition);
        Long count = 0L;
        if (rstotal != null && rstotal.size() > 0) {
            count = Long.parseLong(rstotal.get(0).get("total").toString());
        }
        return MixEnvelop.getSuccessListWithPage("success", list, page, size, count);
    }
    /**
     * 根据id查询某一个问题详情
     * @param id
     * @return
     */
    public BaseKnowledgeQuestion selectById(String id){
        return questionDao.findById(id).get();
    }
    /**
     * 问题设置排序
     * @param id
     * @param flag 1上移2下移
     */
    public BaseKnowledgeQuestion setQuestionSortById(String id,Integer flag){
        BaseKnowledgeQuestion knowledgeQuestion = questionDao.findById(id).get();
        int sort = 0;
        if (flag==1){
            sort = knowledgeQuestion.getSort()-1;
            BaseKnowledgeQuestion knowledgeQuestion1= questionDao.selectBySort(sort);
            if (knowledgeQuestion1!=null){
                knowledgeQuestion1.setSort(knowledgeQuestion.getSort()+1);
                questionDao.save(knowledgeQuestion1);
            }
        }else if (flag==2){
            sort = knowledgeQuestion.getSort()+1;
            BaseKnowledgeQuestion knowledgeQuestion1= questionDao.selectBySort(sort);
            if (knowledgeQuestion1!=null){
                knowledgeQuestion1.setSort(knowledgeQuestion.getSort()-1);
                questionDao.save(knowledgeQuestion1);
            }
        }
        if (sort!=0){
            knowledgeQuestion.setSort(sort);
        }
        return questionDao.save(knowledgeQuestion);
    }
    //=========================问题集合=============================
    /**
     * 新增问题集合
     * @param knowledgeQuestions
     * @return
     */
    public BaseKnowledgeQuestions insertAndUpdateQuestions(BaseKnowledgeQuestions knowledgeQuestions, List<BaseKnowledgeQuestionsRelation> questionsRelations){
        if (StringUtils.isNoneBlank(knowledgeQuestions.getId())){
            BaseKnowledgeQuestions question = questionsDao.findById(knowledgeQuestions.getId()).get();
            knowledgeQuestions.setDel(question.getDel());
            knowledgeQuestions.setCount(questionsRelations.size());
            knowledgeQuestions.setSort(question.getSort());
            knowledgeQuestions.setUpdateTime(new Date());
            questionsRelationDao.deleteByQuestionsId(question.getId());
        }else {
            knowledgeQuestions.setDel(1);
            knowledgeQuestions.setCount(questionsRelations.size());
            knowledgeQuestions.setSort(maxSort("base_knowledge_questions")+1);
            knowledgeQuestions.setCreateTime(new Date());
            knowledgeQuestions.setUpdateTime(new Date());
        }
        knowledgeQuestions = questionsDao.save(knowledgeQuestions);
        for (BaseKnowledgeQuestionsRelation questionsRelation:questionsRelations){
            questionsRelation.setQuestionsId(knowledgeQuestions.getId());
            questionsRelation.setCreateTime(new Date());
            questionsRelation.setUpdateTime(new Date());
            questionsRelationDao.save(questionsRelation);
        }
        return knowledgeQuestions;
    }
    /**
     * 删除问题集合
     * @param id
     * @return
     */
    public void deleteQuestions(String id){
        questionsDao.updateDelById(id, 0);
    }
    /**
     * 查询问题集合列表
     * @param name
     * @param type
     * @param status
     */
    public MixEnvelop selectQuestionsList(String name,String type,String status,Integer page,Integer size){
        String condition = " and del = 1 order by sort asc,create_time desc ";
        String sql = "SELECT\n" +
                "\tid,\n" +
                "\tbusiness_type AS businessType,\n" +
                "\tquestions_name AS questionsName,\n" +
                "\tcount,\n" +
                "\tdescription,\n" +
                "\tstatus,\n" +
                "\ttime,\n" +
                "\tsort\n" +
                "FROM\n" +
                "\tbase_knowledge_questions where 1=1 ";
        if (StringUtils.isNoneBlank(name)){
            condition +=" and questions_name like '"+name+"' ";
        }
        if (StringUtils.isNoneBlank(type)){
            condition +=" and business_type ='"+type+"' ";
        }
        if (StringUtils.isNoneBlank(status)){
            condition +=" and status ='"+type+"' ";
        }
        List<Map<String, Object>> list = hibenateUtils.createSQLQuery(sql+condition, page, size);
        for (Map<String,Object> map:list){
            String id = map.get("id").toString();
            List<BaseKnowledgeQuestionsRelation> questionsRelations = questionsRelationDao.selectByQuestionsId(id);
            for (BaseKnowledgeQuestionsRelation questionsRelation:questionsRelations){
                BaseKnowledgeQuestion question = questionDao.findById(questionsRelation.getQuestionId()).get();
                questionsRelation.setQuestion(question);
            }
            map.put("questionsRelation",questionsRelations);
        }
        String sqlCount ="select COUNT(1) as total from base_knowledge_questions where 1=1 ";
        List<Map<String, Object>> rstotal = hibenateUtils.createSQLQuery(sqlCount+condition);
        Long count = 0L;
        if (rstotal != null && rstotal.size() > 0) {
            count = Long.parseLong(rstotal.get(0).get("total").toString());
        }
        return MixEnvelop.getSuccessListWithPage("success", list, page, size, count);
    }
    /**
     * 根据id查询某一个问题集合详情
     * @param id
     * @return
     */
    public BaseKnowledgeQuestions selectQuestionsById(String id){
        BaseKnowledgeQuestions questions = questionsDao.findById(id).get();
        String questionsId = questions.getId();
        List<BaseKnowledgeQuestionsRelation> questionsRelations = questionsRelationDao.selectByQuestionsId(questionsId);
        for (BaseKnowledgeQuestionsRelation questionsRelation:questionsRelations){
            BaseKnowledgeQuestion question = questionDao.findById(questionsRelation.getQuestionId()).get();
            questionsRelation.setQuestion(question);
        }
        questions.setQuestionsRelations(questionsRelations);
        return questions;
    }
    /**
     * 问题集合设置排序
     * @param id
     * @param flag 1上移2下移
     */
    public BaseKnowledgeQuestions setQuestionsSortById(String id,Integer flag){
        BaseKnowledgeQuestions knowledgeQuestions = questionsDao.findById(id).get();
        int sort = 0;
        if (flag==1){
            sort = knowledgeQuestions.getSort()-1;
            BaseKnowledgeQuestions knowledgeQuestions1= questionsDao.selectBySort(sort);
            if (knowledgeQuestions1!=null){
                knowledgeQuestions1.setSort(knowledgeQuestions.getSort()+1);
                questionsDao.save(knowledgeQuestions1);
            }
        }else if (flag==2){
            sort = knowledgeQuestions.getSort()+1;
            BaseKnowledgeQuestions knowledgeQuestions1= questionsDao.selectBySort(sort);
            if (knowledgeQuestions1!=null){
                knowledgeQuestions1.setSort(knowledgeQuestions.getSort()-1);
                questionsDao.save(knowledgeQuestions1);
            }
        }
        if (sort!=0){
            knowledgeQuestions.setSort(sort);
        }
        return questionsDao.save(knowledgeQuestions);
    }
    //=========================流程配置关联===========================================
    /**
     * 关联设置
     * @param flowConfigurationRelations
     */
    public List<BaseKnowledgeFlowConfigurationRelation> setQuestionConfigurationRelation(List<BaseKnowledgeFlowConfigurationRelation> flowConfigurationRelations){
        for (BaseKnowledgeFlowConfigurationRelation flowConfigurationRelation:flowConfigurationRelations){
            flowConfigurationRelation.setCreateTime(new Date());
            flowConfigurationRelation.setUpdateTime(new Date());
            flowConfigurationRelationDao.save(flowConfigurationRelation);
        }
        if (flowConfigurationRelations!=null&&flowConfigurationRelations.size()!=0){
            BaseKnowledgeFlowConfigurationRelation configurationRelation = flowConfigurationRelations.get(0);
            questionDao.updateFlagById(configurationRelation.getQuestionId(),1);
        }
        return flowConfigurationRelations;
    }
    /**
     * 根据问题id获取问题关联配置
     * @param questionId
     * @return
     */
    public List<BaseKnowledgeFlowConfigurationRelation> selectFlowConfigurationRelations(String questionId){
        List<BaseKnowledgeFlowConfigurationRelation> flowConfigurationRelations = flowConfigurationRelationDao.selectByQuestionId(questionId);
        for (BaseKnowledgeFlowConfigurationRelation flowConfigurationRelation:flowConfigurationRelations){
            if (flowConfigurationRelation.getRelationCode().equalsIgnoreCase("1")){
                flowConfigurationRelation.setQuestion(questionDao.findById(flowConfigurationRelation.getRelationCode()).get());
            }else if (flowConfigurationRelation.getRelationCode().equalsIgnoreCase("2")){
                flowConfigurationRelation.setDict(dictDao.findById(flowConfigurationRelation.getRelationCode()).get());
            }else if (flowConfigurationRelation.getRelationCode().equalsIgnoreCase("3")){
                flowConfigurationRelation.setQuestions(questionsDao.findById(flowConfigurationRelation.getRelationCode()).get());
            }
        }
        return flowConfigurationRelations;
    }
}

common/common-entity/src/main/java/com/yihu/jw/entity/knowledge/BaseKnowledgeDict.java

@@ -4,6 +4,8 @@ import com.yihu.jw.entity.UuidIdentityEntityWithOperator;
import javax.persistence.Entity;
import javax.persistence.Table;
import javax.persistence.Transient;
import java.util.List;
/**
 * 知识库-字典
@@ -21,6 +23,18 @@ public class BaseKnowledgeDict extends UuidIdentityEntityWithOperator {
	private Integer sort;//排序
	private Integer del;//0删除1正常
	private List<BaseKnowledgeDictRelation> dictRelations;
	@Transient
	public List<BaseKnowledgeDictRelation> getDictRelations() {
		return dictRelations;
	}
	public void setDictRelations(List<BaseKnowledgeDictRelation> dictRelations) {
		this.dictRelations = dictRelations;
	}
	public String getType() {
		return type;
	}

common/common-entity/src/main/java/com/yihu/jw/entity/knowledge/BaseKnowledgeDictRelation.java

@@ -1,9 +1,14 @@
package com.yihu.jw.entity.knowledge;
import com.yihu.jw.entity.UuidIdentityEntityWithOperator;
import com.yihu.jw.entity.base.dict.DictHospitalDeptDO;
import com.yihu.jw.entity.base.doctor.BaseDoctorDO;
import com.yihu.jw.entity.hospital.dict.BaseDeptDict;
import javax.persistence.Entity;
import javax.persistence.Table;
import javax.persistence.Transient;
import java.util.List;
/**
 * 知识库-字典关联关系
@@ -19,6 +24,29 @@ public class BaseKnowledgeDictRelation extends UuidIdentityEntityWithOperator {
	private String dept; //科室code，多个以逗号隔开
	private String doctor; //医生code 多个以逗号隔开
	private List<DictHospitalDeptDO> deptDOS;
	private List<BaseDoctorDO> doctorDOS;
	@Transient
	public List<DictHospitalDeptDO> getDeptDOS() {
		return deptDOS;
	}
	public void setDeptDOS(List<DictHospitalDeptDO> deptDOS) {
		this.deptDOS = deptDOS;
	}
	@Transient
	public List<BaseDoctorDO> getDoctorDOS() {
		return doctorDOS;
	}
	public void setDoctorDOS(List<BaseDoctorDO> doctorDOS) {
		this.doctorDOS = doctorDOS;
	}
	public String getDictId() {
		return dictId;
	}

common/common-entity/src/main/java/com/yihu/jw/entity/knowledge/BaseKnowledgeFlowConfiguration.java

@@ -1,91 +0,0 @@
package com.yihu.jw.entity.knowledge;
import com.yihu.jw.entity.UuidIdentityEntityWithOperator;
import javax.persistence.Entity;
import javax.persistence.Table;
import java.util.Date;
/**
 * 流程配置
 *
 * @wangzhinan
 */
@Entity
@Table(name = "base_knowledge_flow_configuration")
public class BaseKnowledgeFlowConfiguration extends UuidIdentityEntityWithOperator {
	private String businessType;//业务类型wlyy_hospital_sys_dict（businessTypeDict）
	private String name; //配置名称
	private String description;//问题集描述
	private Integer status;//1开启0关闭
	private Integer time;//时效（1永久有效 2自定义有效期）
	private Date date;//时间
	private Integer sort;//排序
	private Integer del;//0删除1正常
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getBusinessType() {
		return businessType;
	}
	public void setBusinessType(String businessType) {
		this.businessType = businessType;
	}
	public String getDescription() {
		return description;
	}
	public void setDescription(String description) {
		this.description = description;
	}
	public Integer getStatus() {
		return status;
	}
	public void setStatus(Integer status) {
		this.status = status;
	}
	public Integer getTime() {
		return time;
	}
	public void setTime(Integer time) {
		this.time = time;
	}
	public Date getDate() {
		return date;
	}
	public void setDate(Date date) {
		this.date = date;
	}
	public Integer getSort() {
		return sort;
	}
	public void setSort(Integer sort) {
		this.sort = sort;
	}
	public Integer getDel() {
		return del;
	}
	public void setDel(Integer del) {
		this.del = del;
	}
}

common/common-entity/src/main/java/com/yihu/jw/entity/knowledge/BaseKnowledgeFlowConfigurationRelation.java

@@ -4,6 +4,7 @@ import com.yihu.jw.entity.UuidIdentityEntityWithOperator;
import javax.persistence.Entity;
import javax.persistence.Table;
import javax.persistence.Transient;
import java.util.Date;
/**
@@ -14,18 +15,43 @@ import java.util.Date;
@Entity
@Table(name = "base_knowledge_flow_configuration_relation")
public class BaseKnowledgeFlowConfigurationRelation extends UuidIdentityEntityWithOperator {
    private String configurationId;//配置id
    private String questionId;//问题id
    private String relationType;//关联类型（1常见问题、2字典中心、3问题集、4流程配置）
    private String relationType;//关联类型（1常见问题、2字典中心、3问题集）
    private String relationCode;//关联code
    private Integer del;//0删除1正常
    public String getConfigurationId() {
        return configurationId;
    private BaseKnowledgeQuestion question;//常见问题
    private BaseKnowledgeDict dict;//问题字典
    private BaseKnowledgeQuestions questions;//问题集
    @Transient
    public BaseKnowledgeQuestion getQuestion() {
        return question;
    }
    public void setQuestion(BaseKnowledgeQuestion question) {
        this.question = question;
    }
    @Transient
    public BaseKnowledgeDict getDict() {
        return dict;
    }
    public void setDict(BaseKnowledgeDict dict) {
        this.dict = dict;
    }
    @Transient
    public BaseKnowledgeQuestions getQuestions() {
        return questions;
    }
    public void setConfigurationId(String configurationId) {
        this.configurationId = configurationId;
    public void setQuestions(BaseKnowledgeQuestions questions) {
        this.questions = questions;
    }
    public String getQuestionId() {

common/common-entity/src/main/java/com/yihu/jw/entity/knowledge/BaseKnowledgeQuestion.java

@@ -1,7 +1,9 @@
package com.yihu.jw.entity.knowledge;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.yihu.jw.entity.UuidIdentityEntityWithOperator;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Table;
import java.util.Date;
@@ -18,6 +20,8 @@ public class BaseKnowledgeQuestion extends UuidIdentityEntityWithOperator {
	private String questionName; //标准问题
	private String similarQuestionName; //相似问题
	private String answer;//答案
	private Integer flag;//是否关联（1关联0未关联）
	private Integer status;//1开启0关闭
	private Integer time;//时效（1永久有效 2自定义有效期）
	private Date date;//时间
@@ -72,6 +76,8 @@ public class BaseKnowledgeQuestion extends UuidIdentityEntityWithOperator {
		this.time = time;
	}
	@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+08:00")
	@Column(name = "date", nullable = false, length = 0,updatable = false)
	public Date getDate() {
		return date;
	}

common/common-entity/src/main/java/com/yihu/jw/entity/knowledge/BaseKnowledgeQuestions.java

@@ -1,10 +1,14 @@
package com.yihu.jw.entity.knowledge;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.yihu.jw.entity.UuidIdentityEntityWithOperator;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Table;
import javax.persistence.Transient;
import java.util.Date;
import java.util.List;
/**
 * 问题集
@@ -25,6 +29,17 @@ public class BaseKnowledgeQuestions extends UuidIdentityEntityWithOperator {
	private Integer sort;//排序
	private Integer del;//0删除1正常
	private List<BaseKnowledgeQuestionsRelation> questionsRelations;
	@Transient
	public List<BaseKnowledgeQuestionsRelation> getQuestionsRelations() {
		return questionsRelations;
	}
	public void setQuestionsRelations(List<BaseKnowledgeQuestionsRelation> questionsRelations) {
		this.questionsRelations = questionsRelations;
	}
	public String getBusinessType() {
		return businessType;
	}
@@ -73,6 +88,8 @@ public class BaseKnowledgeQuestions extends UuidIdentityEntityWithOperator {
		this.time = time;
	}
	@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+08:00")
	@Column(name = "date", nullable = false, length = 0,updatable = false)
	public Date getDate() {
		return date;
	}

common/common-entity/src/main/java/com/yihu/jw/entity/knowledge/BaseKnowledgeQuestionsRelation.java

@@ -4,6 +4,7 @@ import com.yihu.jw.entity.UuidIdentityEntityWithOperator;
import javax.persistence.Entity;
import javax.persistence.Table;
import javax.persistence.Transient;
import java.util.Date;
/**
@@ -17,6 +18,18 @@ public class BaseKnowledgeQuestionsRelation extends UuidIdentityEntityWithOperat
	private String questionId;//单个问题id
	private String questionName;//单个问题名称
	private BaseKnowledgeQuestion question;//问题实体
	@Transient
	public BaseKnowledgeQuestion getQuestion() {
		return question;
	}
	public void setQuestion(BaseKnowledgeQuestion question) {
		this.question = question;
	}
	public String getQuestionsId() {
		return questionsId;
	}

common/common-request-mapping/src/main/java/com/yihu/jw/rm/hospital/BaseHospitalRequestMapping.java

@@ -1571,4 +1571,43 @@ public class BaseHospitalRequestMapping {
    public static class UpWebTherapySupserviceInfo extends Basic {
        public static final String PREFIX = "/open/gc";
    }
    /**
     * 知识库-问题
     */
    public static class BaseKnowledgeQuestion extends Basic{
        public static final String PREFIX  = "/baseKnowledgeQuestion";
        //==============问题=================
        public static final String insertAndUpdateQuestion = "/insertAndUpdateQuestion";
        public static final String deleteQuestion = "/deleteQuestion";
        public static final String selectQuestionList = "/selectQuestionList";
        public static final String selectById = "/selectById";
        public static final String setQuestionSortById = "/setQuestionSortById";
        //===========问题集合=================
        public static final String insertAndUpdateQuestions = "/insertAndUpdateQuestions";
        public static final String deleteQuestions = "/deleteQuestions";
        public static final String selectQuestionsList = "/selectQuestionsList";
        public static final String selectQuestionsById = "/selectQuestionsById";
        public static final String setQuestionsSortById = "/setQuestionsSortById";
        public static final String setQuestionConfigurationRelation = "/setQuestionConfigurationRelation";
        public static final String selectFlowConfigurationRelations = "/selectFlowConfigurationRelations";
    }
    /**
     * 知识库-字典
     */
    public static class BaseKnowledgeDict extends Basic{
        public static final String PREFIX  = "/baseKnowledgeDict";
        public static final String insertAndUpdateDict = "/insertAndUpdateDict";
        public static final String deleteDict = "/deleteDict";
        public static final String selectDictList = "/selectDictList";
        public static final String selectById = "/selectById";
        public static final String setDictSortById = "/setDictSortById";
        public static final String setDictRelation= "/setDictRelation";
    }
}

svr/svr-internet-hospital/src/main/java/com/yihu/jw/hospital/endpoint/knowledge/BaseKnowledgeDictController.java

@@ -0,0 +1,114 @@
package com.yihu.jw.hospital.endpoint.knowledge;
import com.yihu.jw.entity.knowledge.BaseKnowledgeDict;
import com.yihu.jw.entity.knowledge.BaseKnowledgeDictRelation;
import com.yihu.jw.knowledge.dao.BaseKnowledgeDictDao;
import com.yihu.jw.knowledge.service.BaseKnowledgeDictService;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import com.yihu.jw.rm.hospital.BaseHospitalRequestMapping;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping(value = BaseHospitalRequestMapping.BaseKnowledgeDict.PREFIX)
@Api(value = "知识库-字典配置", description = "知识库-字典配置", tags = {"知识库-字典配置"})
public class BaseKnowledgeDictController extends EnvelopRestEndpoint {
    @Autowired
    private BaseKnowledgeDictService dictService;
    @ApiOperation("新增/更新字典")
    @PostMapping(value= BaseHospitalRequestMapping.BaseKnowledgeDict.insertAndUpdateDict)
    public Envelop insertAndUpdateDict(@ApiParam(name = "json", value = "字典实体json", required = true)
                                   @RequestParam(value = "json", required = true)String json){
        try {
            BaseKnowledgeDict dict = toEntity(json,BaseKnowledgeDict.class);
            return success(dictService.insertAndUpdateDict(dict));
        }catch (Exception e){
            return failedException(e);
        }
    }
    @ApiOperation("删除字典")
    @PostMapping(value= BaseHospitalRequestMapping.BaseKnowledgeDict.deleteDict)
    public Envelop deleteDict(@ApiParam(name = "id", value = "字典id", required = true)
                                   @RequestParam(value = "id", required = true)String id){
        try {
            dictService.deleteDict(id);
            return success();
        }catch (Exception e){
            return failedException(e);
        }
    }
    @ApiOperation("查询字典列表")
    @GetMapping(value= BaseHospitalRequestMapping.BaseKnowledgeDict.selectDictList)
    public Envelop selectDictList(@ApiParam(name = "name", value = "字典名称", required = false)
                              @RequestParam(value = "name", required = false)String name,
                              @ApiParam(name = "type", value = "字典类型", required = false)
                              @RequestParam(value = "type", required = false)String type,
                              @ApiParam(name = "status", value = "1已设置0未设置", required = false)
                                  @RequestParam(value = "status", required = false)String status,
                              @ApiParam(name = "page", value = "页码", required = false)
                                  @RequestParam(value = "page", required = false)Integer page,
                              @ApiParam(name = "size", value = "大小", required = false)
                                  @RequestParam(value = "size", required = false)Integer size){
        try {
            return success(dictService.selectDictList(name,type,status,page,size));
        }catch (Exception e){
            return failedException(e);
        }
    }
    @ApiOperation("根据id查询某一个字典详情(关联数据)")
    @GetMapping(value= BaseHospitalRequestMapping.BaseKnowledgeDict.selectById)
    public Envelop selectById(@ApiParam(name = "id", value = "字典id", required = true)
                              @RequestParam(value = "id", required = true)String id){
        try {
            return success(dictService.selectById(id));
        }catch (Exception e){
            return failedException(e);
        }
    }
    @ApiOperation("字典设置排序")
    @GetMapping(value= BaseHospitalRequestMapping.BaseKnowledgeDict.setDictSortById)
    public Envelop setDictSortById(@ApiParam(name = "id", value = "字典id", required = true)
                              @RequestParam(value = "id", required = true)String id,
                                   @ApiParam(name = "flag", value = "1上移2下移", required = true)
                                   @RequestParam(value = "flag", required = true)Integer flag){
        try {
            return success(dictService.setDictSortById(id,flag));
        }catch (Exception e){
            return failedException(e);
        }
    }
    @ApiOperation("设置关联关系及取消关联关系")
    @GetMapping(value= BaseHospitalRequestMapping.BaseKnowledgeDict.setDictRelation)
    public Envelop setDictRelation(@ApiParam(name = "json", value = "json关联实体", required = true)
                                   @RequestParam(value = "json", required = true)String json,
                                   @ApiParam(name = "status", value = "1已设置0未设置", required = true)
                                   @RequestParam(value = "status", required = true)Integer status){
        try {
            BaseKnowledgeDictRelation dictRelation = toEntity(json,BaseKnowledgeDictRelation.class);
            dictService.setDictRelation(dictRelation,status);
            return success();
        }catch (Exception e){
            return failedException(e);
        }
    }
}

svr/svr-internet-hospital/src/main/java/com/yihu/jw/hospital/endpoint/knowledge/BaseKnowledgeQuestionController.java

@@ -0,0 +1,214 @@
package com.yihu.jw.hospital.endpoint.knowledge;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.yihu.jw.entity.knowledge.*;
import com.yihu.jw.knowledge.service.BaseKnowledgeQuestionService;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import com.yihu.jw.rm.hospital.BaseHospitalRequestMapping;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.ArrayList;
import java.util.List;
@RestController
@RequestMapping(value = BaseHospitalRequestMapping.BaseKnowledgeQuestion.PREFIX)
@Api(value = "知识库-问题配置", description = "知识库-问题配置", tags = {"知识库-问题配置"})
public class BaseKnowledgeQuestionController extends EnvelopRestEndpoint {
    @Autowired
    private BaseKnowledgeQuestionService questionService;
    @ApiOperation("新增/更新常见问题")
    @PostMapping(value= BaseHospitalRequestMapping.BaseKnowledgeQuestion.insertAndUpdateQuestion)
    public Envelop insertAndUpdateQuestion(@ApiParam(name = "json", value = "常见问题实体json", required = true)
                                       @RequestParam(value = "json", required = true)String json){
        try {
            BaseKnowledgeQuestion question = toEntity(json,BaseKnowledgeQuestion.class);
            return success(questionService.insertAndUpdateQuestion(question));
        }catch (Exception e){
            return failedException(e);
        }
    }
    @ApiOperation("删除常见问题")
    @PostMapping(value= BaseHospitalRequestMapping.BaseKnowledgeQuestion.deleteQuestion)
    public Envelop deleteQuestion(@ApiParam(name = "id", value = "常见问题id", required = true)
                              @RequestParam(value = "id", required = true)String id){
        try {
            questionService.deleteQuestion(id);
            return success();
        }catch (Exception e){
            return failedException(e);
        }
    }
    @ApiOperation("查询常见问题列表")
    @GetMapping(value= BaseHospitalRequestMapping.BaseKnowledgeQuestion.selectQuestionList)
    public Envelop selectQuestionList(@ApiParam(name = "name", value = "问题名称", required = false)
                                  @RequestParam(value = "name", required = false)String name,
                                  @ApiParam(name = "type", value = "字典类型", required = false)
                                  @RequestParam(value = "type", required = false)String type,
                                  @ApiParam(name = "status", value = "1开启0关闭", required = false)
                                  @RequestParam(value = "status", required = false)String status,
                                  @ApiParam(name = "page", value = "页码", required = false)
                                  @RequestParam(value = "page", required = false)Integer page,
                                  @ApiParam(name = "size", value = "大小", required = false)
                                  @RequestParam(value = "size", required = false)Integer size){
        try {
            return success(questionService.selectQuestionList(name,type,status,page,size));
        }catch (Exception e){
            return failedException(e);
        }
    }
    @ApiOperation("根据id查询某一个常见问题详情")
    @GetMapping(value= BaseHospitalRequestMapping.BaseKnowledgeQuestion.selectById)
    public Envelop selectById(@ApiParam(name = "id", value = "常见问题id", required = true)
                              @RequestParam(value = "id", required = true)String id){
        try {
            return success(questionService.selectById(id));
        }catch (Exception e){
            return failedException(e);
        }
    }
    @ApiOperation("常见问题设置排序")
    @GetMapping(value= BaseHospitalRequestMapping.BaseKnowledgeQuestion.setQuestionSortById)
    public Envelop setQuestionSortById(@ApiParam(name = "id", value = "字典id", required = true)
                                   @RequestParam(value = "id", required = true)String id,
                                   @ApiParam(name = "flag", value = "1上移2下移", required = true)
                                   @RequestParam(value = "flag", required = true)Integer flag){
        try {
            return success(questionService.setQuestionSortById(id,flag));
        }catch (Exception e){
            return failedException(e);
        }
    }
    //======================问题集===================================
    @ApiOperation("新增/更新问题集合")
    @PostMapping(value= BaseHospitalRequestMapping.BaseKnowledgeQuestion.insertAndUpdateQuestions)
    public Envelop insertAndUpdateQuestions(@ApiParam(name = "json", value = "问题集实体json", required = true)
                                           @RequestParam(value = "json", required = true)String json,
                                            @ApiParam(name = "relationJson", value = "问题集关联实体json", required = true)
                                            @RequestParam(value = "relationJson", required = true)String relationJson){
        try {
            BaseKnowledgeQuestions questions = toEntity(json,BaseKnowledgeQuestions.class);
            JSONArray array = JSONArray.parseArray(relationJson);
            List<BaseKnowledgeQuestionsRelation> questionsRelationList = new ArrayList<>();
            for (int i=0;i<array.size();i++){
                JSONObject object = array.getJSONObject(i);
                BaseKnowledgeQuestionsRelation questionsRelation = toEntity(object.toJSONString(),BaseKnowledgeQuestionsRelation.class);
                questionsRelationList.add(questionsRelation);
            }
            return success(questionService.insertAndUpdateQuestions(questions,questionsRelationList));
        }catch (Exception e){
            return failedException(e);
        }
    }
    @ApiOperation("删除问题集合")
    @PostMapping(value= BaseHospitalRequestMapping.BaseKnowledgeQuestion.deleteQuestions)
    public Envelop deleteQuestions(@ApiParam(name = "id", value = "问题集id", required = true)
                                  @RequestParam(value = "id", required = true)String id){
        try {
            questionService.deleteQuestions(id);
            return success();
        }catch (Exception e){
            return failedException(e);
        }
    }
    @ApiOperation("查询问题集合列表")
    @GetMapping(value= BaseHospitalRequestMapping.BaseKnowledgeQuestion.selectQuestionsList)
    public Envelop selectQuestionsList(@ApiParam(name = "name", value = "字典名称", required = false)
                                      @RequestParam(value = "name", required = false)String name,
                                      @ApiParam(name = "type", value = "字典类型", required = false)
                                      @RequestParam(value = "type", required = false)String type,
                                      @ApiParam(name = "status", value = "1开启0关闭", required = false)
                                      @RequestParam(value = "status", required = false)String status,
                                      @ApiParam(name = "page", value = "页码", required = false)
                                      @RequestParam(value = "page", required = false)Integer page,
                                      @ApiParam(name = "size", value = "大小", required = false)
                                      @RequestParam(value = "size", required = false)Integer size){
        try {
            return success(questionService.selectQuestionsList(name,type,status,page,size));
        }catch (Exception e){
            return failedException(e);
        }
    }
    @ApiOperation("根据id查询某一个问题集合详情")
    @GetMapping(value= BaseHospitalRequestMapping.BaseKnowledgeQuestion.selectQuestionsById)
    public Envelop selectQuestionsById(@ApiParam(name = "id", value = "问题集合id", required = true)
                              @RequestParam(value = "id", required = true)String id){
        try {
            return success(questionService.selectQuestionsById(id));
        }catch (Exception e){
            return failedException(e);
        }
    }
    @ApiOperation("问题集合设置排序")
    @GetMapping(value= BaseHospitalRequestMapping.BaseKnowledgeQuestion.setQuestionsSortById)
    public Envelop setQuestionsSortById(@ApiParam(name = "id", value = "字典id", required = true)
                                       @RequestParam(value = "id", required = true)String id,
                                       @ApiParam(name = "flag", value = "1上移2下移", required = true)
                                       @RequestParam(value = "flag", required = true)Integer flag){
        try {
            return success(questionService.setQuestionsSortById(id,flag));
        }catch (Exception e){
            return failedException(e);
        }
    }
    //--------------问题关联配置--------------------------
    @ApiOperation("问题流程关联配置")
    @PostMapping(value= BaseHospitalRequestMapping.BaseKnowledgeQuestion.setQuestionConfigurationRelation)
    public Envelop setQuestionConfigurationRelation(@ApiParam(name = "json", value = "问题关联配置JSON", required = true)
                                        @RequestParam(value = "json", required = true)String json){
        try {
            JSONArray array = JSONArray.parseArray(json);
            List<BaseKnowledgeFlowConfigurationRelation> flowConfigurationRelations = new ArrayList<>();
            for (int i=0;i<array.size();i++){
                BaseKnowledgeFlowConfigurationRelation flowConfigurationRelation = toEntity(json,BaseKnowledgeFlowConfigurationRelation.class);
                flowConfigurationRelations.add(flowConfigurationRelation);
            }
            return success(questionService.setQuestionConfigurationRelation(flowConfigurationRelations));
        }catch (Exception e){
            return failedException(e);
        }
    }
    @ApiOperation("根据问题id获取问题关联配置")
    @GetMapping(value= BaseHospitalRequestMapping.BaseKnowledgeQuestion.selectFlowConfigurationRelations)
    public Envelop selectFlowConfigurationRelations(@ApiParam(name = "questionId", value = "问题id", required = true)
                                                    @RequestParam(value = "questionId", required = true)String questionId){
        try {
            return success(questionService.selectFlowConfigurationRelations(questionId));
        }catch (Exception e){
            return failedException(e);
        }
    }
}