历史排班

controllers/mobile_api_controllers/dialysis_api_controller.go

 	for _, adviceNameMap := range adviceNames {
 		adviceNameM := adviceNameMap.(map[string]interface{})
 		var advice models.GroupAdvice
+
 		advice.Remark = Remark
 		advice.AdviceType = adviceType
+
 		advice.StartTime = StartTime
+
 		advice.AdviceDate = AdviceDate
 
 		advice.RecordDate = RecordDate
 			advice.DrugNameId = drug_name_id
 		}
 
+		if adviceNameM["groupno"] != nil || reflect.TypeOf(adviceNameM["groupno"]).String() == "float64" {
+			groupno := int64(adviceNameM["groupno"].(float64))
+			advice.GroupNo = groupno
+		}
+
 		if adviceNameM["template_id"] != nil && reflect.TypeOf(adviceNameM["template_id"]).String() == "string" {
 			template_id, _ := adviceNameM["template_id"].(string)
 			advice.TemplateId = template_id
 						child.PrescribingNumberUnit = childPrescribingNumberUnit
 					}
 
+					if childMap["groupno"] != nil || reflect.TypeOf(childMap["groupno"]).String() == "float64" {
+						groupno := int64(childMap["groupno"].(float64))
+						advice.GroupNo = groupno
+					}
+
 					child.DeliveryWay = advice.DeliveryWay
 					child.ExecutionFrequency = advice.ExecutionFrequency
 					advice.Children = append(advice.Children, &child)
 			PatientId:  patient,
 		}
 
-		dialysisFinish, err := service.GetDialysisFinish(adminUserInfo.Org.Id, AdviceDate, 4, patient)
+		dialysisFinish, _ := service.GetDialysisFinish(adminUserInfo.Org.Id, AdviceDate, 4, patient)
 		if dialysisFinish.ID == 0 {
 			service.CreateDialysisFinish(finish)
 		}
 
-		list, err := service.CreateMGroupAdvice(adminUserInfo.Org.Id, advices, groupNo)
+		if adminUserInfo.Org.Id == 10597 || adminUserInfo.Org.Id == 3877 || adminUserInfo.Org.Id == 10164 {
+			list, err := service.CreateMGroupAdviceOne(adminUserInfo.Org.Id, advices, groupNo)
+			for _, item := range advices {
+				byterequest, _ := json.Marshal(item)
+				adviceLog := models.XtDoctorAdviceLog{
+					UserOrgId:   adminUserInfo.Org.Id,
+					PatientId:   patient,
+					AdminUserId: adminUserInfo.AdminUser.Id,
+					Module:      1,
+					ErrLog:      string(byterequest),
+					Status:      1,
+					Ctime:       time.Now().Unix(),
+					Mtime:       0,
+					Source:      "手机端医嘱推送",
+					RecordDate:  item.AdviceDate,
+				}
 
-		for _, item := range advices {
-			byterequest, _ := json.Marshal(item)
-			adviceLog := models.XtDoctorAdviceLog{
-				UserOrgId:   adminUserInfo.Org.Id,
-				PatientId:   patient,
-				AdminUserId: adminUserInfo.AdminUser.Id,
-				Module:      1,
-				ErrLog:      string(byterequest),
-				Status:      1,
-				Ctime:       time.Now().Unix(),
-				Mtime:       0,
-				Source:      "手机端医嘱推送",
-				RecordDate:  item.AdviceDate,
+				service.CreateDoctorAdviceLog(adviceLog)
 			}
 
-			service.CreateDoctorAdviceLog(adviceLog)
-		}
+			key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(RecordDate, 10) + ":doctor_advices"
+			redis := service.RedisClient()
+			//清空key 值
+			redis.Set(key, "", time.Second)
 
-		key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(RecordDate, 10) + ":doctor_advices"
-		redis := service.RedisClient()
-		//清空key 值
-		redis.Set(key, "", time.Second)
+			keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(AdviceDate, 10) + ":advice_list_all"
+			redis.Set(keyOne, "", time.Second)
 
-		keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(AdviceDate, 10) + ":advice_list_all"
-		redis.Set(keyOne, "", time.Second)
+			keyThree := "scheduals_" + adviceDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
+			defer redis.Close()
+			redis.Set(keyThree, "", time.Second)
+			if err != nil {
+				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateDoctorAdviceFail)
+				return
+			}
 
-		keyThree := "scheduals_" + adviceDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
-		defer redis.Close()
-		redis.Set(keyThree, "", time.Second)
-		if err != nil {
-			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateDoctorAdviceFail)
-			return
-		}
+			c.ServeSuccessJSON(map[string]interface{}{
+				"msg":     "ok",
+				"advices": list,
+			})
+		} else {
+			list, err := service.CreateMGroupAdvice(adminUserInfo.Org.Id, advices, groupNo)
+			for _, item := range advices {
+				byterequest, _ := json.Marshal(item)
+				adviceLog := models.XtDoctorAdviceLog{
+					UserOrgId:   adminUserInfo.Org.Id,
+					PatientId:   patient,
+					AdminUserId: adminUserInfo.AdminUser.Id,
+					Module:      1,
+					ErrLog:      string(byterequest),
+					Status:      1,
+					Ctime:       time.Now().Unix(),
+					Mtime:       0,
+					Source:      "手机端医嘱推送",
+					RecordDate:  item.AdviceDate,
+				}
 
-		c.ServeSuccessJSON(map[string]interface{}{
-			"msg":     "ok",
-			"advices": list,
-		})
+				service.CreateDoctorAdviceLog(adviceLog)
+			}
+
+			key := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(patient, 10) + ":" + strconv.FormatInt(RecordDate, 10) + ":doctor_advices"
+			redis := service.RedisClient()
+			//清空key 值
+			redis.Set(key, "", time.Second)
+
+			keyOne := strconv.FormatInt(adminUserInfo.Org.Id, 10) + ":" + strconv.FormatInt(AdviceDate, 10) + ":advice_list_all"
+			redis.Set(keyOne, "", time.Second)
+
+			keyThree := "scheduals_" + adviceDate + "_" + strconv.FormatInt(adminUserInfo.Org.Id, 10)
+			defer redis.Close()
+			redis.Set(keyThree, "", time.Second)
+			if err != nil {
+				c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeCreateDoctorAdviceFail)
+				return
+			}
+
+			c.ServeSuccessJSON(map[string]interface{}{
+				"msg":     "ok",
+				"advices": list,
+			})
+		}
 
 	} else {
 		c.ServeSuccessJSON(map[string]interface{}{
 
 	end_time := c.GetString("end_time")
 
-	fmt.Println("start_timeo2o2o2o2o2o", start_time)
-	fmt.Println("end_Time2o2o2o2ooo22", end_time)
 	var startdateunix int64
 	if len(start_time) > 0 {
 		theTime, err := time.ParseInLocation(timeLayout+" 15:04:05", start_time+" 00:00:00", loc)
-		fmt.Println("theTim3333333333333333333333e", theTime)
 		if err != nil {
 			c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
 			return
 
 	org_id := c.GetMobileAdminUserInfo().Org.Id
 
-	if org_id == 10579 {
-		list, _ := service.GetPatientDialysisRecordListOne(id, startdateunix, enddateunix)
+	//if org_id == 10579 {
+	//	list, _ := service.GetPatientDialysisRecordListOne(id, startdateunix, enddateunix)
+	//	c.ServeSuccessJSON(map[string]interface{}{
+	//		"list": list,
+	//	})
+	//	return
+	//} else {
+	//	list, _ := service.GetPatientDialysisRecordList(id, startdateunix, enddateunix)
+	//	c.ServeSuccessJSON(map[string]interface{}{
+	//		"list": list,
+	//	})
+	//	return
+	//}
+	if org_id == 9538 || org_id == 10101 {
+		list, _ := service.GetPatientDialysisRecordList(id, startdateunix, enddateunix)
 		c.ServeSuccessJSON(map[string]interface{}{
 			"list": list,
 		})
 		return
 	} else {
-		list, _ := service.GetPatientDialysisRecordList(id, startdateunix, enddateunix)
+		list, _ := service.GetPatientDialysisRecordListOne(id, startdateunix, enddateunix)
 		c.ServeSuccessJSON(map[string]interface{}{
 			"list": list,
 		})
-		return
 	}
 
+	return
+
 }
 
 func (c *DialysisAPIController) BathDeleteAdviceList() {

controllers/sign_api_controller.go

 
 	beego.Router("/api/device/toautodiagnose", &SignApiController{}, "Get:ToAutoDiagnose")
 
+	//加油
+	beego.Router("/api/device/toautojiayou", &SignApiController{}, "Get:ToAutoJiaYou")
+
 }
 
 // 短信服务接口
 
 func (this *SignApiController) UploadPrintOrder() {
 
-	list, _ := service.GetAllPatientNew(10567)
+	list, _ := service.GetAllPatientNew(10440)
 	for _, item := range list {
 
 		hans := item.Name // 要转换的汉字字符串
 	//})
 
 }
+
+func (this *SignApiController) ToAutoJiaYou() {
+
+	list, _ := service.GetPrescriptionListOne(10579)
+
+	for _, item := range list {
+
+		schedule, _ := service.GetPatientScheduleById(item.PatientId, item.RecordDate)
+		var DialysisMachineName string
+		if len(item.DialysisDialyszers) > 0 {
+			DialysisMachineName = item.DialysisDialyszers
+		}
+
+		if len(item.DialysisIrrigation) > 0 {
+			DialysisMachineName = DialysisMachineName + "," + item.DialysisIrrigation
+		}
+
+		if len(item.DialysisStrainer) > 0 {
+			DialysisMachineName = DialysisMachineName + "," + item.DialysisStrainer
+		}
+		DialysisMachineName = DialysisMachineName
+
+		service.UpdateDialysisScheduleOne(schedule.ID, item.ModeId, DialysisMachineName)
+	}
+}

models/dialysis_parameter_models.go

 	EpoCount                   float64 `gorm:"column:epo_count" json:"epo_count" form:"epo_count"`
 	DialysisDialyszers         string  `gorm:"column:dialysis_dialyszers" json:"dialysis_dialyszers" form:"dialysis_dialyszers"`
 	DialysisIrrigation         string  `gorm:"column:dialysis_irrigation" json:"dialysis_irrigation" form:"dialysis_irrigation"`
+	DialysisStrainer           string  `gorm:"column:dialysis_strainer" json:"dialysis_strainer" form:"dialysis_strainer"`
 }
 
 func (DialysisPrescriptionParameter) TableName() string {

models/patient_models.go

 	ModeId                     int64                 `gorm:"column:mode_id" json:"mode_id" form:"mode_id"`
 	Anticoagulant              int64                 `gorm:"column:anticoagulant" json:"anticoagulant" form:"anticoagulant"`
 	DialysisSolution           VmDialysisSolutionOne `gorm:"ForeignKey:PatientId,ModeId;AssociationForeignKey:PatientId,ModeId" json:"solution"`
+	SolutionStatus             int64                 `gorm:"column:solution_status" json:"solution_status" form:"solution_status"`
 }
 
 func (VmDialysisSolution) TableName() string {
 }
 
 type XtScheduleList struct {
-	UserOrgId        int64              `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
-	PartitionId      int64              `gorm:"column:partition_id" json:"partition_id" form:"partition_id"`
-	BedId            int64              `gorm:"column:bed_id" json:"bed_id" form:"bed_id"`
-	PatientId        int64              `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
-	ScheduleDate     int64              `gorm:"column:schedule_date" json:"schedule_date" form:"schedule_date"`
-	ScheduleType     int64              `gorm:"column:schedule_type" json:"schedule_type" form:"schedule_type"`
-	ScheduleWeek     int64              `gorm:"column:schedule_week" json:"schedule_week" form:"schedule_week"`
-	ModeId           int64              `gorm:"column:mode_id" json:"mode_id" form:"mode_id"`
-	IsExport         int64              `gorm:"column:is_export" json:"is_export" form:"is_export"`
-	DialysisSolution VmDialysisSolution `gorm:"ForeignKey:PatientId,ModeId;AssociationForeignKey:PatientId,ModeId" json:"vmsolution"`
-	Status           int64              `gorm:"column:status" json:"status" form:"status"`
+	UserOrgId            int64                `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	PartitionId          int64                `gorm:"column:partition_id" json:"partition_id" form:"partition_id"`
+	BedId                int64                `gorm:"column:bed_id" json:"bed_id" form:"bed_id"`
+	PatientId            int64                `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
+	ScheduleDate         int64                `gorm:"column:schedule_date" json:"schedule_date" form:"schedule_date"`
+	ScheduleType         int64                `gorm:"column:schedule_type" json:"schedule_type" form:"schedule_type"`
+	ScheduleWeek         int64                `gorm:"column:schedule_week" json:"schedule_week" form:"schedule_week"`
+	ModeId               int64                `gorm:"column:mode_id" json:"mode_id" form:"mode_id"`
+	IsExport             int64                `gorm:"column:is_export" json:"is_export" form:"is_export"`
+	DialysisSolution     VmDialysisSolution   `gorm:"ForeignKey:PatientId,ModeId;AssociationForeignKey:PatientId,ModeId" json:"vmsolution"`
+	DialysisPrescription DialysisPrescription `gorm:"ForeignKey:PatientId,RecordDate;AssociationForeignKey:PatientId,ScheduleDate" json:"prescription"`
+	Status               int64                `gorm:"column:status" json:"status" form:"status"`
 }
 
 func (XtScheduleList) TableName() string {

models/schedule_models.go

 	ReceiveTreatmentAsses      ReceiveTreatmentAsses      `gorm:"ForeignKey:PatientId,RecordDate;AssociationForeignKey:PatientId,ScheduleDate" json:"xt_receive_treatment_asses"`
 	XtAssessmentAfterDislysis  XtAssessmentAfterDislysis  `gorm:"ForeignKey:PatientId,AssessmentDate;AssociationForeignKey:PatientId,ScheduleDate" json:"xt_assesment_after_dislysis"`
 	LastAfterWeight            AssessmentAfterDislysis    `gorm:"ForeignKey:PatientID;AssociationForeignKey:PatientID" json:"lastafterweight"`
+	DialysisMachineName        string                     `gorm:"column:dialysis_machine_name" json:"dialysis_machine_name" form:"dialysis_machine_name"`
 }
 
 func (VmBloodSchedule) TableName() string {

service/gobal_config_service.go

 	if end_time > 0 {
 		db = db.Where("schedule_date<=?", end_time)
 	}
-	err = db.Preload("DialysisSolution", "status=1 and user_org_id =?", org_id).Find(&schedulelist).Error
+	err = db.Preload("DialysisSolution", "status=1 and user_org_id =? and solution_status =1", org_id).Preload("DialysisPrescription", "status=1 and user_org_id =?", org_id).Find(&schedulelist).Error
 
 	return schedulelist, err
 

service/mobile_dialysis_service.go

 
 	// cur_date := time.Now().Format("2006-01-02")
 	key := strconv.FormatInt(orgID, 10) + ":" + strconv.FormatInt(patientID, 10) + ":" + strconv.FormatInt(mode_id, 10) + ":dialysis_solution"
+
 	dialysis_solution_str, _ := redis.Get(key).Result()
 
 	if len(dialysis_solution_str) == 0 { //没有到缓存数据，从数据库中获取数据，进行缓存到redis

service/patient_service.go

 
 	}
 	if lapseto != 2 && lapseto != 3 {
-		if orgID != 10579 {
+		if orgID != 10579 && orgID != 10600 {
 			err = db.Order("p.id desc").Select(" p.id, p.user_org_id, p.user_id, p.patient_type, p.dialysis_no, p.admission_number, p.source, p.lapseto, p.partition_id, p.bed_id, p.name, p.alias, p.gender, p.marital_status, p.id_card_no, p.birthday, p.reimbursement_way_id, p.health_care_type, p.health_care_no, p.health_care_due_date, p.height, p.blood_type, p.rh, p.health_care_due_alert_date, p.education_level, p.profession, p.phone, p.home_telephone, p.relative_phone, p.relative_relations, p.home_address, p.work_unit, p.unit_address, p.children, p.receiving_date, p.is_hospital_first_dialysis, p.first_dialysis_date, p.first_dialysis_hospital, p.induction_period, p.initial_dialysis, p.total_dialysis, p.attending_doctor_id, p.head_nurse_id, p.evaluate, p.diagnose, p.remark, p.registrars_id, p.registrars, p.qr_code, p.binding_state, p.status, p.created_time, p.updated_time,p.user_sys_before_count,p.out_reason,p.death_time,p.is_infectious").Group("p.id").Count(&total).Offset(offset).Limit(limit).Find(&patients).Error
 		}
 
-		if orgID == 10579 {
+		if orgID == 10579 || orgID == 10600 {
 			err = db.Order("p.dialysis_no asc").Select(" p.id, p.user_org_id, p.user_id, p.patient_type, p.dialysis_no, p.admission_number, p.source, p.lapseto, p.partition_id, p.bed_id, p.name, p.alias, p.gender, p.marital_status, p.id_card_no, p.birthday, p.reimbursement_way_id, p.health_care_type, p.health_care_no, p.health_care_due_date, p.height, p.blood_type, p.rh, p.health_care_due_alert_date, p.education_level, p.profession, p.phone, p.home_telephone, p.relative_phone, p.relative_relations, p.home_address, p.work_unit, p.unit_address, p.children, p.receiving_date, p.is_hospital_first_dialysis, p.first_dialysis_date, p.first_dialysis_hospital, p.induction_period, p.initial_dialysis, p.total_dialysis, p.attending_doctor_id, p.head_nurse_id, p.evaluate, p.diagnose, p.remark, p.registrars_id, p.registrars, p.qr_code, p.binding_state, p.status, p.created_time, p.updated_time,p.user_sys_before_count,p.out_reason,p.death_time,p.is_infectious").Group("p.id").Count(&total).Offset(offset).Limit(limit).Find(&patients).Error
 		}
 
 	return
 }
 
+func CreateMGroupAdviceOne(orgId int64, advices []*models.GroupAdvice, groupNo int64) (list []*models.GroupAdvice, err error) {
+	if groupNo <= 0 {
+		group := GetMaxAdviceGroupID(orgId)
+		groupNo = group + 1
+	}
+	tx := writeDb.Begin()
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+	for _, advice := range advices {
+		advice.GroupNo = advice.GroupNo
+		if err = tx.Create(advice).Error; err != nil {
+			tx.Rollback()
+			return
+		}
+		list = append(list, advice)
+		if len(advice.Children) > 0 {
+			for _, child := range advice.Children {
+				child.GroupNo = child.GroupNo
+				child.ParentId = advice.ID
+				fmt.Println(child)
+				if err = tx.Create(&child).Error; err != nil {
+					tx.Rollback()
+					return
+				}
+				list = append(list, child)
+			}
+		}
+
+	}
+	tx.Commit()
+	return
+}
+
 func UpdateDoctorAdvice(m *models.DoctorAdvice) (err error) {
 	return writeDb.Save(m).Error
 }

service/sign_service.go

 
 func GetNewAllpatient(org_id int64) (list []*models.XtPatientsNew, err error) {
 
-	err = XTReadDB().Where("status =1 and user_org_id =9990").Find(&list).Error
+	err = XTReadDB().Where("status =1 and user_org_id =10551").Find(&list).Error
 
 	return list, err
 }
 	err := XTWriteDB().Model(models.XtSchedule{}).Where("id = ? and status =1", id).Updates(map[string]interface{}{"dialysis_machine_name": dialysis_machine_name}).Error
 	return err
 }
+
+func GetPrescriptionListOne(user_org_id int64) (prescription []*models.DialysisPrescription, err error) {
+
+	err = XTReadDB().Model(&prescription).Where("user_org_id = ? and status= 1 and record_date =? and status=1", 10579, 1701360000).Find(&prescription).Error
+	return prescription, err
+}
+
+func GetPatientScheduleById(patient_id int64, schedule_date int64) (models.XtSchedule, error) {
+
+	schedule := models.XtSchedule{}
+
+	err := XTReadDB().Where("patient_id= ? and schedule_date = ? and status =1 and user_org_id =10579", patient_id, schedule_date).First(&schedule).Error
+
+	return schedule, err
+}
+
+func UpdateDialysisScheduleOne(id int64, mode_id int64, dialysis_machine_name string) error {
+
+	err := XTWriteDB().Model(models.XtSchedule{}).Where("id = ? and status =1", id).Updates(map[string]interface{}{"dialysis_machine_name": dialysis_machine_name, "mode_id": mode_id}).Error
+	return err
+}