package com.lyms.talkonlineweb.controller;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.lyms.talkonlineweb.domain.*;
import com.lyms.talkonlineweb.request.PatientInfoRequest;
import com.lyms.talkonlineweb.result.BaseResponse;
import com.lyms.talkonlineweb.result.PatientPcaseResult;
import com.lyms.talkonlineweb.service.*;
import com.lyms.talkonlineweb.util.*;
import lombok.extern.log4j.Log4j2;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import org.springframework.validation.BindingResult;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

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

/**
 * 患者管理
 */
@RestController
@RequestMapping("pat")
@Log4j2
public class PatientController {

    @Autowired
    private LymsPatientService lymsPatientService;//患者

    @Autowired
    private LymsPcaseService lymsPcaseService;//病例

    @Autowired
    private LymsIllnessService lymsIllnessService;//疾病

    @Autowired
    private LymsTkcardService lymsTkcardService;//问诊记录

    @Autowired
    private PatientInfoService patientInfoService;//患者视图

    @Autowired
    private LymsTcardService lymsTcardService;//问诊卡信息

    @Autowired
    private LymsLogsService lymsLogsService;//日志记录

    @Autowired
    private LymsHdepartService lymsHdepartService;//科室服务

    @Autowired
    private HXService hxService;

    //医院
    @Autowired
    private LymsHospitalService lymsHospitalService;
    //医生
    @Autowired
    private LymsDoctorService lymsDoctorService;
    //关注
    @Autowired
    private LymsAttentionService lymsAttentionService;
    @Autowired
    private LymsDictService lymsDictService;

    /**
     * 获取患者列表
     *
     * @param patientInfo
     * @param current
     * @param size
     * @return
     */
    @GetMapping("sltPatientLst")
    public BaseResponse sltPatientLst(PatientInfo patientInfo, int current, int size, @RequestParam(required = false) Integer qtype) {
        BaseResponse baseResponse = new BaseResponse();
        Page<PatientInfo> page = new Page<>(current, size);
        QueryWrapper<PatientInfo> queryWrapper = Wrappers.query(patientInfo);
        if (Objects.nonNull(qtype) && qtype == 1) {//从小程序购买
            queryWrapper.inSql("id", "SELECT t.`pid` FROM lyms_tcard t WHERE t.`fid`=1");
        }
        if (Objects.nonNull(qtype) && qtype == 2) {//从医院购买
            queryWrapper.inSql("id", "SELECT t.`pid` FROM lyms_tcard t WHERE t.`fid`=2");
        }
        if(StringUtils.isEmpty(patientInfo.getPname())){
            patientInfo.setPname(null);
        }
        Page<PatientInfo> patientPagePage = patientInfoService.page(page, queryWrapper);
        List<PatientInfo> pLst = patientInfoService.list(queryWrapper);
        int daiCnt = pLst.parallelStream().mapToInt(PatientInfo::getCcnt).sum();//待使用数量

        List<Integer> pids = pLst.parallelStream().map(PatientInfo::getId).collect(Collectors.toList());

        LymsTcard tcard = new LymsTcard();
        QueryWrapper<LymsTcard> tWrapper = Wrappers.query(tcard);
        if (pids.size() == 0) {
            pids.add(-1);
        }
        tWrapper.in("pid", pids);
        int sum = lymsTcardService.list(tWrapper).parallelStream().mapToInt(LymsTcard::getCnt).sum();

        log.error("统计需要改动数据结构:daiCnt:{} sum:{}", daiCnt, sum);
        baseResponse.setObject(patientPagePage);

        return baseResponse;
    }

    /**
     * 保存或更新患者信息
     *
     * @param patient
     * @return
     */
    @PostMapping("savePatient")
    public BaseResponse savePatient(@Validated LymsPatient patient, BindingResult result, LymsPcase pcase, String illness) {
        BaseResponse baseResponse = new BaseResponse();
        log.info(">>>>>>>>>>>>>>>登记病例");
        baseResponse.setErrormsg("");
        LymsPatient tmpP=new LymsPatient();
        tmpP.setIdno(patient.getIdno());
        LymsPatient patient2 = lymsPatientService.getOne(Wrappers.query(tmpP).eq("idno", patient.getIdno()));
        if (patient2 == null) {
            patient.setCreatedtime(new Date());
            patient.setPpasswd(Constant.COMMON_PASSWD);
        } else {
            patient.setId(patient2.getId());
            patient.setUpdatedtime(new Date());
            patient.setCcnt(patient2.getCcnt()+patient.getCcnt());
        }

        if (result.hasErrors()) {
            baseResponse.setErrorcode(1);
            result.getAllErrors().forEach(e -> {
                baseResponse.setErrormsg(baseResponse.getErrormsg() + e.getDefaultMessage());
            });
            baseResponse.setErrorcode(1);
            return baseResponse;
        }

        boolean f = lymsPatientService.saveOrUpdate(patient);

//        添加病例
        pcase.setCreatedby(patient.getCreatedby());
        pcase.setPid(patient.getId());
        pcase.setCreatedtime(new Date());
        f = lymsPcaseService.saveOrUpdate(pcase);
        String[] iArr = illness.split(",");

        log.info(patient);
        log.info(pcase);

        Map param = new HashMap();
        param.put("vtype",3);
        List<LymsDict> dLst=lymsDictService.listByMap(param);
        for (int i = 0; i < iArr.length; i++) {
            LymsIllness ness = new LymsIllness();
            ness.setCreatedby(patient.getCreatedby());
            ness.setPcid(pcase.getPcid());
            ness.setIid(Integer.parseInt(iArr[i]));
            ness.setCreatedtime(new Date());

            dLst.forEach(e->{
                if(e.getCode().intValue()==ness.getIid().intValue()){
                    ness.setIname(e.getValue());
                }
            });

            param.clear();
            param.put("pcid", pcase.getPcid());
            param.put("iid", iArr[i]);
            List<LymsIllness> iLst = lymsIllnessService.listByMap(param);
            if (iLst.size() > 0) {
                ness.setId(iLst.get(0).getId());
            }
            f = lymsIllnessService.saveOrUpdate(ness);
            log.info(ness.toString());
        }

        Date instDate = new Date();
        //需要添加医院购买卡记录
        for (int i = 0; i < patient.getCcnt(); i++) {
            LymsTcard tcard = new LymsTcard();
            tcard.setCnt(1);
            tcard.setPcid(pcase.getPcid());
            tcard.setPid(patient.getId());
            tcard.setFid(2);
            tcard.setCreatedby(patient.getCreatedby());
            tcard.setCreatedtime(instDate);

            lymsTcardService.saveOrUpdate(tcard);
        }

        baseResponse.setErrorcode(f == true ? 0 : 1);
        return baseResponse;
    }

    /**
     * 更新患者信息---小程序端使用
     *
     * @param patient
     * @return
     */
    @PostMapping("updatePatient")
    public BaseResponse updatePatient(@RequestBody LymsPatient patient){
        BaseResponse baseResponse=new BaseResponse();
        boolean f=false;
        if(Objects.nonNull(patient.getId()) ){
            patient.setUpdatedtime(new Date());
            f=lymsPatientService.saveOrUpdate(patient);
        }
        baseResponse.setErrorcode(f==true?0:1);
        return baseResponse;
    }

    /**
     * 删除患者
     *
     * @param id
     * @return
     */
    @GetMapping("delPatient")
    public BaseResponse delPatient(int id) {
        BaseResponse baseResponse = new BaseResponse();
        boolean f = lymsPatientService.removeById(id);
        baseResponse.setErrorcode(f == true ? 0 : 1);
        return baseResponse;
    }

    /**
     * 删除患者病例ID
     *
     * @param pcid
     * @return
     */
    @GetMapping("delPcase")
    public BaseResponse delPcase(int pcid) {
        BaseResponse baseResponse = new BaseResponse();
        boolean f = lymsPcaseService.removeById(pcid);
        baseResponse.setErrorcode(f == true ? 0 : 1);
        return baseResponse;
    }

    /**
     * 患者登录
     *
     * @param patient
     * @return
     */
    @PostMapping("loginPatient")
    public BaseResponse loginPatient(@RequestBody LymsPatient patient) {
        BaseResponse baseResponse = new BaseResponse();
        List<LymsPatient> dLst = lymsPatientService.list(Wrappers.query(patient));
        baseResponse.setErrorcode(1);
        LymsPatient patient2=null;
        if (dLst.size() > 0) {
            patient2 = dLst.get(0);

            String jwt = JwtUtils.createJWT("1", patient.getIdno(), Constant.JWT_TTL);
            Map<String, Object> map = new HashMap<>();

            patient2.setIslogin(1);

            if (StringUtils.isEmpty(patient2.getHxid()) || StringUtils.isEmpty(patient2.getOpenid())) {

                if (patient2.getHxid() == null) {
                    JSONObject json = hxService.addUser(patient2.getIdno(), Constant.COMMON_PASSWD, patient2.getPname());
                    JSONArray rArr = json.getJSONArray("entities");
                    if (rArr.size() > 0) {
                        patient2.setHxid(rArr.getJSONObject(0).getString("uuid"));
                    }
                }
                if (StringUtils.isEmpty(patient2.getOpenid())) {
                    patient2.setOpenid(WeiXinUtil.getWxOpenId(patient.getCode()));
                }
                lymsPatientService.saveOrUpdate(patient2);
            }

            patient.setPpasswd(null);
            map.put("patient", patient2);
            map.put("token", jwt);
            baseResponse.setErrorcode(0);
            baseResponse.setObject(map);
        }
        return baseResponse;
    }

    /**
     * 查询单个患者信息
     *
     * @param patientInfo
     * @return
     */
    @GetMapping("queryPatient")
    public BaseResponse queryPatient(PatientInfo patientInfo) {
        BaseResponse baseResponse = new BaseResponse();
        PatientInfo patientInfo2 = patientInfoService.getOne(Wrappers.query(patientInfo));
        baseResponse.setObject(patientInfo2);
        return baseResponse;
    }


    /**
     * 传入患者id，获取病历对应的医院列表
     *
     * @param lymsPcase
     * @return
     */
    @GetMapping("getPatientHospitals")
    public BaseResponse getPatientHospitals(LymsPcase lymsPcase) {
        BaseResponse baseResponse = new BaseResponse();
        List<LymsPcase> pcases = lymsPcaseService.list(Wrappers.query(lymsPcase));
        baseResponse.setObject(pcases);
        return baseResponse;
    }


    /**
     * 查询患者在某个医院的详细诊断病历
     * 需要传入患者id和医院id
     *
     * @param pid 患者id
     * @param hid 医院id
     * @return
     */
    @GetMapping("getPatientHospitalPcase")
    public BaseResponse getPatientHospitalPcase(int pid, int hid,
                                                @RequestParam(required = false) String keyword) {
        BaseResponse baseResponse = new BaseResponse();
        Map data = new HashMap(5);
        LymsPatient patient = lymsPatientService.getById(pid);
        //患者基本信息
        data.put("patient", patient);

        //医院信息
        LymsHospital hospital = lymsHospitalService.getById(pid);
        data.put("hospital", hospital);

        List<Integer> ilist = new ArrayList<>();
        if (StringUtil.isNotEmpty(keyword)) {
            LambdaQueryWrapper<LymsIllness> iwrapper = new QueryWrapper().lambda();
            iwrapper.like(LymsIllness::getIname, keyword);
            List<LymsIllness> illnesses = lymsIllnessService.list(iwrapper);
            if (CollectionUtils.isNotEmpty(illnesses)) {
                illnesses.stream().forEach(i -> {
                    ilist.add(i.getPcid());
                });
            }
        }
        //查询患者的就诊记录
        LambdaQueryWrapper<LymsPcase> wrapper = new QueryWrapper().lambda();
        wrapper.eq(LymsPcase::getPid, pid);
        wrapper.eq(LymsPcase::getHid, hid);
        if (StringUtil.isNotEmpty(keyword)) {
            wrapper.and(i -> i.like(LymsPcase::getDname, keyword).or().like(LymsPcase::getDtname, keyword));
            if (CollectionUtils.isNotEmpty(ilist)) {
                wrapper.or(i -> i.in(LymsPcase::getPcid, ilist));
            }
        }
        wrapper.orderByDesc(LymsPcase::getCreatedtime);
        List<LymsPcase> lymsPcaseList = lymsPcaseService.list(wrapper);

        List<PatientPcaseResult> pcases = new ArrayList<>();
        if (CollectionUtils.isNotEmpty(lymsPcaseList)) {
            lymsPcaseList.forEach(destModel -> {
                PatientPcaseResult result = new PatientPcaseResult();
                result.setPid(destModel.getPid());
                result.setDepartName(destModel.getDname());
                result.setCardNo(patient.getIdno());
                result.setPatientName(patient.getPname());
                result.setCcnt(patient.getCcnt());
                result.setPhxid(patient.getHxid());
                LymsDoctor doctor = lymsDoctorService.getById(destModel.getDtid());
                //获得医生职位
                result.setDoctorName(doctor.getDname());
                LambdaQueryWrapper<LymsDict> wrapperLymsDict = new QueryWrapper().lambda();
                wrapperLymsDict.eq(LymsDict::getVtype, 4);
                wrapperLymsDict.eq(LymsDict::getCode, doctor.getLvl());
                LymsDict dict=lymsDictService.getOne(wrapperLymsDict);
                result.setDoctorLvl(dict.getValue());
                //获得疾病名称
                LambdaQueryWrapper<LymsIllness> wrapperLymsIllness = new QueryWrapper().lambda();
                wrapperLymsIllness.eq(LymsIllness::getPcid,destModel.getPcid());
                List<LymsIllness> lymsIllnessList=lymsIllnessService.list(wrapperLymsIllness);
                String inames="";
                for (LymsIllness lymsIllness : lymsIllnessList) {
                    LambdaQueryWrapper<LymsDict> wrapperLymsDict2 = new QueryWrapper().lambda();
                    wrapperLymsDict2.eq(LymsDict::getVtype, 3);
                    wrapperLymsDict2.eq(LymsDict::getCode,lymsIllness.getIid());
                    LymsDict dict2=lymsDictService.getOne(wrapperLymsDict2);
                    inames+=dict2.getValue()+",";
                }
                result.setIname(StringUtil.isNotEmpty(inames)?inames.substring(0, inames.length()-1):"");
                //获得医生环信账号
                result.setDlogin(doctor.getDlogin());
                result.setDhxid(doctor.getHxid());
                result.setDtid(destModel.getDtid());
                result.setCreatedby(DateUtil.getYyyyMmDdHhMmSs(destModel.getCreatedtime()));
                //病例id
                result.setPcid(destModel.getPcid());
                pcases.add(result);
            });
        }
        data.put("pcases", pcases);

        baseResponse.setObject(data);
        return baseResponse;
    }


    /**
     * 通过患者id查询患者的基本信息
     *
     * @param lymsPatient
     * @return
     */
    @GetMapping("getPatientBaseInfo")
    public BaseResponse getPatientBaseInfo(LymsPatient lymsPatient) {

        BaseResponse baseResponse = new BaseResponse();

        Map data = new HashMap(6);
        LymsPatient patients = lymsPatientService.getById(lymsPatient.getId());

        //查询患者的就诊记录
        LambdaQueryWrapper<LymsPcase> wrapper = new QueryWrapper().lambda();
        wrapper.eq(LymsPcase::getPid, lymsPatient.getId());
        wrapper.orderByDesc(LymsPcase::getCreatedtime);
        List<LymsPcase> lymsPcaseList = lymsPcaseService.list(wrapper);

        data.put("pid", patients.getId());
        data.put("pname", patients.getPname());
        data.put("psex", patients.getSex());
        data.put("birth", patients.getBirth());
        if (CollectionUtils.isNotEmpty(lymsPcaseList)) {
            data.put("mobile", lymsPcaseList.get(0).getMobile());
        }
        baseResponse.setObject(data);
        return baseResponse;
    }


    /**
     * 更新患者信息
     *
     * @param request
     * @return
     */
    @PutMapping("updatePatientInfo")
    public BaseResponse updatePatientInfo(@RequestBody PatientInfoRequest request) {
        BaseResponse baseResponse = new BaseResponse();
        LymsPatient patients = lymsPatientService.getById(request.getPid());
        patients.setBirth(request.getBirth());
        patients.setPname(request.getPname());
        patients.setSex(request.getPsex());
        lymsPatientService.updateById(patients);

        //查询患者的就诊记录
        LambdaQueryWrapper<LymsPcase> wrapper = new QueryWrapper().lambda();
        wrapper.eq(LymsPcase::getPid, request.getPid());
        wrapper.orderByDesc(LymsPcase::getCreatedtime);
        List<LymsPcase> lymsPcaseList = lymsPcaseService.list(wrapper);
        if (CollectionUtils.isNotEmpty(lymsPcaseList)) {
            lymsPcaseList.forEach(lymsPcase -> {
                lymsPcase.setMobile(request.getMobile());
                lymsPcaseService.updateById(lymsPcase);
            });
        }
        return baseResponse;
    }


    /**
     * 患者的问诊记录接口
     *
     * @param lymsTkrecord 传入患者id参数
     * @return
     */
    @GetMapping("getPatienttkrecord")
    public BaseResponse getPatienttkrecord(LymsTkrecord lymsTkrecord) {

        BaseResponse baseResponse = new BaseResponse();
        LymsPatient patients = lymsPatientService.getById(lymsTkrecord.getPid());

        //查询患者的就诊记录
        LambdaQueryWrapper<LymsTkrecord> wrapper = new QueryWrapper().lambda();
        wrapper.eq(LymsTkrecord::getPid, lymsTkrecord.getPid());
        wrapper.orderByDesc(LymsTkrecord::getCreatedtime);
        List<LymsTkrecord> lymsTkrecords = lymsTkcardService.list(wrapper);
        Map param=new HashMap();
        param.put("vtype",4);
        List<LymsDict> dLst=lymsDictService.listByMap(param);

        List<Map> list = new ArrayList<>();
        if (CollectionUtils.isNotEmpty(lymsTkrecords)) {
            for (LymsTkrecord record : lymsTkrecords) {
                LymsPcase pcase = lymsPcaseService.getById(record.getPcid());
                LymsHospital hospital = lymsHospitalService.getById(pcase.getHid());
                LymsDoctor doctor = lymsDoctorService.getById(pcase.getDtid());

                Map data = new HashMap(20);
                data.put("hospitalName", pcase.getHname());
                data.put("hospitalLevel", hospital.getHlevel());
                data.put("doctorName", pcase.getDtname());
                data.put("departName", pcase.getDname());

                data.put("patientName", patients.getPname());

                dLst.forEach(dd->{
                    if(dd.getCode()==doctor.getLvl()){
                        data.put("doctorLevel", dd.getValue());
                    }
                });

                StringBuilder sb = new StringBuilder();
                LambdaQueryWrapper<LymsIllness> iwrapper = new QueryWrapper().lambda();
                iwrapper.like(LymsIllness::getPcid, pcase.getPcid());
                List<LymsIllness> illnesses = lymsIllnessService.list(iwrapper);
                if (CollectionUtils.isNotEmpty(illnesses)) {
                    illnesses.forEach(lymsIllness -> {
                        sb.append(lymsIllness.getIname());
                        sb.append("  ");
                    });
                }

                data.put("iname", sb.toString());
                data.put("createTime", DateUtil.getDateTime(record.getCreatedtime(), DateUtil.YYYY_MM_DD));
                data.put("stat", record.getStat());
                list.add(data);
            }
        }
        baseResponse.setObject(list);
        return baseResponse;
    }

    /**
     * 查询患者关注的医生记录
     *
     * @param lymsAttention 传入患者id参数
     * @return
     */
    @GetMapping("getPatientAttentions")
    public BaseResponse getPatientAttentions(LymsAttention lymsAttention) {

        BaseResponse baseResponse = new BaseResponse();
        //查询患者的关注医生记录
        LambdaQueryWrapper<LymsAttention> wrapper = new QueryWrapper().lambda();
        wrapper.eq(LymsAttention::getPid, lymsAttention.getPid());
        wrapper.orderByDesc(LymsAttention::getCreatedtime);
        List<LymsAttention> lymsAttentions = lymsAttentionService.list(wrapper);
        Map param=new HashMap();
        param.put("vtype",4);
        List<LymsDict> dLst=lymsDictService.listByMap(param);

        List<Map> list = new ArrayList<>();
        if (CollectionUtils.isNotEmpty(lymsAttentions)) {
            for (LymsAttention attention : lymsAttentions) {
                LymsDoctor doctor = lymsDoctorService.getById(attention.getDid());
                LymsHdepart depart = lymsHdepartService.getById(doctor.getDpid());
                LymsHospital hospital = lymsHospitalService.getById(doctor.getHid());
                Map data = new HashMap(20);
                data.put("doctorName", doctor.getDname());
                data.put("departName", depart.getDname());

                data.put("doctorImage", doctor.getHeadimg());
                data.put("hospitalName", depart.getHname());
                data.put("hospitalLevel", hospital.getHlevel());
                data.put("doctorDesc", doctor.getIntro());
                dLst.forEach(dd->{
                    if(dd.getCode()==doctor.getLvl()){
                        data.put("doctorLevel", dd.getValue());
                    }
                });
                list.add(data);
            }
        }
        baseResponse.setObject(list);
        return baseResponse;
    }
    /**
     * 小程序用户端-登录后显示用户病历所在医院
     *
     * @param patientId 传入患者id
     * @return 医院id和医院名称
     */
    @GetMapping("getAppPatientHospital")
    public BaseResponse getAppPatientHospital(Integer patientId) {
        BaseResponse baseResponse = new BaseResponse();
        List<Map<String,String>>patientListMap=lymsPatientService.getAppPatientHospital(patientId);
        baseResponse.setObject(patientListMap);
        return baseResponse;
    }

    /**
     * 更新患者待用卡数量---小程序端使用
     *
     * @param patient 患者ID
     * @return
     */
    @GetMapping("updateCcnt")
    public BaseResponse updateCcnt(LymsPatient patient){
        BaseResponse baseResponse=new BaseResponse();
        boolean f=false;
        LymsPatient patient2=lymsPatientService.getById(patient.getId());
        if(Objects.nonNull(patient2)){//验证问诊卡次数
            int cnt=patient2.getCcnt()-1;
            if (cnt < 0) {
                baseResponse.setErrorcode(1);
                baseResponse.setErrormsg("问诊卡次数错误");
                return baseResponse;
            }else{
                patient.setCcnt(cnt);
            }
        }
        if(Objects.nonNull(patient.getId()) ){
            patient.setUpdatedtime(new Date());
            f=lymsPatientService.saveOrUpdate(patient);
        }
        baseResponse.setErrorcode(f==true?0:1);
        return baseResponse;
    }

    /**
     * 患者统计待使用和总量问诊卡信息
     * @return
     */
    @GetMapping("cardStat")
    public BaseResponse cardStat(Integer type){
        BaseResponse baseResponse = new BaseResponse();
        String pSql="";
        String cSql="";
        if (type != null) {
            pSql="WHERE id IN (SELECT c.`pid` FROM lyms_tcard c WHERE c.`fid`="+type+")";
            cSql="WHERE fid="+type;
        }
        Map<String,Object> rs= lymsTcardService.cardStat(pSql,cSql);
        baseResponse.setObject(rs);
        return baseResponse;
    }
    /**
     * 小程序-用户关注医生保存关注记录
     * @return
     */
    @PostMapping("saveAttention")
    public BaseResponse saveAttention(@RequestBody LymsAttention lymsAttention){
        BaseResponse baseResponse=new BaseResponse();
        try {
            lymsAttentionService.save(lymsAttention);
            baseResponse.setErrormsg("成功");
        } catch (Exception e) {
            baseResponse.setErrormsg("失败");
            e.printStackTrace();
        }
        return baseResponse;
    }
    /**
     * 小程序-查询用户是否关注该医生
     * @return true 可以关注 false 已关注不能再关注
     */
    @GetMapping("getDoctorById")
    public BaseResponse getDoctorById(LymsAttention lymsAttention){
        BaseResponse baseResponse=new BaseResponse();
        try {
            LymsAttention attention=lymsAttentionService.getOne(Wrappers.query(lymsAttention));
            baseResponse.setObject(null==attention?true:false);
            baseResponse.setErrormsg("成功");
        } catch (Exception e) {
            baseResponse.setErrormsg("失败");
            e.printStackTrace();
        }
        return baseResponse;
    }

    /**
     * PC-二次添加患者，输入身份证号显示相关信息
     * @param idno 患者身份证号码
     * @return
     */
    @GetMapping("getPatientByIdno")
    public BaseResponse getPatientByIdno(String idno){
        BaseResponse baseResponse=new BaseResponse();
        try {
            List<PatientInfo> pLst=patientInfoService.list(new QueryWrapper<PatientInfo>().eq("idno", idno));
            baseResponse.setObject(pLst.size()<1?null:pLst.get(0));
            baseResponse.setErrormsg("成功");
        } catch (Exception e) {
            baseResponse.setErrormsg("失败");
            e.printStackTrace();
        }
        return baseResponse;
    }

    /**
     * 记录患者登录日志，包括切换医院
     * @param logEntity
     */
    @GetMapping("saveLoginLog")
    public void saveLoginLog(LymsLogs logEntity ){

        log.debug(">>>>>>>>>"+logEntity);
        logEntity.setLogDate(new Date());
        lymsLogsService.save(logEntity);
    }
}