diagbotcloud/icss-service/src/main/java/com/diagbot/facade/TemplateNormFacade.java

package com.diagbot.facade;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.diagbot.client.TranServiceClient;
import com.diagbot.dto.HospitalDeptInfoAllDTO;
import com.diagbot.dto.RespDTO;
import com.diagbot.dto.TemplateFolderDTO;
import com.diagbot.dto.TemplateInfoDTO;
import com.diagbot.dto.TemplateInfoNormDTO;
import com.diagbot.entity.FolderMapping;
import com.diagbot.entity.TemplateFolder;
import com.diagbot.entity.TemplateInfo;
import com.diagbot.enums.IsDeleteEnum;
import com.diagbot.enums.TemplateTypeEnum;
import com.diagbot.exception.CommonErrorCode;
import com.diagbot.exception.CommonException;
import com.diagbot.service.impl.FolderMappingServiceImpl;
import com.diagbot.service.impl.TemplateFolderServiceImpl;
import com.diagbot.service.impl.TemplateInfoServiceImpl;
import com.diagbot.util.BeanUtil;
import com.diagbot.util.DateUtil;
import com.diagbot.util.EntityUtil;
import com.diagbot.util.GsonUtil;
import com.diagbot.util.ListUtil;
import com.diagbot.util.RespDTOUtil;
import com.diagbot.vo.HospitalCodeSetVO;
import com.diagbot.vo.HospitalCodeVo;
import com.diagbot.vo.TemplateIdVO;
import com.diagbot.vo.TemplateNormUpVO;
import com.diagbot.vo.TemplateNormsFindVO;
import com.diagbot.vo.TemplateNormsIdsVO;
import com.diagbot.vo.TemplateNormsParamVO;
import com.diagbot.vo.TemplateNormsVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @author wangfeng
 * @Description:
 * @date 2020-01-10 14:25
 */
@Component
public class TemplateNormFacade<tranServiceClient> extends TemplateInfoServiceImpl {

    @Autowired
    TemplateFolderServiceImpl templateFolderServiceImpl;
    @Autowired
    TemplateInfoServiceImpl templateInfoServiceImpl;
    @Autowired
    AdminCheckFacade adminCheckFacade;
    @Autowired
    FolderMappingFacade folderMappingFacade;
    @Autowired
    FolderMappingServiceImpl folderMappingServiceImpl;
    @Autowired
    TranServiceClient tranServiceClient;
    /**
     * 根据模板id修改模板名称和文件夹名称
     *
     * @param templateNormUpVO
     * @return
     */
    public boolean updateTemplateNorm(TemplateNormUpVO templateNormUpVO) {
        //检验权限
        HospitalCodeSetVO hospitalCodeSetVO = new HospitalCodeSetVO();
        hospitalCodeSetVO.setDoctorId(templateNormUpVO.getDoctorId());
        hospitalCodeSetVO.setHospitalId(-9L);
        boolean res = adminCheckFacade.getadminCheck(hospitalCodeSetVO);
        if (!res) {
            throw new CommonException(CommonErrorCode.NOT_EXISTS, "暂无修改权限");
        }
        //1.先判断数据是否存在有效
        QueryWrapper<TemplateInfo> templateInfoFand = new QueryWrapper<>();
        templateInfoFand
                .eq("is_deleted", IsDeleteEnum.N.getKey())
                .eq("id", templateNormUpVO.getId());
        int sum = count(templateInfoFand);
        if (sum == 0) {
            throw new CommonException(CommonErrorCode.NOT_EXISTS, "该模板不存在");
        }
        //2.先判断数据是否有权限修改
        QueryWrapper<TemplateInfo> templateInfoAmind = new QueryWrapper<>();
        templateInfoAmind
                .eq("is_deleted", IsDeleteEnum.N.getKey())
                .eq("id", templateNormUpVO.getId())
                .eq("template_type", TemplateTypeEnum.AdminTemplate.getKey());
        int sumA = count(templateInfoAmind);
        if (sumA == 0) {
            throw new CommonException(CommonErrorCode.NOT_EXISTS, "个人模板无权修改");
        }
        //2.再判断该科室下模板名是否重复重在
        QueryWrapper<TemplateInfo> templates = new QueryWrapper<>();
        Map<String, Object> mapAll = new HashMap<>();
        mapAll.put("hospital_dept_id", templateNormUpVO.getHospitalDeptId());
        //mapAll.put("doctor_id", templateInfoRevampVO.getDoctorId());
        mapAll.put("hospital_id", -9);
        mapAll.put("is_deleted", IsDeleteEnum.N.getKey());
        mapAll.put("template_type", TemplateTypeEnum.AdminTemplate.getKey());
        mapAll.put("name", templateNormUpVO.getModeName());
        //mapAll.put("type", templateInfoRevampVO.getType());
        templates.allEq(mapAll);
        TemplateInfo datas = getOne(templates, false);
        if (datas != null) {
            if(!datas.getId().equals(templateNormUpVO.getId())){
                throw new CommonException(CommonErrorCode.NOT_EXISTS, "该模板名已存在");
            }
        }
        //3.修改表数据的模板名字
        TemplateInfo templateInfo = new TemplateInfo();
        templateInfo.setId(templateNormUpVO.getId());//模板id
        templateInfo.setName(templateNormUpVO.getModeName());//模板名称
        templateInfo.setGmtModified(DateUtil.now());//修改时间
        templateInfo.setSpell(templateNormUpVO.getSpell());
        templateInfo.setSex(templateNormUpVO.getSex());
        res = updateById(templateInfo);
        if (!res) {
            throw new CommonException(CommonErrorCode.UPDATE_INFO_FAIL);
        }
        //更新关系
        if (res) {
            Long orderNo = folderMappingServiceImpl.getMaxOrderNo(templateNormUpVO.getFolderId());
//            Long num = orderNo == null ? 0 : orderNo;
            res = folderMappingFacade.update(new UpdateWrapper<FolderMapping>()
                    .eq("template_id", templateNormUpVO.getId())
                    .eq("is_deleted", IsDeleteEnum.N.getKey())
                    .set("folder_id", templateNormUpVO.getFolderId())
                    .set("order_no", orderNo));
        }
        return res;

    }

    /**
     * 保存病历模板
     *
     * @param templateNormsVO
     * @return
     */
    public boolean saveTemplateNorm(TemplateNormsVO templateNormsVO) {
        //检验权限
        HospitalCodeSetVO hospitalCodeSetVO = new HospitalCodeSetVO();
        hospitalCodeSetVO.setDoctorId(templateNormsVO.getDoctorId());
        hospitalCodeSetVO.setHospitalId(-9L);
        boolean res = adminCheckFacade.getadminCheck(hospitalCodeSetVO);
        if (!res) {
            throw new CommonException(CommonErrorCode.NOT_EXISTS, "暂无修改权限");
        }
        //1.判断同科室下是否存在模板名相同的数据
        TemplateInfo templateInfo = new TemplateInfo();
        QueryWrapper<TemplateInfo> templateInfoFand = new QueryWrapper<>();
        Map<String, Object> mapAll = new HashMap<>();
        mapAll.put("hospital_dept_id", templateNormsVO.getHospitalDeptId());
        //mapAll.put("doctor_id", templateInfosVO.getDoctorId());
        mapAll.put("hospital_id", -9);
        mapAll.put("is_deleted", IsDeleteEnum.N.getKey());
        mapAll.put("template_type", TemplateTypeEnum.AdminTemplate.getKey());
        mapAll.put("name", templateNormsVO.getModeName());
        //mapAll.put("type", templateInfosVO.getModeType());

        templateInfoFand.allEq(mapAll);
        int sum = count(templateInfoFand);
        if (sum != 0) {
            throw new CommonException(CommonErrorCode.NOT_EXISTS, "该模板名存在");
        }
        //2.获取传入的数据，保存到数据表中。
        templateInfo.setCreator(templateNormsVO.getDoctorId().toString());//创建人id
        templateInfo.setDoctorId(templateNormsVO.getDoctorId());//医生id
        templateInfo.setGmtCreate(DateUtil.now());//创建时间
        templateInfo.setHospitalDeptId(templateNormsVO.getHospitalDeptId());//部门id
        templateInfo.setHospitalId(-9L);//医院id
        templateInfo.setSex(templateNormsVO.getSex());
        templateInfo.setPreview(GsonUtil.toJson(templateNormsVO.getPreview()));//文本的展示
        templateInfo.setDataJson(templateNormsVO.getDataJson());//页面json
        templateInfo.setName(templateNormsVO.getModeName());//模板名称
        templateInfo.setSpell(templateNormsVO.getModeSpell().toUpperCase());
        templateInfo.setType(templateNormsVO.getModeType());//类型
        templateInfo.setTemplateType(TemplateTypeEnum.AdminTemplate.getKey());//模板类型
        res = save(templateInfo);
        if (!res) {
            throw new CommonException(CommonErrorCode.INSERT_DATA_FAILED);
        }
        //将id转为负数
        Long num = (templateInfo.getId() > 0) ? -templateInfo.getId() : templateInfo.getId();
        res = update(new UpdateWrapper<TemplateInfo>()
                .in("id", templateInfo.getId())
                .eq("is_deleted", IsDeleteEnum.N.getKey())
                .set("id", num));
        if (res) {
            FolderMapping folderMapping = new FolderMapping();
            folderMapping.setFolderId(templateNormsVO.getFolderId());
            folderMapping.setTemplateId(num);
            folderMapping.setCreator(templateNormsVO.getDoctorId().toString());
            folderMapping.setGmtCreate(DateUtil.now());
            Long orderNo = folderMappingServiceImpl.getMaxOrderNo(templateNormsVO.getFolderId());
            folderMapping.setOrderNo(orderNo);
            res = folderMappingFacade.save(folderMapping);
        }

        return res;
    }

    /**
     * 根据模板id批量删除病历模板
     *
     * @param templateNormsIdsVO
     * @return
     */
    public boolean cancelTemplateInfo(TemplateNormsIdsVO templateNormsIdsVO) {
        //检验权限
        HospitalCodeSetVO hospitalCodeSetVO = new HospitalCodeSetVO();
        hospitalCodeSetVO.setDoctorId(templateNormsIdsVO.getDoctorId());
        hospitalCodeSetVO.setHospitalId(templateNormsIdsVO.getHospitalId());
        boolean res = adminCheckFacade.getadminCheck(hospitalCodeSetVO);
        if (!res) {
            throw new CommonException(CommonErrorCode.NOT_EXISTS, "暂无删除权限");
        }
        //1.获取传入的ids数据
        String ids = templateNormsIdsVO.getIds();
        //2.截取到最后一个
        String substring = ids.substring(0, ids.length());
        //System.out.println(substring);
        //3.以逗号分割
        String[] splitIds = substring.split(",");
        //验证转化好的参数
        if (ListUtil.isEmpty(ListUtil.arrayToList(splitIds))) {
            throw new CommonException(CommonErrorCode.PARAM_IS_ERROR, "请输入模板id");
        }
        //把分割的id数据传入对象中，在表中批量删除
        UpdateWrapper<TemplateInfo> templateInfoNew = new UpdateWrapper<>();
        templateInfoNew
                .in("id", ListUtil.arrayToList(splitIds))
                .eq("is_deleted", IsDeleteEnum.N.getKey())
                .eq("template_type", TemplateTypeEnum.AdminTemplate.getKey())
                .set("is_deleted", IsDeleteEnum.Y.getKey())
                //.set("modifier",UserUtils.getCurrentPrincipleID())
                .set("gmt_modified", DateUtil.now());
        res = update(new TemplateInfo(), templateInfoNew);
        //删除模板和文件的绑定关系
        if (res) {
            res = folderMappingFacade.update(new UpdateWrapper<FolderMapping>()
                    .in("template_id", ListUtil.arrayToList(splitIds))
                    .eq("is_deleted", IsDeleteEnum.N.getKey())
                    .set("is_deleted", IsDeleteEnum.Y.getKey()));
        }
        return res;
    }

    /**
     * 查询标准模板列表
     *
     * @return
     */
    public List<TemplateFolderDTO> getTemplateNorm() {
        //先获取文件夹
        QueryWrapper<TemplateFolder> templateFolderQuery = new QueryWrapper<TemplateFolder>();
        templateFolderQuery
                .eq("hospital_id", -9)
                .eq("is_deleted", IsDeleteEnum.N.getKey())
                .eq("template_type", TemplateTypeEnum.AdminTemplate.getKey())
                //.eq("doctor_id", templateNormsParamVO.getDoctorId())
                .orderByAsc("order_no");
        List<TemplateFolder> datas = templateFolderServiceImpl.list(templateFolderQuery);
        List<TemplateFolderDTO> data = new ArrayList<TemplateFolderDTO>();
        //过滤
        data = BeanUtil.listCopyTo(datas, TemplateFolderDTO.class);
        //再获取模板
        TemplateNormsParamVO templateNormsParamVO = new TemplateNormsParamVO();
        templateNormsParamVO.setHospitalId(-9L);
        List<TemplateInfoNormDTO> templateDatas = templateInfoServiceImpl.getStandardTemplates(templateNormsParamVO);
        HospitalCodeVo hospitalCodeVo = new HospitalCodeVo();
        hospitalCodeVo.setHospitalCode("LT");
        RespDTO<List<HospitalDeptInfoAllDTO>> deptInfoDTO = tranServiceClient.getHospitalDeptInfoAll(hospitalCodeVo);
        RespDTOUtil.respNGDeal(deptInfoDTO, deptInfoDTO.msg);
        List<HospitalDeptInfoAllDTO> deptInfo = deptInfoDTO.data;
        Map<Long, HospitalDeptInfoAllDTO> deptMap = deptInfo.stream().collect(Collectors.toMap(HospitalDeptInfoAllDTO::getId, i -> i));
        if (templateDatas.size() > 0) {
            templateDatas.forEach(i -> {
                HospitalDeptInfoAllDTO dataDept = deptMap.get(i.getHospitalDeptId());
                if (dataDept != null) {
                    i.setHospitalDeptName(dataDept.getConceptDeptName());
                }

            });
        }
        Map<Long, List<TemplateInfoNormDTO>> map
                = EntityUtil.makeEntityListMap(templateDatas, "folderId");
        //把模板放进文件夹中
        if (data.size() > 0) {
            for (TemplateFolderDTO ts : data) {
                List<TemplateInfoNormDTO> tmp = map.get(ts.getId());
                if (ListUtil.isNotEmpty(tmp)) {
                    ts.setTemplateInfo(tmp);
                    ts.setTemplateInfoCount(tmp.size());
                } else {
                    ts.setTemplateInfoCount(0);
                }
            }
        }

        return data;
    }

    /**
     * 根据模板id获取病历模板内容
     *
     * @param templateIdVO
     * @return
     */
    public TemplateInfoDTO getTemplateIdData(TemplateIdVO templateIdVO) {
        //根据传入的医生id和部门id还有医院id在数据表中查出相应的模板数据
        QueryWrapper<TemplateInfo> templateInfoQuery = new QueryWrapper<>();
        templateInfoQuery
                .eq("id", templateIdVO.getId())
                .eq("is_deleted", IsDeleteEnum.N.getKey())
                .eq("template_type", TemplateTypeEnum.AdminTemplate.getKey());
        TemplateInfoDTO data = new TemplateInfoDTO();
        TemplateInfo datas = getOne(templateInfoQuery, false);
        if (datas == null) {
            throw new CommonException(CommonErrorCode.NOT_EXISTS, "该模板不存在！");
        }
        //过滤
        BeanUtil.copyProperties(datas, data);
        return data;
    }

    /**
     * 模糊查询模板
     *
     * @param templateNormsFindVO
     * @return
     */
    public List<TemplateInfoNormDTO> findTemplateNorm(TemplateNormsFindVO templateNormsFindVO) {
        List<TemplateInfoNormDTO> data = templateInfoServiceImpl.findStandardTemplates(templateNormsFindVO);
        return data;
    }
}