居民端-添加图片上传

business/base-service/src/main/java/com/yihu/jw/patient/dao/BasePatientMedicareCardDao.java

@@ -17,4 +17,6 @@ public interface BasePatientMedicareCardDao extends PagingAndSortingRepository<P
    @Query("select id from PatientMedicareCardDO where patientCode = ?1")
    Set<Object> findIdListByPatientCode(String patientCode);
    PatientMedicareCardDO findByCode(String code);
}

business/base-service/src/main/java/com/yihu/jw/patient/service/BasePatientMedicardCardService.java

@@ -56,4 +56,17 @@ public class BasePatientMedicardCardService extends BaseJpaService<PatientMedica
        return basePatientMedicareCardDao.findIdListByPatientCode(patientCode);
    }
    /**
     * 根据居民标识获取关联卡id列表
     * @param patientCode
     * @return
     */
    public PatientMedicareCardDO findByCode(String patientCode) throws Exception{
        PatientMedicareCardDO patientMedicareCard = basePatientMedicareCardDao.findByCode(patientCode);
        if(patientMedicareCard==null){
            throw new Exception("no PatientMedicareCard entity");
        }
        return patientMedicareCard;
    }
}

business/base-service/src/main/java/com/yihu/jw/security/dao/TokenDao.java

@@ -0,0 +1,46 @@
package com.yihu.jw.security.dao;
import com.yihu.jw.entity.base.security.Token;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.PagingAndSortingRepository;
public interface TokenDao extends PagingAndSortingRepository<Token, String> {
	
	@Modifying
	@Query("delete Token a where a.user = ?1")
	int deleteByUser(String user);
	@Modifying
	@Query("delete Token a where a.user = ?1 and platform=?2")
	int deleteByUserAndPlatform(String user, Integer platform);
	
	@Modifying
	@Query("delete Token a where a.token = ?1")
	int deleteByToken(String token);
	
//	@Query("select a from Token a where a.user = ?1 and a.platform = ?2 and a.del = '1'")
//	Token findByUser(String user, int platform);
	
//	@Query("select a from Token a where a.user = ?1 and a.del = '1'")
//	Token findByUser(String user);
	
//	@Query("select count(1) from Token a where a.user = ?1 and a.del = '1'")
//	int countByUser(String user);
	
	@Query("select a from Token a where a.token = ?1 and a.del = '1'")
	Token findByToken(String token);
	
	@Query("select a from Token a where a.user = ?1 and a.platform = ?2 and a.del = '1'")
	Token findByPatient(String patient, int platform);
	
	@Modifying
	@Query("delete Token a where a.user = ?1 and a.platform = 3 and a.del = '1'")
	int deleteWxTokenByPatient(String patient);
	@Query("select a from Token a where a.imei = ?1 and a.platform = 3")
	Page<Token> findByOpenid(String openid, Pageable pageable);
}

business/base-service/src/main/java/com/yihu/jw/security/service/TokenService.java

@@ -0,0 +1,136 @@
package com.yihu.jw.security.service;
import com.yihu.jw.entity.base.security.Token;
import com.yihu.jw.security.dao.TokenDao;
import com.yihu.jw.util.date.DateUtil;
import com.yihu.jw.util.security.MD5;
import com.yihu.jw.utils.SystemData;
import com.yihu.mysql.query.BaseJpaService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import java.util.Date;
import java.util.UUID;
@Component
@Transactional(rollbackFor = Exception.class)
public class TokenService extends BaseJpaService<Token, TokenDao> {
	@Autowired
	public TokenDao tokenDao;
	/**
	 * 生成token
	 * @param user 用户标识
	 * @param imei 手机IMEI码
	 * @param platform 1患者，2医生，3患者微信公众号,4pc端医生
	 * @return
	 * @throws Exception
	 */
	public Token newToken(String user, String imei, int platform) throws Exception {
		Date czrq = new Date();
		String tokenStr = platform + imei + System.currentTimeMillis();
		// MD5加密
		tokenStr = MD5.GetMD5Code(tokenStr);
//		Token token = tokenDao.findByPatient(user, platform);
//		if (token == null) {
//			token = new Token();
//		}
		Token token = new Token();
		token.setDel("1");
		token.setPlatform(platform);
		token.setImei(imei);
		// 30天的有限期
		token.setTimeout(DateUtil.strToDate(DateUtil.getNextDay(DateUtil.getStringDate(DateUtil.YYYY_MM_DD), 30), DateUtil.YYYY_MM_DD));
		token.setToken(tokenStr);
		token.setUser(user);
		token.setCzrq(czrq);
		// 先删除防止重复
		tokenDao.deleteByUserAndPlatform(user,platform);
		// 添加新的token
		token = tokenDao.save(token);
		if (token == null) {
			throw new Exception("Token生成失败");
		}
		// 更新token缓存
		if (platform == 3) {
			SystemData.patientTokens.put(user, token);
		} else if (platform == 2) {
			SystemData.doctorTokens.put(user, token);
		}else if(platform == 4){
			SystemData.doctorPCTokens.put(user,token);
		}else if(platform == 5){
			SystemData.doctorWXTokens.put(user,token);
		}
		return token;
	}
	public Token newTxToken(String user, String openid) throws Exception {
		Date czrq = new Date();
		String tokenStr = "";
		if(!StringUtils.isBlank(openid)){
			tokenStr = 3 + openid + System.currentTimeMillis();
		}else{
			tokenStr = 3 +""+ System.currentTimeMillis();
		}
		// MD5加密
		tokenStr = MD5.GetMD5Code(tokenStr);
		Token token = new Token();
		token.setDel("1");
		token.setPlatform(3);
		if(StringUtils.isBlank(openid)){
			token.setImei(UUID.randomUUID().toString().replace("-",""));
		}else{
			token.setImei(openid);
		}
		// 360天的有限期
		token.setTimeout(DateUtil.strToDate(DateUtil.getNextDay(DateUtil.getStringDate(DateUtil.YYYY_MM_DD), 360), DateUtil.YYYY_MM_DD));
		token.setToken(tokenStr);
		token.setUser(user);
		token.setCzrq(czrq);
		// 先删除，防止重复
		tokenDao.deleteByUser(user);
		// 添加新的token
		token = tokenDao.save(token);
		if (token == null) {
			throw new Exception("Token生成失败");
		}
		// 更新token缓存
		SystemData.patientTokens.put(user, token);
		return token;
	}
	/**
	 * 删除token
	 * @param uid 用户code
	 * @return
	 * @throws Exception
	 */
	public void delToken(int platform, String uid) throws Exception {
		// 删除老的token
		tokenDao.deleteByUser(uid);
		// 更新token缓存
		if (platform == 3) {
			SystemData.patientTokens.remove(uid);
		} else if (platform == 2) {
			SystemData.doctorTokens.remove(uid);
		}
	}
	/**
	 * 查询患者的微信token标识
	 * @param patient
	 */
	public Token findWxToken(String patient) {
		return tokenDao.findByPatient(patient, 3);
	}
	/**
	 * 查询doctor的微信token标识
	 * @param user
	 */
	public Token findDoctorToken(String user) {
		return tokenDao.findByPatient(user, 4);
	}
}

business/base-service/src/main/java/com/yihu/jw/utils/SystemData.java

@@ -0,0 +1,19 @@
package com.yihu.jw.utils;
import com.yihu.jw.entity.base.security.Token;
import java.util.HashMap;
import java.util.Map;
public class SystemData {
	// 医生app验证信息
	public static Map<String, Token> doctorTokens = new HashMap<String, Token>();  // 2
	// 医生pc端验证信息 取药系统 对外系统
	public static Map<String, Token> doctorPCTokens = new HashMap<String, Token>(); // 4
	// 患者验证信息
	public static Map<String, Token> patientTokens = new HashMap<String, Token>(); // 3
	// 医生验证信息
	public static Map<String, Token> doctorWXTokens = new HashMap<String, Token>(); // 5
}

business/sms-service/src/main/java/com/yihu/jw/sms/dao/BaseSmsDao.java

@@ -1,7 +1,11 @@
package com.yihu.jw.sms.dao;
import com.yihu.jw.entity.base.sms.SmsDO;
import com.yihu.jw.entity.base.sms.SmsTemplateDO;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.PagingAndSortingRepository;
import java.util.Date;
@@ -13,4 +17,7 @@ import java.util.Date;
public interface BaseSmsDao extends PagingAndSortingRepository<SmsDO, String>, JpaSpecificationExecutor<SmsDO> {
    boolean existsByCaptchaAndDeadlineBefore(String captcha, Date now);
    @Query("select a from SmsDO a where a.mobile = ?1 and a.captcha = ?2 and a.type = ?3")
    Page<SmsDO> findByCaptcha(String mobile, String captcha, SmsTemplateDO.Type type, Pageable pageRequest);
}

business/sms-service/src/main/java/com/yihu/jw/sms/service/BaseSmsService.java

@@ -1,9 +1,13 @@
package com.yihu.jw.sms.service;
import com.yihu.jw.entity.base.sms.SmsDO;
import com.yihu.jw.entity.base.sms.SmsTemplateDO;
import com.yihu.jw.sms.dao.BaseSmsDao;
import com.yihu.mysql.query.BaseJpaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;
import java.util.Date;
@@ -26,4 +30,41 @@ public class BaseSmsService extends BaseJpaService<SmsDO, BaseSmsDao>{
    public Boolean verifyCaptcha(String captcha){
        return baseSmsDao.existsByCaptchaAndDeadlineBefore(captcha,new Date());
    }
    /**
     * 验证码校验
     *
     * @param mobile  手机号
     * @param type    type 消息类型:1微信端注册，2微信端找回密码，3医生端找回密码，4患者登录，5医生登录 7用户变更手机号 8用户新手机号验证 9用户绑定手机号
     * @param captcha 验证码
     * @return -1验证码过期，-1验证码错误，0验证码无效，1验证通过
     */
    public int check(String mobile, int type, String captcha) {
        // 根据手机号和验证码查询对应的短信信息
        // 排序
        Sort sort = new Sort(Sort.Direction.DESC, "createTime");
        // 分页信息
        PageRequest pageRequest = new PageRequest(0, 1, sort);
        SmsTemplateDO.Type value = SmsTemplateDO.valueOf(type);
        Page<SmsDO> page = baseSmsDao.findByCaptcha(mobile, captcha, value, pageRequest);
        SmsDO sms = null;
        for (SmsDO temp : page) {
            if (temp != null) {
                sms = temp;
                break;
            }
        }
        // 验证码校验
        if (sms == null) {
            // 验证码错误
            return -1;
        } else if (type != sms.getType().ordinal()){
            // 验证码无效，也视为错误
            return -1;
        } else if (sms.getDeadline().before(new Date())) {
            // 验证码过期
            return -2;
        }
        return 1;
    }
}

common/common-entity/src/main/java/com/yihu/jw/entity/base/patient/BasePatientDO.java

@@ -206,7 +206,7 @@ public class BasePatientDO extends UuidIdentityEntityWithOperator {
	private Date openidTime;
    /**
	 * 绑定电子社保卡主体（共济为操作人code）
	 * 绑定电子社保卡主体（共济为操作人code，医社保关联patient_medicare_card）
	 */
	private String principalCode;

common/common-entity/src/main/java/com/yihu/jw/entity/base/security/Token.java

@@ -0,0 +1,81 @@
package com.yihu.jw.entity.base.security;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.yihu.jw.entity.UuidIdentityEntity;
import javax.persistence.Entity;
import javax.persistence.Table;
import java.util.Date;
@Entity
@Table(name = "wlyy_token")
public class Token extends UuidIdentityEntity {
	private static final long serialVersionUID = -3297644428262254694L;
	private String user;
	private Integer platform;   // 1患者端，2医生端app，3微信公众号wechat,4医生端pc
	private Date timeout;
	private String imei;
	private String token;
	private Date czrq;
	private String del;
	public String getUser() {
		return user;
	}
	public void setUser(String user) {
		this.user = user;
	}
	public Integer getPlatform() {
		return platform;
	}
	public void setPlatform(Integer platform) {
		this.platform = platform;
	}
	@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+08:00")
	public Date getTimeout() {
		return timeout;
	}
	public void setTimeout(Date timeout) {
		this.timeout = timeout;
	}
	public String getImei() {
		return imei;
	}
	public void setImei(String imei) {
		this.imei = imei;
	}
	public String getToken() {
		return token;
	}
	public void setToken(String token) {
		this.token = token;
	}
	@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+08:00")
	public Date getCzrq() {
		return czrq;
	}
	public void setCzrq(Date czrq) {
		this.czrq = czrq;
	}
	public String getDel() {
		return del;
	}
	public void setDel(String del) {
		this.del = del;
	}
}

common/common-entity/src/main/java/com/yihu/jw/entity/base/sms/SmsTemplateDO.java

@@ -28,6 +28,21 @@ public class SmsTemplateDO extends UuidIdentityEntityWithOperator {
        updateMobile
    }
    public static Type valueOf(int value) {
        switch (value) {
            case 0:
                return Type.register;
            case 1:
                return Type.register;
            case 2:
                return Type.resetPassword;
            case 3:
                return Type.updateMobile;
            default:
                return null;
        }
    }
    //应用ID
    private String clientId;
    //标签

common/common-entity/src/main/java/com/yihu/jw/entity/myFamily/PatientApplyLog.java

@@ -15,8 +15,8 @@ import java.util.Date;
@Table(name = "patient_apply_for_log")
public class PatientApplyLog extends IntegerIdentityEntity {
    private String patientFamilyMemberName;//家庭成员名称
    private String patienyFamilyMemberCode;//家庭成员code
    private String familyMemberName;//家庭成员名称
    private String familyMemberCode;//家庭成员code
    private String qrCode;//二维码地址
    private Date failureTime;//失效时间
    private Integer status;//1、添加家人（默认），2、邀请登录，3、通过，4、拒绝
@@ -25,23 +25,26 @@ public class PatientApplyLog extends IntegerIdentityEntity {
    private String createUser;//申请人
    private String createUserName;//申请人姓名
    private Integer remindType;//提醒方式（1、打电话，2、发短信，3、微信）
    private Date confirmTime;//确认时间
    private Integer familyBindRole;//1配偶,2父亲,3母亲,4公公,5婆婆,6岳父,7岳母,8女婿,9儿媳,10子女
    @Column(name = "patient_family_member_name")
    public String getPatientFamilyMemberName() {
        return patientFamilyMemberName;
    @Column(name = "family_member_name")
    public String getFamilyMemberName() {
        return familyMemberName;
    }
    public void setPatientFamilyMemberName(String patientFamilyMemberName) {
        this.patientFamilyMemberName = patientFamilyMemberName;
    public void setFamilyMemberName(String familyMemberName) {
        this.familyMemberName = familyMemberName;
    }
    @Column(name = "patient_family_member_code")
    public String getPatienyFamilyMemberCode() {
        return patienyFamilyMemberCode;
    @Column(name = "family_member_code")
    public String getFamilyMemberCode() {
        return familyMemberCode;
    }
    public void setPatienyFamilyMemberCode(String patienyFamilyMemberCode) {
        this.patienyFamilyMemberCode = patienyFamilyMemberCode;
    public void setFamilyMemberCode(String familyMemberCode) {
        this.familyMemberCode = familyMemberCode;
    }
    @Column(name = "qr_code")
@@ -117,4 +120,22 @@ public class PatientApplyLog extends IntegerIdentityEntity {
    public void setRemindType(Integer remindType) {
        this.remindType = remindType;
    }
    @Column(name = "confirm_time")
    public Date getConfirmTime() {
        return confirmTime;
    }
    public void setConfirmTime(Date confirmTime) {
        this.confirmTime = confirmTime;
    }
    @Column(name = "family_bind_role")
    public Integer getFamilyBindRole() {
        return familyBindRole;
    }
    public void setFamilyBindRole(Integer familyBindRole) {
        this.familyBindRole = familyBindRole;
    }
}

common/common-request-mapping/src/main/java/com/yihu/jw/rm/base/BaseRequestMapping.java

@@ -472,6 +472,10 @@ public class BaseRequestMapping {
        public static final String idcardOccupied  = "/idcardOccupied";
        public static final String updateMobile  = "/updateMobile";
        public static final String resetPassword  = "/resetPassword";
        public static final String Regist = "regist";
        public static final String GetKey = "getKey";
        public static final String Login = "login";
    }
   /**

common/common-request-mapping/src/main/java/com/yihu/jw/rm/patient/PatientRequestMapping.java

@@ -26,13 +26,6 @@ public class PatientRequestMapping {
    }
    /**
     * patientInfo
     */
    public static class PatientInfo extends Basic {
        public static final String PREFIX  = "/patientInfo";
    }
    /**
     * signPackage
     */
@@ -54,6 +47,7 @@ public class PatientRequestMapping {
    public static class MyFamily extends Basic {
        public static final String PREFIX  = "/myFamily";
        public static final String getMyFamilyBindingRole  = "/getMyFamilyBindingRole";
        public static final String getBindingList  = "/getBindingList";
    }

common/common-rest-model/src/main/java/com/yihu/jw/restmodel/web/endpoint/EnvelopRestEndpoint.java

@@ -4,7 +4,6 @@ package com.yihu.jw.restmodel.web.endpoint;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.jw.entity.base.doctor.BaseDoctorDO;
import com.yihu.jw.restmodel.web.*;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
@@ -353,6 +352,17 @@ public abstract class EnvelopRestEndpoint {
            return null;
        }
    }
    public String getUID(String patient) {
        try {
            if(StringUtils.isEmpty(patient)){
                patient=this.getUID();
            }
            return patient;
        } catch (Exception e) {
            return null;
        }
    }
    public String getUNAME(){
        try {

svr/svr-patient/sql/sql

@@ -60,4 +60,41 @@ create table `account_appeal`
  `img` varchar(1000) not null COMMENT '身份证正反面照片，存地址，逗号分割',
  primary key (id)
)
  ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='账号申诉';
  ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='账号申诉';
-- 我的家人
DROP TABLE IF EXISTS `patient_apply_for_log`;
CREATE TABLE `patient_apply_for_log` (
  `id` int(11) NOT NULL,
  `family_member_name` varchar(50) COLLATE utf8_unicode_ci DEFAULT NULL COMMENT '家庭成员',
  `family_member_code` varchar(50) COLLATE utf8_unicode_ci DEFAULT NULL COMMENT '家庭成员code',
  `qr_code` varchar(50) COLLATE utf8_unicode_ci DEFAULT NULL,
  `failure_time` datetime DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT '失效时间',
  `status` int(2) DEFAULT '1' COMMENT '1、添加家人（默认），2、邀请登录，3、通过，4、拒绝',
  `create_time` datetime DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT '申请时间',
  `create_user` varchar(50) COLLATE utf8_unicode_ci DEFAULT NULL COMMENT '申请人',
  `create_user_name` varchar(50) COLLATE utf8_unicode_ci DEFAULT NULL COMMENT '申请人姓名',
  `del` int(2) DEFAULT NULL COMMENT '删除标志（1正常，0删除）申请人主动终止申请',
  `remind_type` int(1) DEFAULT NULL COMMENT '提醒方式（1、打电话，2、发短信，3、微信）',
  `confirm_time` datetime DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT '绑定确认时间',
  `family_bind_role` int(2) DEFAULT NULL COMMENT '1配偶,2父亲,3母亲,4公公,5婆婆,6岳父,7岳母,8女婿,9儿媳,10子女',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci COMMENT='绑定家人申请表';
DROP TABLE IF EXISTS `base_patient_family_member`;
CREATE TABLE `base_patient_family_member` (
  `id` varchar(50) NOT NULL COMMENT '主键',
  `patient` varchar(50) DEFAULT NULL COMMENT '居民code',
  `family_member` varchar(50) DEFAULT NULL COMMENT '家庭成员code',
  `family_relation` int(2) DEFAULT NULL COMMENT '1"配偶",2"父亲",3"母亲",4"公公",5"婆婆",6"岳父",7"岳母",8"女婿",9"儿媳",10"子女"',
  `is_authorize` int(1) DEFAULT NULL COMMENT '是否授权0:未授权,1:已授权，默认为1',
  `del` int(1) DEFAULT NULL COMMENT '删除标志（1正常，0删除）',
  `update_time` timestamp NULL DEFAULT NULL COMMENT '操作日期',
  `update_user` varchar(50) DEFAULT NULL,
  `update_user_name` varchar(50) DEFAULT NULL,
  `create_time` timestamp NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP,
  `create_user` varchar(50) DEFAULT NULL,
  `create_user_name` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `fmaily_member_patient` (`patient`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='居民家庭成员表';

svr/svr-patient/src/main/java/com/yihu/jw/patient/constant/SystemConstant.java

@@ -0,0 +1,11 @@
package com.yihu.jw.patient.constant;
public class SystemConstant {
    // 别处登录
    public static final int LOGIN_OTHER = 999;
    // 登录超时
    public static final int LOGIN_TIMEOUT = 998;
    // 未登录
    public static final int NOT_LOGIN = 997;
}

svr/svr-patient/src/main/java/com/yihu/jw/patient/dao/myFamily/PatientApplyLogDao.java

@@ -13,6 +13,8 @@ public interface PatientApplyLogDao extends PagingAndSortingRepository<PatientAp
    @Modifying
    @Query("update PatientApplyLog t set t.remindType = ?1 where t.id=?2 ")
    int updateRemindTypeById(Integer remindType, Integer patientApplyLogId);
    int updateRemindTypeById(Integer remindType, Integer id);
    PatientApplyLog findById(Integer id);
}

svr/svr-patient/src/main/java/com/yihu/jw/patient/dao/myFamily/PatientFamilyMemberDao.java

@@ -26,4 +26,7 @@ public interface PatientFamilyMemberDao extends PagingAndSortingRepository<BaseP
    @Query("select m from BasePatientFamilyMemberDO m where m.del=1 and m.familyMember=?1 and m.familyRelation in (?2,?3)")
    List<BasePatientFamilyMemberDO> getByFamilyMemberAndFamilyRelation(String familyMember,Integer familyRelation1,Integer familyRelation2);
    @Query("select m from BasePatientFamilyMemberDO m where m.del=1 and (m.familyMember=?1 or m.patient=?1)")
    List<BasePatientFamilyMemberDO> getByPatientAndFamilyMember(String patient);
}

svr/svr-patient/src/main/java/com/yihu/jw/patient/dao/personal_info/PatientDao.java

@@ -3,6 +3,7 @@ package com.yihu.jw.patient.dao.personal_info;
import com.yihu.jw.entity.base.patient.BasePatientDO;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.PagingAndSortingRepository;
@@ -32,4 +33,8 @@ public interface PatientDao extends PagingAndSortingRepository<BasePatientDO, St
    @Query("from BasePatientDO p where p.mobile = ?1 and p.del=?2")
    List<BasePatientDO> findByMobileAndDel(String mobile,String del);
    @Modifying
    @Query(" update BasePatientDO a set a.openid=?2 where a.id=?1 ")
    int updateOpenId(String id, String openId);
}

svr/svr-patient/src/main/java/com/yihu/jw/patient/endpoint/file_upload/FileUploadEndpoint.java

@@ -0,0 +1,72 @@
package com.yihu.jw.patient.endpoint.file_upload;
import com.yihu.jw.file_upload.FileUploadService;
import com.yihu.jw.restmodel.iot.common.UploadVO;
import com.yihu.jw.restmodel.web.ObjEnvelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import com.yihu.jw.rm.base.BaseRequestMapping;
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.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import java.io.InputStream;
/**
 * 文件上传公共类
 */
@RestController
@RequestMapping(BaseRequestMapping.FileUpload.PREFIX)
@Api(tags = "文件上传相关操作", description = "文件上传相关操作")
public class FileUploadEndpoint extends EnvelopRestEndpoint {
    @Value("${fastDFS.fastdfs_file_url}")
    private String fastdfs_file_url;
    @Autowired
    FileUploadService fileUploadService;
    @PostMapping(value = BaseRequestMapping.FileUpload.UPLOAD_STREAM_IMG)
    @ApiOperation(value = "文件流上传图片", notes = "文件流上传图片")
    public ObjEnvelop<UploadVO> uploadImg(@ApiParam(value = "文件", required = true)
                                       @RequestParam(value = "file", required = true) MultipartFile file) throws Exception{
        // 得到文件的完整名称  xxx.txt
        String originalFilename = file.getOriginalFilename();
        InputStream inputStream = file.getInputStream();
        UploadVO uploadVO = fileUploadService.uploadImg(inputStream,originalFilename,file.getSize(),fastdfs_file_url);
        return success("上传成功", uploadVO);
    }
    @PostMapping(value = BaseRequestMapping.FileUpload.UPLOAD_STREAM_ATTACHMENT)
    @ApiOperation(value = "文件流上传附件", notes = "文件流上传附件")
    public ObjEnvelop<UploadVO> uploadAttachment(@ApiParam(value = "文件", required = true)
                                       @RequestParam(value = "file", required = true) MultipartFile file) throws Exception{
        String originalFilename = file.getOriginalFilename();
        InputStream inputStream = file.getInputStream();
        UploadVO uploadVO = fileUploadService.uploadAttachment(inputStream,originalFilename,file.getSize(),fastdfs_file_url);
        return success("上传成功", uploadVO);
    }
    @PostMapping(value = BaseRequestMapping.FileUpload.UPLOAD_STREAM)
    @ApiOperation(value = "文件流上传文件", notes = "文件流上传文件")
    public ObjEnvelop<UploadVO> uploadStream(@ApiParam(value = "文件", required = true)
                                                 @RequestParam(value = "file", required = true) MultipartFile file) throws Exception{
        // 得到文件的完整名称  xxx.txt
        String originalFilename = file.getOriginalFilename();
        InputStream inputStream = file.getInputStream();
        UploadVO uploadVO = fileUploadService.uploadStream(inputStream,originalFilename,fastdfs_file_url);
        return success("上传成功", uploadVO);
    }
    @PostMapping(value = BaseRequestMapping.FileUpload.UPLOAD_STRING)
    @ApiOperation(value = "base64上传图片",notes = "base64上传图片")
    public ObjEnvelop<UploadVO> uploadImages(@ApiParam(name = "jsonData", value = "头像转化后的输入流")
                                                 @RequestBody String jsonData) throws Exception {
        UploadVO uploadVO = fileUploadService.uploadImages(jsonData,fastdfs_file_url);
        return success("上传成功", uploadVO);
    }
}

svr/svr-patient/src/main/java/com/yihu/jw/patient/endpoint/myFamily/MyFamilyEndpoint.java

@@ -6,9 +6,11 @@ import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import com.yihu.jw.rm.patient.PatientRequestMapping;
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.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
@@ -27,9 +29,25 @@ public class MyFamilyEndpoint extends EnvelopRestEndpoint {
    @GetMapping(value = PatientRequestMapping.MyFamily.getMyFamilyBindingRole)
    @ApiOperation(value = "获取我的家人")
    public Envelop getMyFamilyBindingRole() throws Exception {
    public Envelop getMyFamilyBindingRole(
            @ApiParam(name = "patient", value = "居民code", required = false)
            @RequestParam(value = "patient",required = false) String patient) throws Exception {
        try{
            List<Map<String,Object>> basePatients = myFamilyService.getMyFamilyBindingRole(getUID());
            List<Map<String,Object>> basePatients = myFamilyService.getMyFamilyBindingRole(getUID(patient));
            return success(basePatients);
        }catch (Exception e){
            e.printStackTrace();
            return failed(e.getMessage());
        }
    }
    @GetMapping(value = PatientRequestMapping.MyFamily.getBindingList)
    @ApiOperation(value = "签约界面已绑定家人信息")
    public Envelop getBindingList(
            @ApiParam(name = "patient", value = "居民code", required = false)
            @RequestParam(value = "patient",required = false) String patient) throws Exception {
        try{
            List<Map<String,Object>> basePatients = myFamilyService.getBindingList(getUID(patient));
            return success(basePatients);
        }catch (Exception e){
            e.printStackTrace();

svr/svr-patient/src/main/java/com/yihu/jw/patient/endpoint/patient/PatientInfoEndpint.java

@@ -1,375 +0,0 @@
package com.yihu.jw.patient.endpoint.patient;
import com.yihu.jw.entity.base.patient.BasePatientDO;
import com.yihu.jw.patient.dao.personal_info.PatientDao;
import com.yihu.jw.patient.service.personal_Info.PatientService;
import com.yihu.jw.patient.util.CommonUtils;
import com.yihu.jw.patient.util.RSAService;
import com.yihu.jw.restmodel.web.Envelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import com.yihu.jw.rm.patient.PatientRequestMapping;
import com.yihu.jw.util.security.MD5;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.*;
import java.util.*;
@RestController
@RequestMapping(PatientRequestMapping.PatientInfo.PREFIX)
@Api(value = "患者注册,登陆等", description = "患者注册,登陆等", tags = {"居民端 - 患者注册,登陆等"})
public class PatientInfoEndpint extends EnvelopRestEndpoint {
    @Autowired
    private PatientDao patientDao;
    @Autowired
    private PatientService patientService;
    @Autowired
    private RSAService rsaService;
    /**
     * 公钥生成并返回接口
     *
     * @return
     */
    @RequestMapping(value = "getKey", method = RequestMethod.GET)
    @ApiOperation("获取公钥")
    public Envelop publicKey() {
        String modulus = rsaService.getModulus();
        String exponent = rsaService.getExponent();
        Map<String, String> map = new HashMap<>();
        map.put("modulus", modulus); //加密指数
        map.put("exponent", exponent);//加密系数
        return success(map);
    }
    @ApiOperation("居民注册接口")
    @RequestMapping(value = "regist", method = RequestMethod.POST)
    @ResponseBody
    public Envelop regist(@ApiParam(value = "手机号", name = "mobile") @RequestParam(required = true)String mobile ,
                         @ApiParam(value = "验证码", name = "captcha") @RequestParam(value = "captcha", required = true) String captcha,
                         @ApiParam(value = "微信openId", name = "openid") @RequestParam(value = "openid", required = false) String openid,
                         @ApiParam(value = "密码", name = "password") @RequestParam(value = "password", required = false) String password) {
        Envelop envelop = new Envelop();
        boolean b = CommonUtils.isMobile(mobile);
        if(!b){
            envelop.setMessage("手机号码格式不正确");
            envelop.setStatus(-1);
            return envelop;
        }
        //验证手机是否被注册
        List<BasePatientDO> list =  patientDao.findByMobileAndDel(mobile,"1");
        if(list!=null && list.size()> 0){
            envelop.setMessage("该手机号已经注册！");
            envelop.setStatus(-1);
            return envelop;
        }
        // 对验证码进行校验 todo cyx
//            int res = smsService.check(mobile, 1, captcha);
//            switch (res) {
//                case -2:
//                    return error(-1, "验证码已过期！");
//                case -1:
//                    return error(-1, "请输入正确的验证码！");
//                case 0:
//                    return error(-1, "验证码无效！");
//            }
        BasePatientDO patient = new BasePatientDO();
        patient.setMobile(mobile);
        if(StringUtils.isNotBlank(password)){
            //增加密码
            String salt = UUID.randomUUID().toString().replace("-", "");
            patient.setSalt(salt);
            password = rsaService.decryptString(password);
            password = StringUtils.reverse(password);
            if(password.length()<6 || password.length()>20){
                envelop.setMessage("密码长度需为6-20位");
                envelop.setStatus(-1);
                return envelop;
            }
            patient.setPassword(MD5.GetMD5Code(password + salt));
        }
        if(!"undefined".equals(openid) && StringUtils.isNotBlank(openid)){
            patient.setOpenid(openid);
            patient.setOpenidTime(new Date());
        }
        patient.setDel("1");
        patient.setPatientStatus("1");
        patientService.save(patient);
        envelop.setMessage("注册成功");
        envelop.setStatus(200);
        return envelop;
    }
    /**
     * 患者微信登录接口
     *
     * @param captcha  短信号
     * @param mobile   电话号码
     * @param password 登录密码
     * @return
     */
        @RequestMapping(value = "login", method = RequestMethod.POST)
        @ResponseBody
        public Envelop login(
                @RequestParam(required = true) String mobile,
                @RequestParam(required = false) String captcha,
                @RequestParam(required = false) String password,
                @RequestParam(required = false) String openId) {
        Envelop envelop = new Envelop();
        boolean b = CommonUtils.isMobile(mobile);
        if(!b){
            envelop.setMessage("手机号码格式不正确");
            envelop.setStatus(-1);
            return envelop;
        }
        //验证手机是否被注册
        List<BasePatientDO> list = patientDao.findByMobileAndDel(mobile,"1");
        if(CollectionUtils.isEmpty(list)){
            envelop.setMessage("该手机未注册");
            envelop.setStatus(-1);
            return envelop;
        }
        if(list.size()> 1){
            envelop.setMessage("该手机号存在多个账号,请联系管理员");
            envelop.setStatus(-1);
            return envelop;
        }
        BasePatientDO p = list.get(0);
        //用于判断是否登陆成功,若登陆成功,且openId不为空,则更新openId
        boolean isLogin = false;
        if(StringUtils.isNotBlank(password)){
            password = rsaService.decryptString(password);
            password = StringUtils.reverse(password);
            //生成MD5
            String loginPassword = MD5.GetMD5Code(password + p.getSalt());
            if (loginPassword.equals(p.getPassword())) {
                //使用密码登录成功
            }else{
                //使用密码登录失败
            }
        } else {
          //验证码登陆
        }
        if(isLogin && StringUtils.isNotBlank(openId) && !"undefined".equals(openId)){
            //更新openId
            if(!openId.equals(p.getOpenid())){
            }
        }
//         String errorMessage;
//        try {
//            //账号登录 mobile可能是电话号也可能是身份证
//            if (StringUtils.isNoneEmpty(mobile) && StringUtils.isNoneEmpty(password)) {
//                BasePatientDO p = patientService.findByMobile(mobile);
//                //生成MD5
//                String loginPassword = MD5.GetMD5Code(password + p.getSalt());
//                //判断d登录密码是否正确
//                if (loginPassword.equals(p.getPassword())) {
//                    // 绑定用户手机号和openid
//                    if (StringUtils.isNotBlank(openId) && !"undefined".equals(openId)) {//undefined不更新数据库
//                        //patient.setOpenid(openId);
//                        //1.判斷居民OPenid是不是空
//                        if(StringUtils.isNotBlank(p.getOpenid())){
//                            //如果OPenid与原来用户不相等，则判断登录的openids是否被大于10人登录
//                            if(!p.getOpenid().equals(openId)){
//                                //判断登录的openids是否被大于10人登录
////                                if(!patientService.checkOpenidCount(openId)){
////                                    errorMessage ="您已超过系统允许登录的最大居民账号数量，当前不再允许使用该微信登录新的居民账号，请使用其他微信号进行登录";
////                                    return error(-2, errorMessage);
////                                }
//                            }
//                            patientService.updatePatient(p, openId);
//                        }else{
//                            // 判断登录的openids是否被大于10人登录
//                            if(!patientService.checkOpenidCount(openId)){
////                                errorMessage ="您已超过系统允许登录的最大居民账号数量，当前不再允许使用该微信登录新的居民账号，请使用其他微信号进行登录";
////                                return error(-2, errorMessage);
//                            }else{
//                                //未达到上限更新用户openid
//                                patientService.updatePatient(p, openId);
//                            }
//                        }
//                    }
//
//                    // 用户校验通过，生成token
//                    Token token = tokenService.newTxToken(p.getCode(), openId);
//                    Map<Object, Object> map = new HashMap<Object, Object>();
//                    map.put("id", p.getId());
//                    map.put("uid", p.getCode());
//                    map.put("name", p.getName());
//                    map.put("token", token.getToken());
//                    map.put("photo", p.getPhoto());
//                    if (StringUtils.isNoneEmpty(openId)) {
//                        //发送微信模板
//                        familyService.sendWXMessage(p);
//                    }
//
//                    loginLog.setLoginType("1");
//                    loginLogService.saveLog(loginLog);
//                    //判断是否打过标签
//                    //if (!(Patient.isWchatTage.yes.getValue() == p.getIsWxtag())) {
//
//                    //清空患者的微信标签
//                    weiXinTagUtil.deleteTagWithOpenid(p.getOpenid());
//                    //给患者打微信标签
//                    weiXinTagUtil.addTagWithOpenid(openId, p.getCode(), p.getName());
//                    //}
//                    return write(200, "登录成功", "data", map);
//                } else {
//                    errorMessage = "密码错误,登录失败";
//                    loginLog.setErrorMessage(errorMessage);
//                    loginLogService.saveLog(loginLog);
//                    return error(-1, errorMessage);
//                }
//            }
//            //短信登录
//            if (StringUtils.isNoneEmpty(mobile) && StringUtils.isNoneEmpty(captcha)) {
//                List<Patient> patients = patientService.findByMobile(mobile);
//                if (patients.size() > 1) {
//                    return error(-1, "此手机存在多个用户，请用身份证和密码登录！");
//                }
//                // 对验证码进行校验
//                int res = smsService.check(mobile, 4, captcha);
//                switch (res) {
//                    case -2: {
//                        errorMessage = "验证码已过期！";
//                        loginLog.setErrorMessage(errorMessage);
//                        loginLogService.saveLog(loginLog);
//                        return error(-1, errorMessage);
//                    }
//                    case -1: {
//                        errorMessage = "请输入正确的验证码！";
//                        loginLog.setErrorMessage(errorMessage);
//                        loginLogService.saveLog(loginLog);
//                        return error(-1, errorMessage);
//                    }
//                    case 0: {
//                        errorMessage = "验证码无效！";
//                        loginLog.setErrorMessage(errorMessage);
//                        loginLogService.saveLog(loginLog);
//                        return error(-1, errorMessage);
//                    }
//                }
//
//                loginLog.setLoginType("1");
//                if (patients == null || patients.size() == 0) {
//                    if (mobile.length() == 11) {
//                        errorMessage = "该手机号暂未注册账号，请确认后重新输入！";
//                    } else {
//                        errorMessage = "该身份证号暂未注册账号，请确认后重新输入！";
//                    }
//                    loginLog.setErrorMessage(errorMessage);
//                    loginLogService.saveLog(loginLog);
//                    return error(-1, errorMessage);
//                } else {
//                    Patient p = null;
//                    if (patients.size() == 1) {
//                        p = patients.get(0);
//                    }
//                    if (p.getStatus() == 0) {
//                        if (mobile.length() == 11) {
//                            errorMessage = "该手机号已被禁止使用！";
//                        } else {
//                            errorMessage = "该身份证号已被禁止使用！";
//                        }
//                        loginLog.setErrorMessage(errorMessage);
//                        loginLogService.saveLog(loginLog);
//                        return error(-1, errorMessage);
//                    } else if (p.getStatus() == 2) {
//                        errorMessage = "该账号正在审核中，请确认审核通过后再登录，“如有疑问，拨打400-6677-400转2人工客服”";
//                        loginLog.setErrorMessage(errorMessage);
//                        loginLogService.saveLog(loginLog);
//                        return error(-1, errorMessage);
//                    } else if (StringUtils.isEmpty(openId)) {
//                        errorMessage = "无效的OpenID！";
//                        loginLog.setErrorMessage(errorMessage);
//                        loginLogService.saveLog(loginLog);
//                        return error(-1, errorMessage);
//                    }
//                    loginLog.setUserCode(p.getCode());
//                    // 绑定用户手机号和openid
////                    if (!StringUtils.equals(p.getOpenid(), openId) && !"undefined".equals(openId)) {//undefined不更新数据库
////                        //patient.setOpenid(openId);
////                        patientService.updatePatient(p, openId);
////                    }
//                    if (StringUtils.isNotBlank(openId) && !"undefined".equals(openId)) {//undefined不更新数据库
//                        //patient.setOpenid(openId);
//                        //1.判斷居民OPenid是不是空
//                        if(StringUtils.isNotBlank(p.getOpenid())){
//                            //如果OPenid与原来用户不相等，则判断登录的openids是否被大于10人登录
//                            if(!p.getOpenid().equals(openId)){
//                                //判断登录的openids是否被大于10人登录
//                                if(!patientService.checkOpenidCount(openId)){
////                                    errorMessage ="您已超过系统允许登录的最大居民账号数量，当前不再允许使用该微信登录新的居民账号，请使用其他微信号进行登录";
////                                    return error(-2, errorMessage);
//                                }
//                            }
//                            patientService.updatePatient(p, openId);
//                        }else{
//                            // 判断登录的openids是否被大于10人登录
//                            if(!patientService.checkOpenidCount(openId)){
////                                errorMessage ="您已超过系统允许登录的最大居民账号数量，当前不再允许使用该微信登录新的居民账号，请使用其他微信号进行登录";
////                                return error(-2, errorMessage);
//                            }else{
//                                //未达到上限更新用户openid
//                                patientService.updatePatient(p, openId);
//                            }
//                        }
//                    }
//
//                    // 用户校验通过，生成token
//                    Token token = tokenService.newTxToken(p.getCode(), openId);
//                    Map<Object, Object> map = new HashMap<Object, Object>();
//                    map.put("id", p.getId());
//                    map.put("uid", p.getCode());
//                    map.put("name", p.getName());
//                    map.put("token", token.getToken());
//                    map.put("photo", p.getPhoto());
//                    if (StringUtils.isNoneEmpty(openId)) {
//                        //发送微信模板
//                        familyService.sendWXMessage(p);
//                    }
//                    loginLog.setType("1");
//                    loginLogService.saveLog(loginLog);
//                    //判断是否打过标签
//                    //if (!(Patient.isWchatTage.yes.getValue() == p.getIsWxtag())) {
//                    //清空患者的微信标签
//                    weiXinTagUtil.deleteTagWithOpenid(p.getOpenid());
//                    //给患者打微信标签
//                    weiXinTagUtil.addTagWithOpenid(openId, p.getCode(), p.getName());
//                    //}
//                    return write(200, "登录成功", "data", map);
//                }
//            }
//            return error(-1, "登录失败");
//        } catch (Exception e) {
//
//            errorMessage = "系统异常，登录失败";
//            loginLog.setErrorMessage(errorMessage);
//            loginLogService.saveLog(loginLog);
//            error(e);
//            return error(-1, "系统异常，登录失败");
//        }
            return null;
    }
}

svr/svr-patient/src/main/java/com/yihu/jw/patient/endpoint/personal_info/PatientEndpoint.java

@@ -1,9 +1,15 @@
package com.yihu.jw.patient.endpoint.personal_info;
import com.yihu.jw.entity.base.patient.BasePatientDO;
import com.yihu.jw.entity.base.security.Token;
import com.yihu.jw.entity.base.sms.SmsDO;
import com.yihu.jw.entity.base.sms.SmsTemplateDO;
import com.yihu.jw.patient.service.personal_Info.PatientService;
import com.yihu.jw.patient.dao.personal_info.PatientDao;
import com.yihu.jw.patient.service.personal_Info.PatientService;
import com.yihu.jw.patient.util.CommonUtils;
import com.yihu.jw.patient.util.ConstantUtils;
import com.yihu.jw.patient.util.RSAService;
import com.yihu.jw.restmodel.base.patient.BasePatientVO;
import com.yihu.jw.restmodel.base.sms.SmsVO;
import com.yihu.jw.restmodel.web.Envelop;
@@ -12,17 +18,20 @@ import com.yihu.jw.restmodel.web.ObjEnvelop;
import com.yihu.jw.restmodel.web.PageEnvelop;
import com.yihu.jw.restmodel.web.endpoint.EnvelopRestEndpoint;
import com.yihu.jw.rm.base.BaseRequestMapping;
import com.yihu.jw.security.service.TokenService;
import com.yihu.jw.sms.service.BaseSmsGatewayService;
import com.yihu.jw.sms.service.BaseSmsService;
import com.yihu.jw.util.security.MD5;
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.beans.factory.annotation.Value;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import java.util.List;
import java.util.Map;
import java.util.*;
/**
 * 居民信息控制器
@@ -48,6 +57,240 @@ public class PatientEndpoint extends EnvelopRestEndpoint {
    @Autowired
    private BaseSmsGatewayService baseSmsGatewayService;
    @Autowired
    private PatientDao patientDao;
    @Autowired
    private PatientService patientService;
    @Autowired
    private RSAService rsaService;
    @Autowired
    private TokenService tokenService;
    @Autowired
    private BaseSmsService baseSmsService;
    /**
     * 公钥生成并返回接口
     *
     * @return
     */
    @RequestMapping(value = BaseRequestMapping.BasePatient.GetKey, method = RequestMethod.GET)
    @ApiOperation("获取公钥")
    public Envelop publicKey() {
        String modulus = rsaService.getModulus();
        String exponent = rsaService.getExponent();
        Map<String, String> map = new HashMap<>();
        map.put("modulus", modulus); //加密指数
        map.put("exponent", exponent);//加密系数
        return success(map);
    }
    @ApiOperation("居民注册接口")
    @RequestMapping(value = BaseRequestMapping.BasePatient.Regist, method = RequestMethod.POST)
    @ResponseBody
    public Envelop regist(@ApiParam(value = "手机号", name = "mobile") @RequestParam(required = true)String mobile ,
                          @ApiParam(value = "验证码", name = "captcha") @RequestParam(value = "captcha", required = true) String captcha,
                          @ApiParam(value = "微信openId", name = "openid") @RequestParam(value = "openid", required = false) String openid,
                          @ApiParam(value = "密码", name = "password") @RequestParam(value = "password", required = false) String password) {
        Envelop envelop = new Envelop();
        boolean b = CommonUtils.isMobile(mobile);
        if(!b){
            envelop.setMessage("手机号码格式不正确");
            envelop.setStatus(-1);
            return envelop;
        }
        //验证手机是否被注册
        List<BasePatientDO> list = patientDao.findByMobileAndDel(mobile,"1");
        if(list!=null && list.size()> 0){
            envelop.setMessage("该手机号已经注册！");
            envelop.setStatus(-1);
            return envelop;
        }
        // 对验证码进行校验
        int res = baseSmsService.check(mobile, 0, captcha);
        if(-2 == res){
            envelop.setMessage("验证码已过期！");
            envelop.setStatus(-1);
            return envelop;
        }else if(-1 == res){
            envelop.setMessage("请输入正确的验证码！");
            envelop.setStatus(-1);
            return envelop;
        }else if(0 == res){
            envelop.setMessage("验证码无效！");
            envelop.setStatus(-1);
            return envelop;
        } else{
            BasePatientDO patient = new BasePatientDO();
            patient.setMobile(mobile);
            if(StringUtils.isNotBlank(password)){
                //增加密码
                String salt = UUID.randomUUID().toString().replace("-", "");
                patient.setSalt(salt);
                password = rsaService.decryptString(password);
                password = StringUtils.reverse(password);
                if(password.length()<6 || password.length()>20){
                    envelop.setMessage("密码长度需为6-20位");
                    envelop.setStatus(-1);
                    return envelop;
                }
                patient.setPassword(MD5.GetMD5Code(password + salt));
            }
            if(!"undefined".equals(openid) && StringUtils.isNotBlank(openid)){
                patient.setOpenid(openid);
                patient.setOpenidTime(new Date());
            }
            patient.setDel("1");
            patient.setPatientStatus("1");
            patientService.save(patient);
            envelop.setMessage("注册成功");
            envelop.setStatus(200);
            return envelop;
        }
    }
    /**
     * 患者微信登录接口
     *
     * @param captcha  短信号
     * @param mobile   电话号码
     * @param password 登录密码
     * @return
     */
    @RequestMapping(value = BaseRequestMapping.BasePatient.Login, method = RequestMethod.POST)
    @ResponseBody
    public Envelop login(
            @RequestParam(required = true) String mobile,
            @RequestParam(required = false) String captcha,
            @RequestParam(required = false) String password,
            @RequestParam(required = false) String openId) throws Exception {
        Envelop envelop = new Envelop();
        boolean b = CommonUtils.isMobile(mobile);
        if(!b){
            envelop.setMessage("手机号码格式不正确");
            envelop.setStatus(-1);
            return envelop;
        }
        //验证手机是否被注册
        List<BasePatientDO> list = patientDao.findByMobileAndDel(mobile,"1");
        if(CollectionUtils.isEmpty(list)){
            envelop.setMessage("该手机未注册");
            envelop.setStatus(-1);
            return envelop;
        }
        if(list.size()> 1){
            envelop.setMessage("该手机号存在多个账号,请联系管理员");
            envelop.setStatus(-1);
            return envelop;
        }
        BasePatientDO p = list.get(0);
        //用于判断是否登陆成功,若登陆成功,且openId不为空,则更新openId
        boolean isLogin = false;
        if(org.apache.commons.lang3.StringUtils.isNotBlank(password)){
            password = rsaService.decryptString(password);
            password = org.apache.commons.lang3.StringUtils.reverse(password);
            //生成MD5
            String loginPassword = MD5.GetMD5Code(password + p.getSalt());
            if (loginPassword.equals(p.getPassword())) {
                //使用密码登录成功
                isLogin = true;
            }else{
                //使用密码登录失败
                envelop.setMessage("密码错误");
                envelop.setStatus(-1);
                return envelop;
            }
        } else {
            //验证码登陆
            int res = baseSmsService.check(mobile, 4, captcha);
            if(-2 == res){
                envelop.setMessage("验证码已过期！");
                envelop.setStatus(-1);
                return envelop;
            }else if(-1 == res){
                envelop.setMessage("请输入正确的验证码！");
                envelop.setStatus(-1);
                return envelop;
            }else if(0 == res) {
                envelop.setMessage("验证码无效！");
                envelop.setStatus(-1);
                return envelop;
            } else {
                //使用密码登录成功
                isLogin = true;
            }
        }
        if(isLogin){
            if(StringUtils.isNotBlank(openId) && !"undefined".equals(openId)){
                //更新openId
                if(!openId.equals(p.getOpenid())){
                    patientService.updateOpenId(p.getId(), openId);
                }
            }
            // 用户校验通过，生成token
            Token token = tokenService.newTxToken(p.getId(), p.getOpenid());
            Map<Object, Object> map = new HashMap<Object, Object>();
            map.put("id", p.getId());
            map.put("uid", p.getId());
            map.put("name", p.getName());
            map.put("token", token.getToken());
            map.put("photo", p.getPhoto());
            envelop.setMessage("登陆成功");
            envelop.setStatus(200);
        }
        return envelop;
    }
    @PostMapping(value = BaseRequestMapping.BasePatient.CREATE)
    @ApiOperation(value = "创建")
    public Envelop create(
            @ApiParam(name = "jsonData", value = "Json数据", required = true)
            @RequestParam String jsonData) throws Exception {
       String msg = patientService.createPatient(jsonData);
       if(!StringUtils.equalsIgnoreCase(ConstantUtils.SUCCESS,msg)){
           return success(msg);
       }
        return failed(msg);
    }
    @PostMapping(value = BaseRequestMapping.BasePatient.DELETE)
    @ApiOperation(value = "删除")
    public Envelop delete(
            @ApiParam(name = "ids", value = "id串，中间用,分隔", required = true)
            @RequestParam(value = "ids") String ids) {
        patientService.delete(ids.split(","));
        return success("删除成功");
    }
    @PostMapping(value = BaseRequestMapping.BasePatient.UPDATE)
    @ApiOperation(value = "更新")
    public Envelop update(
            @ApiParam(name = "jsonData", value = "Json数据", required = true)
            @RequestParam String jsonData) throws Exception {
        String msg = patientService.updatePatient(jsonData);
        if(!StringUtils.equalsIgnoreCase(ConstantUtils.SUCCESS,msg)){
            return failed(msg);
        }
        return success(msg);
    }
    @GetMapping(value = BaseRequestMapping.BasePatient.getPatientById)
    @ApiOperation(value = "获取列表")
    public Envelop getPatientById(
            @ApiParam(name = "id", value = "居民id")
            @RequestParam(value = "id", required = true) String id) throws Exception {
        String result = patientService.getPatientById(id);
        return success(result);
    }
    @GetMapping(value = BaseRequestMapping.BasePatient.PAGE)
    @ApiOperation(value = "获取分页")
    public PageEnvelop<BasePatientVO> page(

svr/svr-patient/src/main/java/com/yihu/jw/patient/service/myFamily/MyFamilyService.java

@@ -4,11 +4,14 @@ import com.alibaba.fastjson.JSONObject;
import com.yihu.jw.entity.base.message.BaseMessageDO;
import com.yihu.jw.entity.base.patient.BasePatientDO;
import com.yihu.jw.entity.base.patient.BasePatientFamilyMemberDO;
import com.yihu.jw.entity.base.patient.PatientMedicareCardDO;
import com.yihu.jw.entity.myFamily.PatientApplyLog;
import com.yihu.jw.message.service.MessageService;
import com.yihu.jw.patient.service.BasePatientService;
import com.yihu.jw.patient.service.BasePatientMedicardCardService;
import com.yihu.jw.patient.service.personal_Info.PatientService;
import com.yihu.jw.wechat.service.WeChatQrcodeService;
import org.apache.commons.collections.map.HashedMap;
import org.apache.commons.collections.map.LinkedMap;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
@@ -27,7 +30,7 @@ public class MyFamilyService {
    @Autowired
    private PatientFamilyMemberService patientFamilyMemberService;
    @Autowired
    private BasePatientService patientService;
    private PatientService patientService;
    @Autowired
    private MessageService messageService;
    @Value("${myFamily.qrCodeFailurTime}")
@@ -36,6 +39,8 @@ public class MyFamilyService {
    private WeChatQrcodeService weChatQrcodeService;
    @Autowired
    private PatientApplyLogService patientApplyLogService;
    @Autowired
    private BasePatientMedicardCardService  patientMedicareCardService;
    public List<Map<String,Object>> getMyFamilyBindingRole(String patient) throws Exception{
@@ -44,9 +49,9 @@ public class MyFamilyService {
        BasePatientDO patientDO = patientService.findByIdAndDel(patient);
        Integer sex = patientDO.getSex();
        LinkedList<String> role = new LinkedList<>(Arrays.asList("配偶","父亲","母亲","公公","婆婆","岳父","岳母","女婿","儿媳","子女"));
        Map<String,Map<String,Object>> map = new HashedMap();
        Map<String,Map<String,Object>> map = new LinkedMap();
        for(int i =0;i<role.size();i++){
            Map<String,Object> m = new HashedMap();
            Map<String,Object> m = new LinkedMap();
            m.put("name",role.get(i));
            m.put("isBinding",0);
            m.put("key",(i+1));
@@ -77,13 +82,9 @@ public class MyFamilyService {
        if(childrenList.size()==2){
            map.get("10").put("isBinding",1);
        }
        List<Map<String,Object>> resultList = new ArrayList();
        Iterator iter = map.entrySet().iterator(); // 获得map的Iterator
        while (iter.hasNext()) {
            String key = iter.next().toString();
            resultList.add(map.get(key));
        }
        return resultList;
        Collection<Map<String,Object>> valueCollection = map.values();
        List<Map<String,Object>> valueList = new LinkedList<>(valueCollection);
        return valueList;
    }
    /**
@@ -97,7 +98,7 @@ public class MyFamilyService {
     * @throws Exception
     */
    @Transactional(rollbackFor = Exception.class)
    public PatientApplyLog bindingMyFamily(HttpServletRequest request,String wechatId, String saasId, String patient, String familyMobile, Integer platform) throws Exception{
    public PatientApplyLog bindingMyFamily(HttpServletRequest request,String wechatId, String saasId, String patient, String familyMobile, Integer platform,Integer familyBindRole) throws Exception{
        BasePatientDO patientDO = patientService.findByIdAndDel(patient);
        //1、检验手机号码是否有存在账号，
@@ -106,8 +107,8 @@ public class MyFamilyService {
        BasePatientDO familyPatient = null;
        //3、生成申请绑定的记录，二维码
        PatientApplyLog patientApplyLog = createFamilyQrCode(request,familyPatient,wechatId,patient);
        //3、生成申请绑定的记录，申请绑定二维码
        PatientApplyLog patientApplyLog = createFamilyQrCode(request,familyPatient,wechatId,patient,familyBindRole);
        //4、发送绑定家人的系统消息
        BaseMessageDO messageDO = new BaseMessageDO();
        messageDO.setSaasId(saasId);
@@ -141,11 +142,11 @@ public class MyFamilyService {
     * @throws Exception
     */
    @Transactional(rollbackFor = Exception.class)
    public PatientApplyLog createFamilyQrCode(HttpServletRequest request,BasePatientDO familyPatient,String wechatId, String patient) throws Exception{
    public PatientApplyLog createFamilyQrCode(HttpServletRequest request,BasePatientDO familyPatient,String wechatId, String patient,Integer familyBindRole) throws Exception{
        BasePatientDO patientDO = patientService.findByIdAndDel(patient);
        PatientApplyLog patientApplyLog = new PatientApplyLog();
        patientApplyLog.setPatientFamilyMemberName(familyPatient.getName());
        patientApplyLog.setPatienyFamilyMemberCode(familyPatient.getId());
        patientApplyLog.setFamilyMemberName(familyPatient.getName());
        patientApplyLog.setFamilyMemberCode(familyPatient.getId());
        String scene ="family_"+familyPatient.getId()+"_"+familyPatient.getId();
        String qrCode = weChatQrcodeService.getQrcode(request,wechatId, scene);
        if(StringUtils.isEmpty(qrCode)){
@@ -159,6 +160,7 @@ public class MyFamilyService {
        patientApplyLog.setCreateTime(new Date());
        patientApplyLog.setCreateUser(familyPatient.getId());
        patientApplyLog.setCreateUserName(patientDO.getName());
        patientApplyLog.setFamilyBindRole(familyBindRole);
        patientApplyLogService.save(patientApplyLog);
        return patientApplyLog;
    }
@@ -177,7 +179,14 @@ public class MyFamilyService {
        }
    }
    public void confirmApply(Integer messageId,Integer patientApplyLogId){
    /**
     * 家人确认绑定
     * @param messageId
     * @param patientApplyLogId
     * @param status 1、添加家人（默认），2、邀请登录，3、通过，4、拒绝
     */
    @Transactional(rollbackFor = Exception.class)
    public void confirmApply(Integer messageId,Integer patientApplyLogId,Integer status,Integer isAuthorize){
        BaseMessageDO messageDO = null;
        if(messageId!=null){
@@ -192,9 +201,77 @@ public class MyFamilyService {
            messageService.save(messageDO);
        }
        PatientApplyLog patientApplyLog = patientApplyLogService.findById(patientApplyLogId);
        patientApplyLog.setStatus(status);
        patientApplyLog.setConfirmTime(new Date());
        patientApplyLogService.save(patientApplyLog);
        if(status==3){
            BasePatientFamilyMemberDO patientFamilyMember = new BasePatientFamilyMemberDO();
            patientFamilyMember.setPatient(patientApplyLog.getCreateUser());
            patientFamilyMember.setFamilyMember(patientApplyLog.getFamilyMemberCode());
            patientFamilyMember.setFamilyRelation(patientApplyLog.getFamilyBindRole());
            patientFamilyMember.setIsAuthorize(isAuthorize);
            patientFamilyMember.setDel(1);
            patientFamilyMemberService.save(patientFamilyMember);
        }
    }
    /**
     * 签约界面已绑定家人列表
     * @param patient
     * @return
     * @throws Exception
     */
    public List<Map<String,Object>> getBindingList(String patient) throws Exception{
        List<Map<String,Object>> resultList = new LinkedList<>();
        List<BasePatientFamilyMemberDO> list = patientFamilyMemberService.getByPatientAndFamilyMember(patient);
        String patientTemp = null;
        //自己
        BasePatientDO basePatientDO = patientService.findByIdAndDel(patient);
        Map<String,Object> map = new HashedMap();
        map.put("appellation","自己");//别称
        map.put("patientCode",patient);//居民code
        map.put("name",basePatientDO.getName());//姓名
        map.put("cardTypeName","身份证");
        map.put("idcard",basePatientDO.getIdcard());//身份证
        if(!StringUtils.isEmpty(basePatientDO.getPrincipalCode())){
            PatientMedicareCardDO patientMedicareCard = patientMedicareCardService.findByCode(basePatientDO.getPrincipalCode());
            map.put("principalNum",patientMedicareCard.getMedicareNumber());//社保卡号
        }else{
            map.put("principalNum","");//社保卡号
        }
        map.put("mobile",basePatientDO.getMobile());//手机号码
        resultList.add(map);
        //家人
        for(BasePatientFamilyMemberDO one:list){
            Map<String,Object> map2 = new HashedMap();
            if(patient.equals(one.getPatient())){
                patientTemp = one.getPatient();
            }else{
                patientTemp = one.getFamilyMember();
            }
            basePatientDO = patientService.findByIdAndDel(patientTemp);
            map2.put("appellation",basePatientDO.getName());//别称
            map2.put("patientCode",patientTemp);//居民code
            map2.put("name",basePatientDO.getName());//姓名
            map2.put("cardTypeName","身份证");
            map2.put("idcard",basePatientDO.getIdcard());//身份证
            if(!StringUtils.isEmpty(basePatientDO.getPrincipalCode())){
                PatientMedicareCardDO patientMedicareCard = patientMedicareCardService.findByCode(basePatientDO.getPrincipalCode());
                map2.put("principalNum",patientMedicareCard.getMedicareNumber());//社保卡号
            }else{
                map2.put("principalNum","");//社保卡号
            }
            map2.put("mobile",basePatientDO.getMobile());//手机号码
            resultList.add(map2);
        }
        return resultList;
    }
    /**
     * 家庭关系转换

svr/svr-patient/src/main/java/com/yihu/jw/patient/service/myFamily/PatientApplyLogService.java

@@ -24,4 +24,8 @@ public class PatientApplyLogService extends BaseJpaService<PatientApplyLog, Pati
    public int updateRemindTypeById(Integer remindType, Integer patientApplyLogId){
        return  patientApplyLogDao.updateRemindTypeById(remindType,patientApplyLogId);
    }
    public PatientApplyLog findById(Integer id){
        return  patientApplyLogDao.findById(id);
    }
}

svr/svr-patient/src/main/java/com/yihu/jw/patient/service/myFamily/PatientFamilyMemberService.java

@@ -1,8 +1,6 @@
package com.yihu.jw.patient.service.myFamily;
import com.yihu.jw.entity.base.patient.BasePatientDO;
import com.yihu.jw.entity.base.patient.BasePatientFamilyMemberDO;
import com.yihu.jw.patient.dao.BasePatientDao;
import com.yihu.jw.patient.dao.myFamily.PatientFamilyMemberDao;
import com.yihu.mysql.query.BaseJpaService;
import org.springframework.beans.factory.annotation.Autowired;
@@ -14,7 +12,7 @@ import java.util.List;
 * @author liuwenbin on 2018/11/27.
 */
@Service
public class PatientFamilyMemberService extends BaseJpaService<BasePatientDO, BasePatientDao> {
public class PatientFamilyMemberService extends BaseJpaService<BasePatientFamilyMemberDO, PatientFamilyMemberDao> {
    @Autowired
    private PatientFamilyMemberDao patientFamilyMemberDao;
@@ -50,4 +48,8 @@ public class PatientFamilyMemberService extends BaseJpaService<BasePatientDO, Ba
        return list;
    }
    public List<BasePatientFamilyMemberDO> getByPatientAndFamilyMember(String patient){
        return patientFamilyMemberDao.getByPatientAndFamilyMember(patient);
    }
}

svr/svr-patient/src/main/java/com/yihu/jw/patient/service/personal_Info/PatientService.java

@@ -6,6 +6,7 @@ import com.yihu.jw.entity.base.patient.BasePatientDO;
import com.yihu.jw.exception.business.patient.CapthcaInvalidException;
import com.yihu.jw.exception.business.patient.PatientNotFoundException;
import com.yihu.jw.file_upload.FileUploadService;
import com.yihu.jw.exception.business.patient.NotFoundPatientException;
import com.yihu.jw.patient.dao.BasePatientDao;
import com.yihu.jw.patient.service.BasePatientService;
import com.yihu.jw.patient.util.ConstantUtils;
@@ -154,6 +155,10 @@ public class PatientService extends BasePatientService<BasePatientDO, BasePatien
    public boolean existsByIdcard(String idcard){
        Preconditions.checkNotNull(idcard,"身份证不可为空");
        return basePatientDao.existsByIdcard(idcard);
    @Transactional(rollbackFor = Exception.class)
    public int updateOpenId(String id, String openId){
        return patientDao.updateOpenId(id,openId);
    }

svr/svr-patient/src/main/resources/bootstrap.yml

@@ -1,6 +1,6 @@
spring:
  application:
    name: svr-patient-lyx
    name: svr-patient
  cloud:
    config:
      failFast: true