历史排班

controllers/dialysis_api_controller.go

 
 	} else {
 		dialysisSchedule, err, total := service.GetDialysisWatch(adminUserInfo.CurrentOrgId, startTime/1000, schedulType, partitionType, page, limit, start_time/1000, end_time/1000)
+
+		for _, item := range dialysisSchedule {
+			patients, _ := service.GetMonitorPatients(item.PatientId)
+			item.MonitorPatients = patients
+
+			orderObj, _ := service.GetMonitorDialysisOrderObj(item.PatientId, item.ScheduleDate)
+
+			item.DialysisOrder = orderObj
+
+			prescription, _ := service.GetMonitorDialysisPrescription(item.PatientId, item.ScheduleDate)
+
+			item.Prescription = prescription
+
+			evaluation, _ := service.GetMonitorPredialysisEvaluation(item.PatientId, item.ScheduleDate)
+
+			item.AssessmentBeforeDislysis = evaluation
+
+			afterdislysis, _ := service.GetMonitorAssessmentAfterDislysis(item.PatientId, item.ScheduleDate)
+
+			item.AssessmentAfterDislysis = afterdislysis
+
+			monitorRecord, _ := service.GetMonitoringRecordList(item.PatientId, item.ScheduleDate)
+
+			item.MonitoringRecord = monitorRecord
+
+		}
 		if err == nil {
 			c.ServeSuccessJSON(map[string]interface{}{
 				"schedule": dialysisSchedule,

controllers/mobile_api_controllers/dialysis_api_controller.go

 	defer redis.Close()
 
 	key := "scheduals_" + schedualDate + "_" + strconv.FormatInt(orgID, 10)
-
+	//redis.Set(key, "", time.Second)
 	scheduals_json_str, _ := redis.Get(key).Result()
 
 	patients, _ := service.GetAllPatientListSix(orgID)
+	fmt.Println("scheduals_json_strwoowowow", len(scheduals_json_str))
 	if len(scheduals_json_str) == 0 { //没有到缓存数据，从数据库中获取数据，进行缓存到redis
 		scheduals, err := service.MobileGetDialysisScheduals(orgID, date.Unix(), schedualType)
+
+		for _, item := range scheduals {
+			order, _ := service.GetMonitDialysisOrder(item.UserOrgId, item.PatientId, date.Unix())
+			item.DialysisLastOrder = order
+
+			solution, _ := service.GetMonitDialysisSolution(item.UserOrgId, item.PatientId, item.ModeId)
+			item.DialysisSolution = solution
+		}
 		fmt.Println("len2223o32o23o23owo", len(scheduals))
 		if err != nil {
 			this.ErrorLog("获取排班信息失败:%v", err)
 				treatmentSummarys, _ := service.GetAllTreatmentSummarysByList(orgID, date.Unix())
 				AssessmentAfterDislysis, _ := service.GetAllAssessmentAfterDislysisByList(orgID, date.Unix())
 				dobulecheck, _ := service.GetAllDobuleCheckList(orgID, date.Unix())
-				fmt.Println("dobulecheck", dobulecheck)
+
 				hisAdvices, _ := service.GetAllHisAdvicesByList(orgID, date.Unix())
 				inforMation, _ := service.GetTodayInforMation(orgID, date.Unix())
 				for key, item := range scheduals {

controllers/mobile_api_controllers/patient_api_controller.go

 	//获取患者的透析次数
 	//count, err := service.GetDialysisCount(orgID, partition)
 
-	patients, err := service.GetAllpatientThirty(orgID)
+	patients, err := service.GetAllpatientFourty(orgID)
 	if err == nil {
 		c.ServeSuccessJSON(map[string]interface{}{
 			"monitor": monitor,

controllers/schedule_api_controller.go

 
 	beego.Router("/api/schedule/create_two", &ScheduleApiController{}, "Post:CreateScheduleTwo")
 
+	beego.Router("/api/schedule/changeschedule", &ScheduleApiController{}, "Put:ChangeScheduleTen")
+
 }
 func (c *ScheduleApiController) CoverSch() {
 	id_one, _ := c.GetInt64("id_one")
 		var DialysisMachineName string
 		if filedRecordOne.IsShow == 1 {
 			DialysisMachineName = so.DialysisDialyszers
-			fmt.Println("1111")
+			//fmt.Println("1111")
 			fmt.Println(DialysisMachineName)
 
 		}
 		if filedRecordThree.IsShow == 1 {
 			if len(schedule.DialysisMachineName) > 0 {
 				DialysisMachineName = DialysisMachineName + "," + so.DialyzerPerfusionApparatus
-				fmt.Println("22222")
+				//fmt.Println("22222")
 				fmt.Println(DialysisMachineName)
 			} else {
 				DialysisMachineName = so.DialyzerPerfusionApparatus
-				fmt.Println("333333")
+				//fmt.Println("333333")
 				fmt.Println(DialysisMachineName)
 			}
 		}
 		if filedRecordTwo.IsShow == 1 {
 			if len(DialysisMachineName) > 0 {
 				DialysisMachineName = DialysisMachineName + "," + so.DialysisIrrigation
-				fmt.Println("55555555")
+				//fmt.Println("55555555")
 				fmt.Println(DialysisMachineName)
 			} else {
 				DialysisMachineName = so.DialysisIrrigation
-				fmt.Println("66666666")
+				//fmt.Println("66666666")
 				fmt.Println(DialysisMachineName)
 			}
 		}
 	adminUserInfo := this.GetAdminUserInfo()
 	orgId := adminUserInfo.CurrentOrgId
 	start_time, _ := this.GetInt64("start_time")
-	fmt.Println("start_time", start_time)
+
 	end_time, _ := this.GetInt64("end_time")
-	fmt.Println("end_time", end_time)
+
 	copy_startime, _ := this.GetInt64("copy_startime")
-	fmt.Println("copy_startime", copy_startime)
+
 	copy_endtime, _ := this.GetInt64("copy_endtime")
 
 	//获取本周患者排班
 	}
 	schdules, _ := service.GetWeekScheduleTwo(adminInfo.CurrentOrgId, weekStartPoint, weekEndPoint, ids, schedule_type)
 
-	if adminInfo.CurrentOrgId == 9671 || adminInfo.CurrentOrgId == 10346 {
+	if adminInfo.CurrentOrgId == 10346 {
 
 		if len(schdules) > 0 {
 			//获取长期医嘱里面的透析器灌流器
 
 	week, _ := c.GetInt64("weekTime", 0) //1:last, 2:this 3:next 4 nextTwo
 
-	fmt.Println("weekwoowowowowowowowowowo", week)
 	patitionIdStr := c.GetString("patitionid")
 
 	ids := strings.Split(patitionIdStr, ",")
 
 	adminInfo := c.GetAdminUserInfo()
 	weekDateStr := c.GetString("week_date")
-	fmt.Println("weekDateStr--------------------", weekDateStr)
+
 	WeekDayIds := strings.Split(weekDateStr, ",")
 
 	thisTime := time.Now()
 	}
 
 }
+
+func (c *ScheduleApiController) ChangeScheduleTen() {
+
+	id, _ := c.GetInt64("id", 0)
+	bed_id, _ := c.GetInt64("bed_id")
+	mode_id, _ := c.GetInt64("mode_id")
+	schedule_type, _ := c.GetInt64("schedule_type")
+	if id <= 0 {
+		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeParamWrong)
+		return
+	}
+
+	adminINfo := c.GetAdminUserInfo()
+
+	schedule, _ := service.GetSchedule(adminINfo.CurrentOrgId, id)
+
+	//获取分区号
+	number, _ := service.GetZoneId(bed_id, adminINfo.CurrentOrgId)
+	if schedule == nil {
+		c.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeScheduleNotExist)
+		return
+	}
+	//如果透析模式相等 床位号相等，班次相等
+	if mode_id == schedule.ModeId && bed_id == schedule.BedId && schedule_type == schedule.ScheduleType && number.ZoneID == schedule.PartitionId {
+		c.ServeFailJSONWithSGJErrorCode(enums.ErrorScheduleCode)
+		return
+	} else {
+
+		//查询该床位今天是否存在排班
+		sch, _ := service.GetScheduleByBedId(bed_id, schedule_type, adminINfo.CurrentOrgId, schedule.ScheduleDate)
+		fmt.Println("schwowowoowowowowowo", sch.ID)
+		if sch.ID == 0 {
+			//删除排班
+			service.UpdateScheduleByScheduleId(id)
+			xtSchedule := models.XtSchedule{
+				UserOrgId:           adminINfo.CurrentOrgId,
+				PartitionId:         number.ZoneID,
+				BedId:               bed_id,
+				PatientId:           schedule.PatientId,
+				ScheduleDate:        schedule.ScheduleDate,
+				ScheduleType:        schedule.ScheduleType,
+				ScheduleWeek:        schedule.ScheduleWeek,
+				ModeId:              mode_id,
+				Status:              1,
+				CreatedTime:         time.Now().Unix(),
+				UpdatedTime:         0,
+				IsExport:            999999,
+				DialysisMachineName: "",
+			}
+			service.CreateNewSchedule(xtSchedule)
+		}
+
+		//存在排班
+		if sch.ID > 0 {
+			//删除排班
+			//service.UpdateScheduleByScheduleId(id)
+			//查询该患者的透析模式对应的透析器灌流器
+			//service.GetDialysisSolutionByMode(schedule.PatientId)
+			xtSchedule := models.XtSchedule{
+				UserOrgId:           adminINfo.CurrentOrgId,
+				PartitionId:         number.ZoneID,
+				BedId:               bed_id,
+				PatientId:           schedule.PatientId,
+				ScheduleDate:        schedule.ScheduleDate,
+				ScheduleType:        schedule_type,
+				ScheduleWeek:        schedule.ScheduleWeek,
+				ModeId:              mode_id,
+				Status:              1,
+				CreatedTime:         time.Now().Unix(),
+				UpdatedTime:         time.Now().Unix(),
+				IsExport:            8888,
+				DialysisMachineName: "",
+			}
+
+			service.UpdateScheduleSixTy(sch.ID, xtSchedule)
+
+			msch := models.XtSchedule{
+				UserOrgId:    adminINfo.CurrentOrgId,
+				PartitionId:  number.ZoneID,
+				BedId:        bed_id,
+				PatientId:    sch.PatientId,
+				ScheduleDate: sch.ScheduleDate,
+				ScheduleType: sch.ScheduleType,
+				ScheduleWeek: sch.ScheduleWeek,
+				ModeId:       sch.ModeId,
+				IsExport:     88888,
+				CreatedTime:  time.Now().Unix(),
+				UpdatedTime:  time.Now().Unix(),
+			}
+
+			service.UpdateScheduleSixTy(id, msch)
+
+		}
+	}
+
+	c.ServeSuccessJSON(map[string]interface{}{
+		"msg": "ok",
+	})
+
+}

enums/error_code.go

 	AdviceCodeParamWrong = 600000007
 
 	ErrorCodeInformationExist = 600000008
+
+	ErrorScheduleCode = 600000009
 )
 
 var ErrCodeMsgs = map[int]string{
 	ErrorCodePatientScheduleRepeat:        "一天只能存在一次排班",
 	ErrorCodeDelScheduleFailByDialysisTwo: "已经上机透析，不能操作排班",
 	AdviceCodeParamWrong:                  "医嘱核对人和执行人不能为同一人,请更换第二核对人!",
-
-	ErrorCodeInformationExist: "已经超过归档天数,不予编辑,请提交申请",
+	ErrorCodeInformationExist:             "已经超过归档天数,不予编辑,请提交申请",
+	ErrorScheduleCode:                     "未更改排班,保存失败!",
 }
 
 type SGJError struct {

models/dialysis.go

 	AssessmentBeforeDislysis *PredialysisEvaluation   `gorm:"ForeignKey:AssessmentDate,PatientId;AssociationForeignKey:ScheduleDate,PatientId" json:"assessment_before_dislysis"`
 	AssessmentAfterDislysis  *AssessmentAfterDislysis `gorm:"ForeignKey:AssessmentDate,PatientId;AssociationForeignKey:ScheduleDate,PatientId" json:"assessment_after_dislysis"`
 	MonitoringRecord         []*MonitoringRecord      `gorm:"ForeignKey:MonitoringDate,PatientId;AssociationForeignKey:ScheduleDate,PatientId" json:"monitoring_record"`
-
-	//Patient         string          `gorm:"-" json:"patient" form:"patient"`
-	//SchedualPatient SchedualPatient `gorm:"ForeignKey:PatientId"`
-	//DeviceNumber    DeviceNumber    `gorm:"ForeignKey:BedId"`
-	//DeviceZone      DeviceZone      `gorm:"ForeignKey:PartitionId"`
-	//TreatmentMode   TreatmentMode   `gorm:"ForeignKey:ModeId"`
 }
 
 type DialysisScheduleOne struct {

models/patient_models.go

 	DialysisNo    string `gorm:"column:dialysis_no" json:"dialysis_no" form:"dialysis_no"`
 	Name          string `gorm:"column:name" json:"name" form:"name"`
 	TotalDialysis int64  `gorm:"column:total_dialysis" json:"total_dialysis" form:"total_dialysis"`
+	Lapseto       int64  `gorm:"column:lapseto" json:"lapseto" form:"lapseto"`
 }
 
 func (PatientsThirty) TableName() string {

service/dialysis_service.go

 	if start > 0 && end > 0 {
 		db = db.Preload("DeviceNumber", "org_id = ?", orgID).
 			Preload("TreatmentMode", "status = 1").
-			Preload("Prescription", "status = 1 AND user_org_id = ? and record_date>=? and record_date <=?", orgID, start, end).
-			Preload("AssessmentBeforeDislysis", "status = 1 AND  user_org_id = ? and assessment_date >=? and assessment_date <=?", orgID, start, end).
-			Preload("AssessmentAfterDislysis", "status = 1 AND  user_org_id = ? and assessment_date >=? and assessment_date <=?", orgID, start, end).
 			Preload("MonitoringRecord", func(db *gorm.DB) *gorm.DB {
 				return db.Where("status = 1 AND user_org_id = ? and monitoring_date >=? and monitoring_date<=? ", orgID, start, end).Order("operate_time asc")
-			}).
-			Preload("DialysisOrder", "status = 1 AND user_org_id = ? and dialysis_date>=? and dialysis_date<=?", orgID, start, end).
-			Preload("MonitorPatients", "status = 1 AND user_org_id = ?", orgID)
+			})
 		db = db.Where("xt_schedule.status = 1")
 	}
 	if schedulDate > 0 {
 		db = db.Preload("DeviceNumber", "org_id = ?", orgID).
 			Preload("TreatmentMode", "status = 1").
-			Preload("Prescription", "status = 1 AND user_org_id = ? and record_date>=? and record_date <=?", orgID, schedulDate, schedulDate).
-			Preload("AssessmentBeforeDislysis", "status = 1 AND  user_org_id = ? and assessment_date >=? and assessment_date <=?", orgID, schedulDate, schedulDate).
-			Preload("AssessmentAfterDislysis", "status = 1 AND  user_org_id = ? and assessment_date >=? and assessment_date <=?", orgID, schedulDate, schedulDate).
 			Preload("MonitoringRecord", func(db *gorm.DB) *gorm.DB {
 				return db.Where("status = 1 AND user_org_id = ? and monitoring_date >=? and monitoring_date<=? ", orgID, schedulDate, schedulDate).Order("operate_time asc")
-			}).
-			Preload("DialysisOrder", "status = 1 AND user_org_id = ? and dialysis_date>=? and dialysis_date<=?", orgID, schedulDate, schedulDate).
-			Preload("MonitorPatients", "status = 1 AND user_org_id = ?", orgID)
+			})
 		db = db.Where("xt_schedule.status = 1")
 		db = db.Where("schedule_date = ?", schedulDate)
 	}
 	}
 	if partitionType > 0 {
 		db = db.Joins("inner join xt_device_number on xt_device_number.id = xt_schedule.bed_id and xt_device_number.zone_id = ?", partitionType)
-		// db = db.Where("partition_id = ?", partitionType)
 	}
 	offset := (page - 1) * limit
 	err = db.Count(&total).Offset(offset).Limit(limit).Order("bed_id desc").Find(&schedule).Error
 
 	return schedules, err
 }
+
+func GetMonitorPatients(patient_id int64) (*models.MonitorPatients, error) {
+
+	patients := models.MonitorPatients{}
+	err := XTReadDB().Where("id = ? and status = 1", patient_id).Find(&patients).Error
+
+	return &patients, err
+}
+
+func GetMonitorDialysisOrderObj(patient_id int64, schedule_date int64) (*models.MonitorDialysisOrder, error) {
+
+	order := models.MonitorDialysisOrder{}
+
+	err := XTReadDB().Where("patient_id = ? and dialysis_date = ? and status = 1", patient_id, schedule_date).Find(&order).Error
+
+	return &order, err
+}
+
+func GetMonitorDialysisPrescription(patient_id int64, record_date int64) (*models.DialysisPrescription, error) {
+
+	prescription := models.DialysisPrescription{}
+	err := XTReadDB().Where("patient_id = ? and status =1 and record_date = ?", patient_id, record_date).Find(&prescription).Error
+
+	return &prescription, err
+}
+
+func GetMonitorPredialysisEvaluation(patient_id int64, record_date int64) (*models.PredialysisEvaluation, error) {
+
+	evaluation := models.PredialysisEvaluation{}
+
+	err := XTReadDB().Where("patient_id = ? and status =1 and assessment_date = ?", patient_id, record_date).Find(&evaluation).Error
+
+	return &evaluation, err
+}
+
+func GetMonitorAssessmentAfterDislysis(patient_id int64, record_date int64) (*models.AssessmentAfterDislysis, error) {
+
+	dislysis := models.AssessmentAfterDislysis{}
+
+	err = XTReadDB().Where("patient_id = ? and status =1 and assessment_date = ?", patient_id, record_date).Find(&dislysis).Error
+
+	return &dislysis, err
+}
+
+func GetMonitoringRecordList(patient_id int64, record_date int64) (record []*models.MonitoringRecord, err error) {
+
+	err = XTReadDB().Where("patient_id = ? and monitoring_date=? and status =1", patient_id, record_date).Find(&record).Error
+
+	return record, err
+}

service/manage_service.go

 	return patients, err
 }
 
+func GetAllpatientFourty(orgid int64) (patients []*models.PatientsThirty, err error) {
+	err = XTReadDB().Where("user_org_id = ? and status = 1 and lapseto = 1", orgid).Find(&patients).Error
+	return patients, err
+}
+
 func GetInformation(eid int64, startdate int64, orgid int64, classtype int64) (*models.DeviceInformation, error) {
 	var information models.DeviceInformation
 	var err error

service/mobile_dialysis_service.go

 		db = db.Where("schedule_type = ?", scheduleType)
 	}
 
-	err := db.Preload("DialysisLastOrder", func(db *gorm.DB) *gorm.DB {
-		return db.Order("dialysis_date desc").Where(" status = 1 AND user_org_id = ? and dialysis_date>=1672502400 && dialysis_date < ?", orgID, scheduleDate)
-	}).Preload("DialysisSolution", "status = 1 and user_org_id = ? and solution_status = 1", orgID).Find(&vms).Error
+	err := db.Find(&vms).Error
+	//err := db.Preload("DialysisLastOrder", func(db *gorm.DB) *gorm.DB {
+	//	return db.Order("dialysis_date desc").Where(" status = 1 AND user_org_id = ? and dialysis_date>=1672502400 && dialysis_date < ?", orgID, scheduleDate)
+	//}).Preload("DialysisSolution", "status = 1 and user_org_id = ? and solution_status = 1", orgID).Find(&vms).Error
 	return vms, err
 }
 
+func GetMonitDialysisOrder(user_org_id int64, patient_id int64, scheduleDate int64) (*models.MDialysisOrderForList, error) {
+
+	order := models.MDialysisOrderForList{}
+	err := XTReadDB().Where("user_org_id = ? and status =1 and patient_id = ?", user_org_id, patient_id).Order("id asc").Last(&order).Error
+	return &order, err
+}
+
+func GetMonitDialysisSolution(user_org_id int64, patient_id int64, mode_id int64) (*models.DialysisSolution, error) {
+
+	solution := models.DialysisSolution{}
+
+	err := XTReadDB().Where("user_org_id = ? and patient_id =? and solution_status = 1 and mode_id = ?", user_org_id, patient_id, mode_id).Find(&solution).Error
+
+	return &solution, err
+}
+
 func MobileGetWaitingScheduals(orgID int64, scheduleDate int64) ([]*MDialysisScheduleVM, error) {
 	var vms []*MDialysisScheduleVM
 	db := readDb.

service/schedule_service.go

 
 	return err
 }
+
+func GetScheduleByBedId(bed_id int64, schedule_type int64, user_org_id int64, schedule_date int64) (models.XtSchedule, error) {
+
+	schedule := models.XtSchedule{}
+
+	err := XTReadDB().Model(&schedule).Where("bed_id = ? and schedule_type =? and user_org_id = ? and schedule_date = ? and status =1", bed_id, schedule_type, user_org_id, schedule_date).Find(&schedule).Error
+
+	return schedule, err
+}
+
+func UpdateScheduleByScheduleId(id int64) error {
+
+	err := XTWriteDB().Model(&models.XtSchedule{}).Where("id = ? and status = 1", id).Updates(map[string]interface{}{"status": 0}).Error
+
+	return err
+}
+
+func UpdateScheduleSixTy(id int64, schedules models.XtSchedule) error {
+
+	err := XTWriteDB().Model(&models.XtSchedule{}).Where("id = ? and status =1", id).Updates(map[string]interface{}{"mode_id": schedules.ModeId, "partition_id": schedules.PartitionId, "bed_id": schedules.BedId, "patient_id": schedules.PatientId, "schedule_date": schedules.ScheduleDate, "schedule_type": schedules.ScheduleType, "schedule_week": schedules.ScheduleWeek}).Error
+
+	return err
+}
+
+func CreateNewSchedule(schedule models.XtSchedule) error {
+
+	err := XTWriteDB().Create(&schedule).Error
+
+	return err
+}