111

controllers/dialysis_api_controller.go

 	remark := c.GetString("remark")
 	puncture_method := c.GetString("puncture_method")
 
-	dialysis_count, _ := c.GetInt64("dialysis_count", 0)
+	dialysis_count:= c.GetString("dialysis_count")
 	emergency_treatment, _ := c.GetInt64("emergency_treatment", 0)
 	emergency_treatment_other := c.GetString("emergency_treatment_other")
 	ductus_arantii := c.GetString("ductus_arantii")
 	ductus_arantii_other := c.GetString("ductus_arantii_other")
 	machine_type := c.GetString("machine_type")
 	puncture_needle := c.GetString("puncture_needle")
-	humor_excessive_symptom, _ := c.GetInt64("humor_excessive_symptom", 0)
+	humor_excessive_symptom := c.GetString("humor_excessive_symptom")
 	phinholing := c.GetString("pinholing")
 
 	catheter_suture := c.GetString("catheter_suture")

controllers/mobile_api_controllers/check_weight_api_controller.go

 	if len(sn) > 0 {
 		redis := service.RedisClient()
 		defer redis.Close()
-		redis.Set(sn, 0, 0)
+		redis.Set(redis.Context(),sn, 0, 0)
 	}
 	serviceTime := time.Now().Unix()
 	c.ServeSuccessJSON(map[string]interface{}{
 	redis := service.RedisClient()
 	defer redis.Close()
 	if len(sn) > 0 {
-		syncTimeStr, _ := redis.Get(sn).Result()
+		syncTimeStr, _ := redis.Get(redis.Context(),sn).Result()
 		syncTime, _ = strconv.ParseInt(syncTimeStr, 10, 64)
 	}
 
 	if ftype == 1 {
 		timeNow := time.Now().Unix()
-		redis.Set(sn, timeNow, 0)
+		redis.Set(redis.Context(),sn, timeNow, 0)
 	}
 
 	adminUserInfo := c.GetMobileAdminUserInfo()

controllers/mobile_api_controllers/dialysis_api_controller.go

 
 	// cur_date := time.Now().Format("2006-01-02")
 	key := "scheduals_" + schedualDate + "_" + strconv.FormatInt(orgID, 10)
-	scheduals_json_str, _ := redis.Get(key).Result()
+	scheduals_json_str, _ := redis.Get(redis.Context(),key).Result()
 
 	if len(scheduals_json_str) == 0 { //没有到缓存数据，从数据库中获取数据，进行缓存到redis
 		scheduals, err := service.MobileGetDialysisScheduals(orgID, date.Unix(), schedualType)
 				//缓存数据
 				scheduals_json, err := json.Marshal(scheduals)
 				if err == nil {
-					redis.Set(key, scheduals_json, time.Second*60)
+					redis.Set(redis.Context(),key, scheduals_json, time.Second*60)
 				}
 			}
 
 	// cur_date := time.Now().Format("2006-01-02")
 	key := "wait_scheduals_" + schedualDate + "_" + strconv.FormatInt(orgID, 10)
 
-	wait_scheduals, _ := redis.Get(key).Result()
+	wait_scheduals, _ := redis.Get(redis.Context(),key).Result()
 
 	if len(wait_scheduals) == 0 { //没有到缓存数据，从数据库中获取数据，进行缓存到redis
 		scheduals, err := service.MobileGetWaitingScheduals(orgID, date.Unix())
 				//缓存数据
 				wait_scheduals_json, err := json.Marshal(scheduals)
 				if err == nil {
-					redis.Set(key, wait_scheduals_json, time.Second*30)
+					redis.Set(redis.Context(),key, wait_scheduals_json, time.Second*30)
 				}
 			}
 
 		//缓存数据
 		scheduals_json, err := json.Marshal(scheduals)
 		if err == nil {
-			redis.Set(key, scheduals_json, time.Second*30)
+			redis.Set(redis.Context(),key, scheduals_json, time.Second*30)
 		}
 	}
 	this.ServeSuccessJSON(map[string]interface{}{

controllers/mobile_api_controllers/mobile_api_base_controller.go

 
 			//redis key值
 			key := "purviews_" + strconv.FormatInt(adminUserInfo.Org.Id, 10) + strconv.FormatInt(adminUserInfo.AdminUser.Id, 10)
-			purviews_json_str, _ := redis.Get(key).Result()
+			purviews_json_str, _ := redis.Get(redis.Context(),key).Result()
 			//获取该用户下所有角色的权限总集
 			var userRolePurviews string
 			var userRolePurviewsArr []string
 				//缓存数据
 				purview_json, err := json.Marshal(userRolePurviewsArr)
 				if err == nil {
-					redis.Set(key, purview_json, time.Minute*60*60*24)
+					redis.Set(redis.Context(),key, purview_json, time.Minute*60*60*24)
 				}
 			} else {
 				var dat []string

controllers/mobile_api_controllers/patient_api_controller.go

 
 	if dataBody["dialysis_count"] != nil && reflect.TypeOf(dataBody["dialysis_count"]).String() == "string" {
 		dialysis_count, _ := dataBody["dialysis_count"].(string)
-		count, _ := strconv.ParseInt(dialysis_count, 10, 64)
-		evaluation.DialysisCount = count
+		// count, _ := strconv.ParseInt(dialysis_count, 10, 64)
+		evaluation.DialysisCount = dialysis_count
 	}
 
 	if dataBody["is_infect"] != nil && reflect.TypeOf(dataBody["is_infect"]).String() == "string" {
 	}
 
 	if dataBody["humor_excessive_symptom"] != nil && reflect.TypeOf(dataBody["humor_excessive_symptom"]).String() == "float64" {
-		humor_excessive_symptom := int64(dataBody["humor_excessive_symptom"].(float64))
+		humor_excessive_symptom := dataBody["humor_excessive_symptom"].(string)
 		evaluation.HumorExcessiveSymptom = humor_excessive_symptom
 	}
 

controllers/mobile_api_controllers/qiniiu_api_controller.go

 	redisClient := service.RedisClient()
 	defer redisClient.Close()
 
-	token, err := redisClient.Get("qn_token").Result()
+	token, err := redisClient.Get(redisClient.Context(),"qn_token").Result()
 	if err != nil {
 		defer fmt.Println(err)
 		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeGetQiniuUpToken)

controllers/new_mobile_api_controllers/forget_password_controller.go

 		// 修改成功后验证码就要使其失效
 		redisClient := service.RedisClient()
 		defer redisClient.Close()
-		redisClient.Del("code_msg_" + mobile)
+		redisClient.Del(redisClient.Context(),"code_msg_" + mobile)
 
 		ip := utils.GetIP(this.Ctx.Request)
 		ssoDomain := beego.AppConfig.String("sso_domain")
 	}
 	redisClient := service.RedisClient()
 	defer redisClient.Close()
-	cache_code, _ := redisClient.Get("code_msg_" + mobile).Result()
+	cache_code, _ := redisClient.Get(redisClient.Context(),"code_msg_" + mobile).Result()
 	if cache_code != code {
 		return &enums.SGJError{Code: enums.ErrorCodeVerificationCodeWrong}
 	}

controllers/new_mobile_api_controllers/home_api_controller.go

 		// 修改成功后验证码就要使其失效
 		redisClient := service.RedisClient()
 		defer redisClient.Close()
-		redisClient.Del("code_msg_" + mobile)
+		redisClient.Del(redisClient.Context(),"code_msg_" + mobile)
 		this.ServeSuccessJSON(map[string]interface{}{
 			"admin": adminUser,
 		})
 	}
 	redisClient := service.RedisClient()
 	defer redisClient.Close()
-	cache_code, _ := redisClient.Get("code_msg_" + mobile).Result()
+	cache_code, _ := redisClient.Get(redisClient.Context(),"code_msg_" + mobile).Result()
 	if cache_code != code {
 		return &enums.SGJError{Code: enums.ErrorCodeVerificationCodeWrong}
 	}

controllers/new_mobile_api_controllers/mobile_regist_controller.go

 
 		redisClient := service.RedisClient()
 		defer redisClient.Close()
-		cache_code, _ := redisClient.Get("code_msg_" + mobile).Result()
+		cache_code, _ := redisClient.Get(redisClient.Context(),"code_msg_" + mobile).Result()
 		if cache_code != code {
 			//this.Data["json"] = enums.MakeFailResponseJSONWithSGJErrorCode(enums.ErrorCodeVerificationCodeWrong)
 			//this.ServeJSON()
 			this.Ctx.SetCookie("mobile", mobile)
 			this.SetSession("mobile_admin_user", admin)
 			// 注册成功后验证码就要使其失效
-			redisClient.Del("code_msg_" + mobile)
+			redisClient.Del(redisClient.Context(),"code_msg_" + mobile)
 
 			this.Data["json"] = enums.MakeSuccessResponseJSON(map[string]interface{}{
 				"result": true,

controllers/new_mobile_api_controllers/new_dialysis_api_controller.go

 	req := this.Ctx.Request
 	addr := utils.GetIP(req)
 	cur_time := time.Now().Format("2006-01-02")
-	_, err := redisClient.Get("ip:host_" + cur_time + "_" + addr).Result()
+	_, err := redisClient.Get(redisClient.Context(),"ip:host_" + cur_time + "_" + addr).Result()
 	if err != nil {
-		redisClient.Set("ip:host_"+cur_time+"_"+addr, 0, time.Second*24*60*60)
+		redisClient.Set(redisClient.Context(),"ip:host_"+cur_time+"_"+addr, 0, time.Second*24*60*60)
 	}
 	//将客户端的ip加密传给前端，作为短信验证的密钥，来验证短信发送的IP地址
 	aespass := utils.AESEncrypt(addr)

controllers/new_mobile_api_controllers/new_login_api_controller.go

 	req := this.Ctx.Request
 	addr := utils.GetIP(req)
 	cur_time := time.Now().Format("2006-01-02")
-	_, err := redisClient.Get("ip:host_" + cur_time + "_" + addr).Result()
+	_, err := redisClient.Get(redisClient.Context(),"ip:host_" + cur_time + "_" + addr).Result()
 	if err != nil {
-		redisClient.Set("ip:host_"+cur_time+"_"+addr, 0, time.Second*24*60*60)
+		redisClient.Set(redisClient.Context(),"ip:host_"+cur_time+"_"+addr, 0, time.Second*24*60*60)
 	}
 	//将客户端的ip加密传给前端，作为短信验证的密钥，来验证短信发送的IP地址
 	aespass := utils.AESEncrypt(addr)
 
 		redisClient := service.RedisClient()
 		defer redisClient.Close()
-		cachedCode, err := redisClient.Get("code_msg_" + mobile).Result()
+		cachedCode, err := redisClient.Get(redisClient.Context(),"code_msg_" + mobile).Result()
 
 		if err != nil {
 			this.Data["json"] = enums.MakeFailResponseJSONWithSGJErrorCode(enums.ErrorCodeAccountOrVerCodeWrong)
 						TemplateInfo: &templateInfo,
 					}
 					this.SetSession("mobile_admin_user_info", mobileAdminUserInfo)
-					redisClient.Del("code_msg_" + mobile)
+					redisClient.Del(redisClient.Context(),"code_msg_" + mobile)
 
 					mobile = mobile + "-" + strconv.FormatInt(org.Id, 10) + "-" + strconv.FormatInt(appRole.Id, 10)
 					token := utils.GenerateLoginToken(mobile)

controllers/new_mobile_api_controllers/new_role_api_controller.go

 	users := service.GetAllUserRole(adminUser.Org.Id)
 	for _, item := range users {
 		key := "purviews_" + strconv.FormatInt(adminUser.Org.Id, 10) + strconv.FormatInt(item.AdminUserId, 10)
-		redis.Set(key, "", time.Second)
+		redis.Set(redis.Context(),key, "", time.Second)
 	}
 
 	if err != nil {

controllers/patient_api_controller.go

 
 	redis := service.RedisClient()
 	defer redis.Close()
-	redis.SAdd("sgj_patient:new_user_set", patient.UserId)
+	redis.SAdd(redis.Context(),"sgj_patient:new_user_set", patient.UserId)
 
 	c.ServeSuccessJSON(map[string]interface{}{
 		"msg": "ok",

controllers/qiniiu_api_controller.go

 	redisClient := service.RedisClient()
 	defer redisClient.Close()
 
-	token, err := redisClient.Get("qn_token").Result()
+	token, err := redisClient.Get(redisClient.Context(),"qn_token").Result()
 	fmt.Print("token------------------------------------", token)
 	if err != nil {
 		defer fmt.Println(err)

controllers/role_controller.go

 	users := service.GetAllUserRole(adminUserInfo.CurrentOrgId)
 	for _, item := range users {
 		key := "purviews_" + strconv.FormatInt(adminUserInfo.CurrentOrgId, 10) + strconv.FormatInt(item.AdminUserId, 10)
-		redis.Set(key, "", time.Second)
+		redis.Set(redis.Context(),key, "", time.Second)
 	}
 
 	err := service.SaveRolePurviewIds(adminUserInfo.CurrentOrgId, adminUserInfo.CurrentAppId, roleId, purviewIds)
 
 	redisClient := service.RedisClient()
 	defer redisClient.Close()
-	qntoken, _ := redisClient.Get("qn_token").Result()
+	qntoken, _ := redisClient.Get(redisClient.Context(),"qn_token").Result()
 
 	this.ServeSuccessJSON(map[string]interface{}{
 		"roles":           roles,
 
 	redisClient := service.RedisClient()
 	defer redisClient.Close()
-	qntoken, _ := redisClient.Get("qn_token").Result()
+	qntoken, _ := redisClient.Get(redisClient.Context(),"qn_token").Result()
 
 	this.ServeSuccessJSON(map[string]interface{}{
 		"admin":           appRole,

controllers/schedule_api_controller.go

 	err = service.CreateSchedule(&schedule)
 
 	key := "scheduals_" + scheduleDate + "_" + strconv.FormatInt(adminUserInfo.CurrentOrgId, 10)
-	redis.Set(key, "", time.Second)
+	redis.Set(redis.Context(),key, "", time.Second)
 
 	fmt.Println(err)
 	if err != nil {

controllers/verify_login_controller.go

 
 	redisClient := service.RedisClient()
 	defer redisClient.Close()
-	cachedCode, err := redisClient.Get("xt_modify_pwd_" + mobile).Result()
+	cachedCode, err := redisClient.Get(redisClient.Context(),"xt_modify_pwd_" + mobile).Result()
 	if err != nil {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeAccountOrVerCodeWrong)
 		return
 	}
 
 	// 清除验证码
-	redisClient.Del("xt_modify_pwd_" + mobile)
+	redisClient.Del(redisClient.Context(),"xt_modify_pwd_" + mobile)
 	this.ServeSuccessJSON(map[string]interface{}{
 		"msg": "密码已修改",
 	})

controllers/xcx_mobile_api_controller.go/xcx_api_controller.go

 	//获取验证码
 	beego.Router("/xcx/api/mobile/code", &XcxApiController{}, "Get:GetCodeInfo")
 	//用户绑定
-	beego.Router("/xcx/api/mobile/register", &XcxApiController{}, "Get:GetUserRegister")
+	beego.Router("/xcx/api/mobile/register", &XcxApiController{}, "Get:GetUserNameRegister")
 	//登录
 	beego.Router("/xcx/api/mobile/login", &XcxApiController{}, "Get:GetLoginInfor")
 
 	req := this.Ctx.Request
 	addr := utils.GetIP(req)
 	cur_time := time.Now().Format("2006-01-02")
-	_, err := redisClient.Get("ip:host_" + cur_time + "_" + addr).Result()
+	_, err := redisClient.Get(redisClient.Context(),"ip:host_" + cur_time + "_" + addr).Result()
 	if err != nil {
-		redisClient.Set("ip:host_"+cur_time+"_"+addr, 0, time.Second*24*60*60)
+		redisClient.Set(redisClient.Context(),"ip:host_"+cur_time+"_"+addr, 0, time.Second*24*60*60)
 	}
 	//将客户端的ip加密传给前端，作为短信验证的密钥，来验证短信发送的IP地址
 	aespass := utils.AESEncrypt(addr)
 
 }
 
+func (this *XcxApiController) GetUserNameRegister() {
+	name := this.GetString("name")
+	id_card_no := this.GetString("id_card_no")
+	mobile := this.GetString("mobile")
+	patient, errcodes := service.GetNamePatient(name, id_card_no)
+	if errcodes == nil {
+		role := models.XcxAdminUserRole{
+			PatientName: name,
+			IdCardNo:    id_card_no,
+			Mobile:      mobile,
+			Code:        "000000",
+			PatientId:   patient.ID,
+			UserOrgId:   patient.UserOrgId,
+			Status:      1,
+			Ctime:       time.Now().Unix(),
+			Mtime:       0,
+			Appid:       "",
+			Appsecret:   "",
+			SessionKey:  "",
+		}
+		err := service.CreateXcxAdminUser(role)
+		if err == nil {
+			mobilePatient, _ := service.GetNamePatient(name, id_card_no)
+			template_id, _ := service.GetTemplateMode(mobilePatient.UserOrgId)
+				//处方
+			prescripition_config, _ := service.GetPrescripionFieldConfig(mobilePatient.UserOrgId)
+
+				//接诊评估
+			receive_treatement_config, _ := service.GetReceiveTreatmentAssess(mobilePatient.UserOrgId)
+
+				//透前评估
+			dialysis_befor, _ := service.GetDialysisBefor(mobilePatient.UserOrgId)
+
+				//透析上机
+			dialysis_order, _ := service.GetDialysisOrderConfig(mobilePatient.UserOrgId)
+
+				//透析监测
+			monitor_record, _ := service.GetMonitorRecordConfig(mobilePatient.UserOrgId)
+
+				//透后评估
+			dialysis_after, _ := service.GetDialysisAfeterConfig(mobilePatient.UserOrgId)
+
+			treate_ment, _ := service.GetTreatMentConfig(mobilePatient.UserOrgId)
+			var configList interface{}
+			configList, _ = service.GetConfigList(mobilePatient.UserOrgId)
+			this.ServeSuccessJSON(map[string]interface{}{
+					"role":                      role,
+					"is_bind":                   true,
+					"patient":                   mobilePatient,
+					"template_id":               template_id,
+					"user_org_id":               mobilePatient.UserOrgId,
+					"prescripition_config":      prescripition_config,
+					"receive_treatement_config": receive_treatement_config,
+					"dialysis_befor":            dialysis_befor,
+					"dialysis_order":            dialysis_order,
+					"monitor_record":            monitor_record,
+					"dialysis_after":            dialysis_after,
+					"treate_ment":               treate_ment,
+					"configList":                configList,
+					"result":                    false,
+			})
+		} else {
+			this.ServeSuccessJSON(map[string]interface{}{
+				"is_bind": false,
+				"msg":     "绑定失败",
+				"result":  false,
+			})
+		}
+	} else {
+		this.ServeSuccessJSON(map[string]interface{}{
+			"is_bind": false,
+			"msg":     "绑定失败",
+			"result":  false,
+		})
+	}
+}
+
 func (this *XcxApiController) GetUserRegister() {
 
 	//用户绑定
 	} else {
 		redisClient := service.RedisClient()
 		defer redisClient.Close()
-		cache_code, _ := redisClient.Get("code_msg_" + mobile).Result()
+		cache_code, _ := redisClient.Get(redisClient.Context(),"code_msg_" + mobile).Result()
 		fmt.Println("cache_code9999999293323232322323", cache_code)
 		if cache_code != code {
 			this.ServeSuccessJSON(map[string]interface{}{
 		} else {
 			this.Ctx.SetCookie("mobile", mobile)
 			// 注册成功后验证码就要使其失效
-			redisClient.Del("code_msg_" + mobile)
+			redisClient.Del(redisClient.Context(),"code_msg_" + mobile)
 			patient, errcodes := service.GetMobilePatient(mobile, id_card_no)
 			fmt.Println("errcodes2323232232", errcodes)
 			if errcodes == nil {

main.go

 }
 
 func main() {
-	//service.BeginAutoCreateWeekSchedulesJob()
-	//service.BeginAutoCreateWeekDisinfectionJob()
-	//service.BeginAutoCreatePlanJob()
-	//service.AutoClearSchedules()
-	//service.BeginAutoCreateStaffScheduleJob()
 	beego.BConfig.WebConfig.Session.SessionGCMaxLifetime = 60
 	beego.Run()
 }

models/dialysis.go

 	DuctusArantii                  string  `gorm:"column:ductus_arantii" json:"ductus_arantii"`
 	EmergencyTreatment             int64   `gorm:"column:emergency_treatment" json:"emergency_treatment"`
 	EmergencyTreatmentOther        string  `gorm:"column:emergency_treatment_other" json:"emergency_treatment_other"`
-	DialysisCount                  int64   `gorm:"column:dialysis_count" json:"dialysis_count"`
+	DialysisCount                  string   `gorm:"column:dialysis_count" json:"dialysis_count"`
 	AssessmentDoctor               int64   `gorm:"column:assessment_doctor" json:"assessment_doctor"`
 	AssessmentTime                 int64   `gorm:"column:assessment_time" json:"assessment_time"`
 	MachineType                    string  `gorm:"column:machine_type" json:"machine_type"`
 	LastPostDialysisOther          string  `gorm:"column:last_post_dialysis_other" json:"last_post_dialysis_other"`
 	SymptomBeforeDialysisOther     string  `gorm:"column:symptom_before_dialysis_other" json:"symptom_before_dialysis_other"`
 	DialysisInterphaseOther        string  `gorm:"column:dialysis_interphase_other" json:"dialysis_interphase_other"`
-	HumorExcessiveSymptom          int64   `gorm:"column:humor_excessive_symptom" json:"humor_excessive_symptom"`
+	HumorExcessiveSymptom          string   `gorm:"column:humor_excessive_symptom" json:"humor_excessive_symptom"`
 	Phinholing                     string  `gorm:"column:pinholing" json:"pinholing" form:"pinholing"`
 	CatheterSuture                 string  `gorm:"column:catheter_suture" json:"catheter_suture" form:"catheter_suture"`
 	CatheterSutureOther            string  `gorm:"column:catheter_suture_other" json:"catheter_suture_other" form:"catheter_suture_other"`

service/auto_create_stock.go

 	//spec := "0 55 23 * * ?" // 每天23点55执行一次
 	//spec := "0 0 0 ? * Sun"
 	createStockCronJob.AddFunc(spec, func() {
+		utils.InfoLog("开启自动更新耗材库存定时任务1111111111111")
 		AutoCreateStockJob()
 	})
 }

service/new_sms_service.go

 		redisClient := RedisClient()
 		defer redisClient.Close()
 		cur_date := time.Now().Format("2006-01-02")
-		redisClient.Set("code_msg_"+mobile, code_str, time.Minute*10)
-		redisClient.Incr("code_msg_" + mobile + "_" + cur_date).Result()
+		redisClient.Set(redisClient.Context(),"code_msg_"+mobile, code_str, time.Minute*10)
+		redisClient.Incr(redisClient.Context(),"code_msg_" + mobile + "_" + cur_date).Result()
 		// 取出地址信息，因为上面已经验证过，这里就直接解密而不做错误判断了
 		bytesPass, _ := base64.StdEncoding.DecodeString(aespass)
 		tpass := utils.AESDecrypt(bytesPass)
-		redisClient.Incr("ip:host_" + cur_date + "_" + tpass).Result()
+		redisClient.Incr(redisClient.Context(),"ip:host_" + cur_date + "_" + tpass).Result()
 	}
 	return err
 }
 	}
 
 	cur_date := time.Now().Format("2006-01-02")
-	add_redis, err := redisClient.Get("ip:host_" + cur_date + "_" + tpass).Result()
+	add_redis, err := redisClient.Get(redisClient.Context(),"ip:host_" + cur_date + "_" + tpass).Result()
 	if err != nil {
 		return &SMSServiceError{Err: "缺少关键参数"}
 	}
 		return &SMSServiceError{Err: "当前IP发送短信超过限制"}
 	}
 
-	moblie_count, _ := redisClient.Get("code_msg_" + mobile + "_" + cur_date).Result()
+	moblie_count, _ := redisClient.Get(redisClient.Context(),"code_msg_" + mobile + "_" + cur_date).Result()
 	moblie_count_int, _ := strconv.Atoi(moblie_count)
 	if moblie_max, _ := beego.AppConfig.Int("moblie_max_send_count"); moblie_count_int >= moblie_max {
 		return &SMSServiceError{Err: "当前手机号发送短信超过限制"}

service/redis.go

 		Password: beego.AppConfig.String("redispasswrod"), // no password set
 		DB:       0,                                       // use default DB
 	})
-	pong, err := client.Ping().Result()
+	pong, err := client.Ping(client.Context()).Result() 
 	fmt.Println(pong, err)
 	return client
 }

service/sms_service.go

 		redisClient := RedisClient()
 		defer redisClient.Close()
 		cur_date := time.Now().Format("2006-01-02")
-		redisClient.Set("xt_modify_pwd_"+mobile, code_str, time.Minute*10)
-		redisClient.Incr("xt_modify_pwd_" + mobile + "_" + cur_date).Result()
+		redisClient.Set(redisClient.Context(),"xt_modify_pwd_"+mobile, code_str, time.Minute*10)
+		redisClient.Incr(redisClient.Context(),"xt_modify_pwd_" + mobile + "_" + cur_date).Result()
 	}
 	return err
 }
 	defer redisClient.Close()
 
 	cur_date := time.Now().Format("2006-01-02")
-	moblie_count, _ := redisClient.Get("xt_modify_pwd_" + mobile + "_" + cur_date).Result()
+	moblie_count, _ := redisClient.Get(redisClient.Context(),"xt_modify_pwd_" + mobile + "_" + cur_date).Result()
 	moblie_count_int, _ := strconv.Atoi(moblie_count)
 	if moblie_max := 5; moblie_count_int >= moblie_max {
 		return &SMSServiceError{Err: "当前手机号发送短信超过限制"}

service/xcx_mobile_api_service.go

 	"github.com/jinzhu/gorm"
 	"net/http"
 	"time"
-	"net/http"
 )
 
 func GetXcxMobileInformation(mobile string) (*models.XcxAdminUserRole, error) {
 
 }
 
+func GetNamePatient(name string, idcard string) (*models.XcxPatients, error) {
+
+	patient := models.XcxPatients{}
+	err := XTReadDB().Model(&patient).Where("name = ? and id_card_no =?", name, idcard).Find(&patient).Error
+	//err := XTReadDB().Model(&patient).Where("id_card_no = ? and status = 1", mobile).Find(&patient).Error
+	if err == gorm.ErrRecordNotFound {
+		return nil, err
+	}
+
+	if err != nil {
+		return nil, err
+	}
+	return &patient, nil
+
+}
+
 func GetTemplateMode(orgid int64) (models.XcxGobalTemplate, error) {
 
 	template := models.XcxGobalTemplate{}