Merge branch 'master' of http://git.shengws.com/csx/XT_New

controllers/manage_api_controller.go

 		ids = append(ids, id)
 	}
 
+	//查询机位号是否绑定设备
+	thisAddmacher, err := service.GetEquitmentByBedID(bed_number, orgid)
+	if thisAddmacher.ID > 0 {
+		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeDialysisNoExist)
+		return
+	}
+
 	addmacher := &models.DeviceAddmacher{
-		SerialNumber:        serial_numbe,
-		DeviceType:          device_type,
-		BedNumber:           number.Number,
-		BedId:               bed_number,
-		ZoneId:              number.ZoneID,
+		SerialNumber: serial_numbe,
+		DeviceType:   device_type,
+		BedNumber:    number.Number,
+		BedId:        bed_number,
+		//ZoneId:              number.ZoneID,
 		DeviceName:          device_name,
 		ManufactureFactory:  manufacture_factory,
 		ServiceManufacturer: service_manufacturer,
 	fmt.Print("information", information)
 	if errinfor == gorm.ErrRecordNotFound {
 		infor := models.DeviceInformation{
-			Date:                startdate,
-			Class:               classtype,
-			Zone:                zone,
-			BedNumber:           bednumber,
-			PatientId:           patient_time,
-			Contagion:           contagion,
-			DialysisMode:        dialysis_mode,
-			StartTime:           startDate.Unix(),
-			EndTime:             endDate.Unix(),
-			DialysisHour:        dialysis_time,
-			Hyperfiltratio:      hyperfiletration,
-			WeightLoss:          weight_loss,
-			WarningValue:        warining_value,
-			UserTotal:           user_total,
-			Move:                run,
-			FailureStage:        failure_stage,
-			FaultDescription:    falult_desciription,
-			CodeInformation:     code_information,
-			DisinfectantType:    disinfectant_type,
-			DisinfectType:       disinfect_type,
-			Disinfection:        disinfection,
-			MachineRun:          machine_run,
-			FluidPath:           fluid_path,
-			Disinfectant:        disinfectant,
-			DisinfectionStatus:  disinfection_status,
-			DisinfectionResidue: disinfection_residue,
-			LongTime:            longtime,
-			DisinfecStartime:    start_Date.Unix(),
-			DisinfecEndtime:     end_Date.Unix(),
-			DialysisChecked:     dialysis_checked,
-			DialysisName:        dialysis_name,
-			Norms:               norms,
+			Date:                  startdate,
+			Class:                 classtype,
+			Zone:                  zone,
+			BedNumber:             bednumber,
+			PatientId:             patient_time,
+			Contagion:             contagion,
+			DialysisMode:          dialysis_mode,
+			StartTime:             startDate.Unix(),
+			EndTime:               endDate.Unix(),
+			DialysisHour:          dialysis_time,
+			Hyperfiltratio:        hyperfiletration,
+			WeightLoss:            weight_loss,
+			WarningValue:          warining_value,
+			UserTotal:             user_total,
+			Move:                  run,
+			FailureStage:          failure_stage,
+			FaultDescription:      falult_desciription,
+			CodeInformation:       code_information,
+			DisinfectantType:      disinfectant_type,
+			DisinfectType:         disinfect_type,
+			Disinfection:          disinfection,
+			MachineRun:            machine_run,
+			FluidPath:             fluid_path,
+			Disinfectant:          disinfectant,
+			DisinfectionStatus:    disinfection_status,
+			DisinfectionResidue:   disinfection_residue,
+			LongTime:              longtime,
+			DisinfecStartime:      start_Date.Unix(),
+			DisinfecEndtime:       end_Date.Unix(),
+			DialysisChecked:       dialysis_checked,
+			DialysisName:          dialysis_name,
+			Norms:                 norms,
 			DialysisConcentration: dialysis_concentration,
 			GermChecked:           germ_checked,
 			GermName:              germ_name,
 		})
 	} else if errinfor == nil {
 		infor := models.DeviceInformation{
-			Date:                startdate,
-			Class:               classtype,
-			Zone:                zone,
-			BedNumber:           bednumber,
-			PatientId:           patient_time,
-			Contagion:           contagion,
-			DialysisMode:        dialysis_mode,
-			StartTime:           startDate.Unix(),
-			EndTime:             endDate.Unix(),
-			DialysisHour:        dialysis_time,
-			Hyperfiltratio:      hyperfiletration,
-			WeightLoss:          weight_loss,
-			WarningValue:        warining_value,
-			UserTotal:           user_total,
-			Move:                run,
-			FailureStage:        failure_stage,
-			FaultDescription:    falult_desciription,
-			CodeInformation:     code_information,
-			DisinfectantType:    disinfectant_type,
-			DisinfectType:       disinfect_type,
-			Disinfection:        disinfection,
-			MachineRun:          machine_run,
-			FluidPath:           fluid_path,
-			Disinfectant:        disinfectant,
-			DisinfectionStatus:  disinfection_status,
-			DisinfectionResidue: disinfection_residue,
-			LongTime:            longtime,
-			DisinfecStartime:    start_Date.Unix(),
-			DisinfecEndtime:     end_Date.Unix(),
-			DialysisChecked:     dialysis_checked,
-			DialysisName:        dialysis_name,
-			Norms:               norms,
+			Date:                  startdate,
+			Class:                 classtype,
+			Zone:                  zone,
+			BedNumber:             bednumber,
+			PatientId:             patient_time,
+			Contagion:             contagion,
+			DialysisMode:          dialysis_mode,
+			StartTime:             startDate.Unix(),
+			EndTime:               endDate.Unix(),
+			DialysisHour:          dialysis_time,
+			Hyperfiltratio:        hyperfiletration,
+			WeightLoss:            weight_loss,
+			WarningValue:          warining_value,
+			UserTotal:             user_total,
+			Move:                  run,
+			FailureStage:          failure_stage,
+			FaultDescription:      falult_desciription,
+			CodeInformation:       code_information,
+			DisinfectantType:      disinfectant_type,
+			DisinfectType:         disinfect_type,
+			Disinfection:          disinfection,
+			MachineRun:            machine_run,
+			FluidPath:             fluid_path,
+			Disinfectant:          disinfectant,
+			DisinfectionStatus:    disinfection_status,
+			DisinfectionResidue:   disinfection_residue,
+			LongTime:              longtime,
+			DisinfecStartime:      start_Date.Unix(),
+			DisinfecEndtime:       end_Date.Unix(),
+			DialysisChecked:       dialysis_checked,
+			DialysisName:          dialysis_name,
+			Norms:                 norms,
 			DialysisConcentration: dialysis_concentration,
 			GermChecked:           germ_checked,
 			GermName:              germ_name,
 	fmt.Println("签名", sign_name)
 
 	information := models.DeviceInformation{
-		Date:                startdate,
-		Class:               classtype,
-		Zone:                zone,
-		BedNumber:           bednumber,
-		Contagion:           contagion,
-		DialysisMode:        dialysis_mode,
-		StartTime:           startDate.Unix(),
-		EndTime:             endDate.Unix(),
-		DialysisHour:        dialysis_time,
-		Hyperfiltratio:      hyperfiletration,
-		WeightLoss:          weight_loss,
-		WarningValue:        warining_value,
-		UserTotal:           user_total,
-		Move:                run,
-		FailureStage:        failure_stage,
-		FaultDescription:    falult_desciription,
-		CodeInformation:     code_information,
-		DisinfectantType:    disinfectant_type,
-		DisinfectType:       disinfect_type,
-		Disinfection:        disinfection,
-		MachineRun:          machine_run,
-		FluidPath:           fluid_path,
-		Disinfectant:        disinfectant,
-		DisinfectionStatus:  disinfection_status,
-		DisinfectionResidue: disinfection_residue,
-		LongTime:            longtime,
-		DisinfecStartime:    distartime,
-		DisinfecEndtime:     diendtime,
-		DialysisChecked:     dialysis_checked,
-		DialysisName:        dialysis_name,
-		Norms:               norms,
+		Date:                  startdate,
+		Class:                 classtype,
+		Zone:                  zone,
+		BedNumber:             bednumber,
+		Contagion:             contagion,
+		DialysisMode:          dialysis_mode,
+		StartTime:             startDate.Unix(),
+		EndTime:               endDate.Unix(),
+		DialysisHour:          dialysis_time,
+		Hyperfiltratio:        hyperfiletration,
+		WeightLoss:            weight_loss,
+		WarningValue:          warining_value,
+		UserTotal:             user_total,
+		Move:                  run,
+		FailureStage:          failure_stage,
+		FaultDescription:      falult_desciription,
+		CodeInformation:       code_information,
+		DisinfectantType:      disinfectant_type,
+		DisinfectType:         disinfect_type,
+		Disinfection:          disinfection,
+		MachineRun:            machine_run,
+		FluidPath:             fluid_path,
+		Disinfectant:          disinfectant,
+		DisinfectionStatus:    disinfection_status,
+		DisinfectionResidue:   disinfection_residue,
+		LongTime:              longtime,
+		DisinfecStartime:      distartime,
+		DisinfecEndtime:       diendtime,
+		DialysisChecked:       dialysis_checked,
+		DialysisName:          dialysis_name,
+		Norms:                 norms,
 		DialysisConcentration: dialysis_concentration,
 		GermChecked:           germ_checked,
 		GermName:              germ_name,
 }
 
 func (this *MachineApiController) GetBedForm() {
+	adminUser := this.GetAdminUserInfo()
+	orgId := adminUser.CurrentOrgId
 	id, _ := this.GetInt64("id")
 	fmt.Println("id", id)
 	addmacher, err := service.GetZoneForm(id)
-	number, err := service.GetBedForm(addmacher.ZoneId)
+	bed, err := service.GetZoneId(addmacher.BedId, orgId)
+	number, err := service.GetBedForm(bed.ZoneID)
 	if err != nil {
 		this.ServeFailJsonSend(enums.ErrorCodeDBDelete, "查询:（"+err.Error()+"）")
 		return

controllers/new_mobile_api_controllers/mobile_regist_controller.go

 
 	//创建两个血透的虚拟病人到新表
 	fmt.Print("patients", patients)
-	for _, it := range ids {
+	for _, it := range patients {
 		patientsNew := models.XtPatientsNew{
-			UserOrgId:     org.Id,
-			CreatedTime:   time.Now().Unix(),
-			UpdatedTime:   time.Now().Unix(),
-			Status:        1,
-			BloodId:       it,
-			BloodPatients: 1,
+			UserOrgId:                    org.Id,
+			CreatedTime:                  time.Now().Unix(),
+			UpdatedTime:                  time.Now().Unix(),
+			Status:                       1,
+			BloodId:                      it.ID,
+			BloodPatients:                1,
+			Name:                         it.Name,
+			Avatar:                       it.Avatar,
+			PatientType:                  it.PatientType,
+			DialysisNo:                   it.DialysisNo,
+			Source:                       it.Source,
+			Lapseto:                      it.Lapseto,
+			Gender:                       it.Gender,
+			Nation:                       it.Nation,
+			NativePlace:                  it.NativePlace,
+			MaritalStatus:                it.MaritalStatus,
+			IdCardNo:                     it.IdCardNo,
+			Birthday:                     it.Birthday,
+			ReimbursementWayId:           it.ReimbursementWayId,
+			HealthCareNo:                 it.HealthCareNo,
+			Phone:                        it.Phone,
+			HomeAddress:                  it.HomeAddress,
+			WorkUnit:                     it.WorkUnit,
+			UnitAddress:                  it.UnitAddress,
+			Children:                     it.Children,
+			IsHospitalFirstDialysis:      it.IsHospitalFirstDialysis,
+			FirstDialysisDate:            it.FirstDialysisDate,
+			FirstDialysisHospital:        it.FirstDialysisHospital,
+			PreHospitalDialysisFrequency: it.PreHospitalDialysisFrequency,
+			PreHospitalDialysisTimes:     it.PreHospitalDialysisTimes,
+			HospitalFirstDialysisDate:    it.HospitalFirstDialysisDate,
+			TotalDialysis:                it.TotalDialysis,
+			Diagnose:                     it.Diagnose,
+			Remark:                       it.Remark,
+			RegistrarsId:                 it.RegistrarsId,
+			BindingState:                 it.BindingState,
+			PatientComplains:             it.PatientComplains,
+			PresentHistory:               it.PresentHistory,
+			PastHistory:                  it.PastHistory,
+			Temperature:                  it.Temperature,
+			Pulse:                        it.Pulse,
+			Respiratory:                  it.Respiratory,
+			Age:                          it.Age,
+			IsOpenRemind:                 it.IsOpenRemind,
+			TellPhone:                    it.TellPhone,
+			FirstTreatmentDate:           it.FirstTreatmentDate,
+			ContactName:                  it.ContactName,
 		}
 		service.CreateVMOrgNewPatient(&patientsNew)
 	}

controllers/new_mobile_api_controllers/new_dialysis_api_controller.go

 
 	//如果是血透病人
 	if bloodPatient == 1 {
-		_, errcode := service.GetPatientData(phone, orgid)
-		if errcode == gorm.ErrRecordNotFound {
-			patients := models.Patients{
-				Name:              name,
-				Gender:            sex,
-				Birthday:          birth,
-				Age:               ages,
-				Phone:             phone,
-				Lapseto:           lapseto,
-				AdmissionNumber:   adminssionNumber,
-				FirstDialysisDate: fisttime,
-				Diagnose:          diagonse,
-				Source:            patientsoure,
-				DialysisNo:        dialysis,
-				UserOrgId:         orgid,
-				Status:            1,
-				CreatedTime:       time.Now().Unix(),
-				Avatar:            avatar,
-				IdCardNo:          idCard,
-				IsInfectious:      is_infectious,
-			}
-			err := service.CreateOldPatient(&patients)
-			fmt.Print("报错", err)
-			patient, err := service.GetLastOldPatient(orgid)
-			fmt.Print("病人ID", patient.ID)
-			err = service.AddContagions(patient.ID, patient.CreatedTime, patient.UpdatedTime, ids)
-			fmt.Println("添加传染病失败", err)
-
-			patientsNew := models.XtPatientsNew{
-				Name:              name,
-				Gender:            sex,
-				Birthday:          birth,
-				Age:               ages,
-				Phone:             phone,
-				Lapseto:           lapseto,
-				AdmissionNumber:   adminssionNumber,
-				FirstDialysisDate: fisttime,
-				Diagnose:          diagonse,
-				Source:            patientsoure,
-				DialysisNo:        dialysis,
-				UserOrgId:         orgid,
-				Status:            1,
-				CreatedTime:       time.Now().Unix(),
-				Avatar:            avatar,
-				MemberPatients:    memberpatient,
-				BloodPatients:     bloodPatient,
-				SlowPatients:      slowpatient,
-				BloodId:           patient.ID,
-				IsInfectious:      is_infectious,
-				IdCardNo:          idCard,
-			}
-			err = service.CreateNewPatient(&patientsNew)
-			fmt.Print("报错", err)
-			if err != nil {
-				this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
-				return
-			}
-			this.ServeSuccessJSON(map[string]interface{}{
-				"patient": patientsNew,
-			})
-		} else if errcode == nil {
-			fmt.Print("病人已存在")
+		//查询身份证号码是否存在
+		thisPatientOne, _ := service.FindPatientByIdCardNoOne(orgid, idCard)
+		if thisPatientOne.ID > 0 {
+			returnData := make(map[string]interface{}, 0)
+			returnData["msg"] = "身份证号码已存在"
+			this.ServeSuccessJSON(returnData)
 			return
-		} else {
+		}
+
+		//查询手机号码是否存在
+		thisPatient, err := service.FindPatientByMobileOne(phone, orgid)
+		if thisPatient.ID > 0 {
+			returnData := make(map[string]interface{}, 0)
+			returnData["msg"] = "手机号码已存在"
+			this.ServeSuccessJSON(returnData)
+			return
+		}
 
+		//查询透析号是否存在
+		thisPatientTwo, _ := service.FindPatientByDialysisNoOne(orgid, dialysis)
+		if thisPatientTwo.ID > 0 {
+			returnData := make(map[string]interface{}, 0)
+			returnData["msg"] = "透析号已存在"
+			this.ServeSuccessJSON(returnData)
+			return
 		}
+
+		patients := models.Patients{
+			Name:              name,
+			Gender:            sex,
+			Birthday:          birth,
+			Age:               ages,
+			Phone:             phone,
+			Lapseto:           lapseto,
+			AdmissionNumber:   adminssionNumber,
+			FirstDialysisDate: fisttime,
+			Diagnose:          diagonse,
+			Source:            patientsoure,
+			DialysisNo:        dialysis,
+			UserOrgId:         orgid,
+			Status:            1,
+			CreatedTime:       time.Now().Unix(),
+			Avatar:            avatar,
+			IdCardNo:          idCard,
+			IsInfectious:      is_infectious,
+		}
+		err = service.CreateOldPatient(&patients)
+		fmt.Print("报错", err)
+		patient, err := service.GetLastOldPatient(orgid)
+		fmt.Print("病人ID", patient.ID)
+		err = service.AddContagions(patient.ID, patient.CreatedTime, patient.UpdatedTime, ids)
+		fmt.Println("添加传染病失败", err)
+
+		patientsNew := models.XtPatientsNew{
+			Name:              name,
+			Gender:            sex,
+			Birthday:          birth,
+			Age:               ages,
+			Phone:             phone,
+			Lapseto:           lapseto,
+			AdmissionNumber:   adminssionNumber,
+			FirstDialysisDate: fisttime,
+			Diagnose:          diagonse,
+			Source:            patientsoure,
+			DialysisNo:        dialysis,
+			UserOrgId:         orgid,
+			Status:            1,
+			CreatedTime:       time.Now().Unix(),
+			Avatar:            avatar,
+			MemberPatients:    memberpatient,
+			BloodPatients:     bloodPatient,
+			SlowPatients:      slowpatient,
+			BloodId:           patient.ID,
+			IsInfectious:      is_infectious,
+			IdCardNo:          idCard,
+		}
+		err = service.CreateNewPatient(&patientsNew)
+		fmt.Print("报错", err)
+		if err != nil {
+			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
+			return
+		}
+		this.ServeSuccessJSON(map[string]interface{}{
+			"patient": patientsNew,
+		})
 	}
 
 	fmt.Print("slowpatient", slowpatient)
 					MemberTreatement:  treatmentmethod,
 				}
 				err = service.CreateNewPatient(&patientsNew)
-				fmt.Print("报错-----------------------", err)
+				fmt.Print("报错", err)
 				if err != nil {
 					this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
 					return
 	fmt.Print("开始时间", startime)
 	end := this.GetString("endtime")
 	fmt.Print("end", end)
-	endTimes, _ := time.ParseInLocation(timeLayout+" 15:04:05", end+" 00:00:00", loc)
+	endTimes, _ := time.ParseInLocation(timeLayout+" 15:04:05", end+" 23:59:59", loc)
 	endtime := endTimes.Unix()
 	fmt.Print("结束时间", endtime)
 	limit, _ := this.GetInt64("limit")
 	startime := startTimes.Unix()
 	fmt.Print("startime", startime)
 	end := this.GetString("endtime")
-	endTimes, _ := time.ParseInLocation(timeLayout+" 15:04:05", end+" 00:00:00", loc)
+	endTimes, _ := time.ParseInLocation(timeLayout+" 15:04:05", end+" 23:59:59", loc)
+
 	endtime := endTimes.Unix()
 	fmt.Print("endtime", endtime)
 	limit, _ := this.GetInt64("limit")
 	startime := startTimes.Unix()
 	fmt.Print("startime", startime)
 	end := this.GetString("endtime")
-	endTimes, _ := time.ParseInLocation(timeLayout+" 15:04:05", end+" 00:00:00", loc)
+	endTimes, _ := time.ParseInLocation(timeLayout+" 15:04:05", end+" 23:59:59", loc)
 	endtime := endTimes.Unix()
 	fmt.Print("endtime", endtime)
 	limit, _ := this.GetInt64("limit")
 	startime := startTimes.Unix()
 	fmt.Print("startime", startime)
 	end := this.GetString("endtime")
-	endTimes, _ := time.ParseInLocation(timeLayout+" 15:04:05", end+" 00:00:00", loc)
+	endTimes, _ := time.ParseInLocation(timeLayout+" 15:04:05", end+" 23:59:59", loc)
 	endtime := endTimes.Unix()
 	fmt.Print("endtime", endtime)
 	limit, _ := this.GetInt64("limit")
 	if bloodPatient == 1 {
 		//根据新表ID获取老表病人ID
 		patient, _ := service.GetNewPatient(id)
+
+		//判断身份证号是否相同
+		thisPatient, _ := service.FindPatientByIdCardNoOne(orgid, idCard)
+		if thisPatient.ID > 0 && thisPatient.ID != patient.BloodId {
+			returnData := make(map[string]interface{}, 0)
+			returnData["msg"] = "身份证号码已存在"
+			this.ServeSuccessJSON(returnData)
+			return
+		}
+
+		//查询手机号码是否存在
+		thisPatientOne, err := service.FindPatientByMobileOne(phone, orgid)
+		if thisPatientOne.ID > 0 && thisPatientOne.ID != patient.BloodId {
+			returnData := make(map[string]interface{}, 0)
+			returnData["msg"] = "手机号码已存在"
+			this.ServeSuccessJSON(returnData)
+			return
+		}
+
+		//查询号透析号是否相同
+		thisPatientother, _ := service.FindPatientByDialysisNoOne(orgid, dialysis)
+		if thisPatientother.ID > 0 && thisPatientother.ID != patient.BloodId {
+			returnData := make(map[string]interface{}, 0)
+			returnData["msg"] = "透析号码已存在"
+			this.ServeSuccessJSON(returnData)
+			return
+		}
+
 		patients := models.Patients{
 			Name:              name,
 			Gender:            sex,
 			IdCardNo:          idCard,
 			IsInfectious:      is_infectious,
 		}
-		err := service.UpdatedPatient(patients, patient.BloodId)
+		err = service.UpdatedPatient(patients, patient.BloodId)
 		patientsNew := models.XtPatientsNew{
 			ID:                id,
 			Name:              name,
 		this.ServeSuccessJSON(map[string]interface{}{
 			"patients": patientsNew,
 		})
+		//更改传染病
+		updateContagions, err := service.UpdateContagions(patient.BloodId)
+		fmt.Print("更新传染病失败", err)
+		fmt.Print("up", updateContagions)
+		err = service.AddContagions(patient.BloodId, patient.CreatedTime, patient.UpdatedTime, ids)
+		fmt.Println("添加传染病失败", err)
 	}
 	if slowpatient == 1 {
 		patient, _ := service.GetNewPatient(id)
 
 func (this *NewDialysisApiController) GetAllInspection() {
 
-	inspection, err := service.GetAllInspection(0)
-	if err != nil {
-		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
-		return
+	//查询该机构是否存在检验检测项目
+	orgid := this.GetMobileAdminUserInfo().Org.Id
+	fmt.Print("orgid", orgid)
+	_, errcode := service.GetInspectionByOrgId(orgid)
+	if errcode == gorm.ErrRecordNotFound {
+		inspection, err := service.GetAllInspection(0)
+		if err != nil {
+			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
+			return
+		}
+		this.ServeSuccessJSON(map[string]interface{}{
+			"inspection": inspection,
+		})
+	} else if errcode == nil {
+		inspection, err := service.GetAllInspection(orgid)
+		if err != nil {
+			this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
+			return
+		}
+		this.ServeSuccessJSON(map[string]interface{}{
+			"inspection": inspection,
+		})
+	} else {
+
 	}
-	this.ServeSuccessJSON(map[string]interface{}{
-		"inspection": inspection,
-	})
+
 }
 
 func (this *NewDialysisApiController) GetInspection() {
 	orgid := adminInfo.Org.Id
 	fmt.Print("patient", patient)
 	fmt.Print("orgid", orgid)
+
+	//查询该机构是否存在
+	//inspection, _ := service.GetInspectionById(patient.BloodId, startime, endtime, orgid)
+	//if len(inspection) == 0 {
+	//
+	//}
 	inspection, total, err := service.GetInspection(patient.BloodId, startime, endtime, limit, page, orgid)
 	if err != nil {
 		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
 	adminUserInfo := this.GetMobileAdminUserInfo()
 
 	roleInfo := adminUserInfo.AppRole
-
+	fmt.Print("aa")
 	es, _ := service.GetAdminUserElectronicSignature(adminUserInfo.Org.Id, adminUserInfo.App.Id, adminUserInfo.AdminUser.Id)
 
 	this.ServeSuccessJSON(map[string]interface{}{
 	})
 	return
 }
+
+func (this *NewDialysisApiController) GetPatientName() {
+	id, _ := this.GetInt64("id")
+	patients, _ := service.GetPatientDetailTwo(id)
+	fmt.Print("paitents", patients.ID)
+	patientName, err := service.GetPatientName(patients.BloodId)
+	fmt.Print("err", err)
+	if err != nil {
+		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
+		return
+	}
+	this.ServeSuccessJSON(map[string]interface{}{
+		"patientName": patientName,
+	})
+}
+
+func (this *NewDialysisApiController) GetInspectionDetail() {
+
+	patientid, _ := this.GetInt64("patientid")
+	fmt.Print("patientid", patientid)
+	patients, _ := service.GetPatientDetailTwo(patientid)
+	date, _ := this.GetInt64("date")
+	fmt.Print("date", date)
+	projectid, _ := this.GetInt64("projectid")
+	adminUser := this.GetMobileAdminUserInfo()
+	orgid := adminUser.Org.Id
+	InspectionDetail, err := service.GetInspectionDetail(patients.BloodId, date, orgid, projectid)
+	if err != nil {
+		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
+		return
+	}
+	this.ServeSuccessJSON(map[string]interface{}{
+		"InspectionDetail": InspectionDetail,
+	})
+}
+
+func (this *NewDialysisApiController) SaveFeed() {
+
+	question, _ := this.GetInt64("question")
+	fmt.Print("question", question)
+	title := this.GetString("title")
+	fmt.Print("title", title)
+	content := this.GetString("content")
+	fmt.Print("content", content)
+	phone := this.GetString("phone")
+	fmt.Print("phone", phone)
+	times, _ := this.GetInt64("time")
+	fmt.Print("time", times)
+	adminUser := this.GetMobileAdminUserInfo()
+	orgid := adminUser.Org.Id
+	feedback := models.XtPatientFeedback{
+		ProblemType: question,
+		Title:       title,
+		Content:     content,
+		Phone:       phone,
+		TimeQuantum: times,
+		UserOrgId:   orgid,
+		Ctime:       time.Now().Unix(),
+		Status:      1,
+	}
+	err := service.CreateFeedBack(&feedback)
+	if err != nil {
+		this.ServeFailJSONWithSGJErrorCode(enums.ErrorCodeSystemError)
+		return
+	}
+	this.ServeSuccessJSON(map[string]interface{}{
+		"feedback": feedback,
+	})
+}

controllers/new_mobile_api_controllers/new_mobile_api_router_register.go

 	beego.Router("/m/api/patient/getallinspection", &NewDialysisApiController{}, "Get:GetAllInspection")
 	beego.Router("/m/api/patient/getinspection", &NewDialysisApiController{}, "Get:GetInspection")
 	beego.Router("/m/api/patient/getmyinformation", &NewDialysisApiController{}, "Get:GetMyInformation")
+	beego.Router("/m/api/patient/getpatientname", &NewDialysisApiController{}, "Get:GetPatientName")
+	beego.Router("/m/api/patient/getinspectiondetail", &NewDialysisApiController{}, "Get:GetInspectionDetail")
+	beego.Router("/m/api/patient/savefeed", &NewDialysisApiController{}, "Get:SaveFeed")
 }

controllers/patient_api_controller.go

 		return
 	}
 
+	//获取老表的最后一条数据
+	patients, err := service.GetLastPatientData(adminUserInfo.CurrentOrgId)
+	patientsNew := models.XtPatientsNew{
+		UserOrgId:                    adminUserInfo.CurrentOrgId,
+		UserId:                       0,
+		Avatar:                       patients.Avatar,
+		PatientType:                  patients.PatientType,
+		DialysisNo:                   patients.DialysisNo,
+		AdmissionNumber:              patients.AdmissionNumber,
+		Source:                       patients.Source,
+		Lapseto:                      patients.Lapseto,
+		PartitionId:                  patients.PartitionId,
+		BedId:                        patients.BedId,
+		Name:                         patients.Name,
+		Alias:                        patients.Alias,
+		Gender:                       patients.Gender,
+		MaritalStatus:                patients.MaritalStatus,
+		IdCardNo:                     patients.IdCardNo,
+		Birthday:                     patients.Birthday,
+		ReimbursementWayId:           patients.ReimbursementWayId,
+		HealthCareType:               patients.HealthCareType,
+		HealthCareNo:                 patients.HealthCareNo,
+		HealthCareDueDate:            patients.HealthCareDueDate,
+		Height:                       patients.Height,
+		BloodType:                    patients.BloodType,
+		Rh:                           patients.Rh,
+		HealthCareDueAlertDate:       patients.HealthCareDueAlertDate,
+		EducationLevel:               patients.EducationLevel,
+		Profession:                   patients.Profession,
+		Phone:                        patients.Phone,
+		HomeTelephone:                patients.HomeTelephone,
+		RelativePhone:                patients.RelativePhone,
+		RelativeRelations:            patients.RelativeRelations,
+		HomeAddress:                  patients.HomeAddress,
+		WorkUnit:                     patients.WorkUnit,
+		UnitAddress:                  patients.UnitAddress,
+		Children:                     patients.Children,
+		ReceivingDate:                patients.ReceivingDate,
+		IsHospitalFirstDialysis:      patients.IsHospitalFirstDialysis,
+		FirstDialysisDate:            patients.FirstDialysisDate,
+		FirstDialysisHospital:        patients.FirstDialysisHospital,
+		PredialysisCondition:         patients.PredialysisCondition,
+		PreHospitalDialysisFrequency: patients.PreHospitalDialysisFrequency,
+		PreHospitalDialysisTimes:     patients.PreHospitalDialysisTimes,
+		HospitalFirstDialysisDate:    patients.HospitalFirstDialysisDate,
+		InductionPeriod:              patients.InductionPeriod,
+		InitialDialysis:              patients.InitialDialysis,
+		TotalDialysis:                patients.TotalDialysis,
+		AttendingDoctorId:            patients.AttendingDoctorId,
+		HeadNurseId:                  patients.HeadNurseId,
+		Evaluate:                     patients.Evaluate,
+		Diagnose:                     patients.Diagnose,
+		Remark:                       patients.Remark,
+		RegistrarsId:                 patients.RegistrarsId,
+		Registrars:                   patients.Registrars,
+		QrCode:                       patients.QrCode,
+		BindingState:                 patients.BindingState,
+		PatientComplains:             patients.PatientComplains,
+		PresentHistory:               patients.PresentHistory,
+		PastHistory:                  patients.PresentHistory,
+		Temperature:                  patients.Temperature,
+		Pulse:                        patients.Pulse,
+		Respiratory:                  patients.Respiratory,
+		Sbp:                          patients.SBP,
+		Dbp:                          patients.DBP,
+		Status:                       patients.Status,
+		CreatedTime:                  patients.CreatedTime,
+		UpdatedTime:                  patients.UpdatedTime,
+		Nation:                       patients.Nation,
+		NativePlace:                  patients.NativePlace,
+		Age:                          patients.Age,
+		InfectiousNextRecordTime:     patients.InfectiousNextRecordTime,
+		IsInfectious:                 patients.IsInfectious,
+		RemindCycle:                  patients.RemindCycle,
+		ResponseResult:               patients.ResponseResult,
+		IsOpenRemind:                 patients.IsOpenRemind,
+		FirstTreatmentDate:           patients.FirstTreatmentDate,
+		DialysisAge:                  patients.DialysisAge,
+		ExpenseKind:                  patients.ExpenseKind,
+		TellPhone:                    patients.TellPhone,
+		ContactName:                  patients.ContactName,
+		BloodPatients:                1,
+		SlowPatients:                 0,
+		MemberPatients:               0,
+		EcommerPatients:              "",
+		BloodId:                      patients.ID,
+		SlowId:                       0,
+		MemberId:                     0,
+		MemberFistdate:               0,
+		MemberPatienttype:            0,
+		MemberTreatement:             0,
+		EquitmentId:                  "",
+	}
+
+	err = service.CreatePatientsNew(&patientsNew)
+	fmt.Print("创建失败", err)
+
 	if len(record_date) > 0 {
 		var recordTime int64
 		timeLayout := "2006-01-02"

models/device_models.go

 	EquitmentName       string `gorm:"column:equitment_name" json:"equitment_name" form:"equitment_name"`
 	BedId               int64  `gorm:"column:bed_id" json:"bed_id" form:"bed_id"`
 	DeviceMode          string `gorm:"column:device_mode" json:"device_mode" form:"device_mode"`
+	Number              string `gorm:"column:number" json:"number" form:"number"`
 }
 
 type DeviceAddmacher struct {

models/inspection_models.go

 	return "xt_inspection"
 }
 
+type Inspections struct {
+	ID           int64  `gorm:"column:id" json:"id" form:"id"`
+	PatientId    int64  `gorm:"column:patient_id" json:"patient_id" form:"patient_id"`
+	OrgId        int64  `gorm:"column:org_id" json:"org_id" form:"org_id"`
+	ProjectId    int64  `gorm:"column:project_id" json:"project_id" form:"project_id"`
+	ItemId       int64  `gorm:"column:item_id" json:"item_id" form:"item_id"`
+	ItemName     string `gorm:"column:item_name" json:"item_name" form:"item_name"`
+	ProjectName  string `gorm:"column:project_name" json:"project_name" form:"project_name"`
+	InspectType  int64  `gorm:"column:inspect_type" json:"inspect_type" form:"inspect_type"`
+	InspectValue string `gorm:"column:inspect_value" json:"inspect_value" form:"inspect_value"`
+	InspectDate  int64  `gorm:"column:inspect_date" json:"inspect_date" form:"inspect_date"`
+	Status       int64  `gorm:"column:status" json:"status" form:"status"`
+	CreatedTime  int64  `gorm:"column:created_time" json:"created_time" form:"created_time"`
+	UpdatedTime  int64  `gorm:"column:updated_time" json:"updated_time" form:"updated_time"`
+	RangeType    int64  `gorm:"column:range_type" json:"range_type" form:"range_type"`
+	RangeMin     string `gorm:"column:range_min" json:"range_min" form:"range_min"`
+	RangeMax     string `gorm:"column:range_max" json:"range_max" form:"range_max"`
+	RangeValue   string `gorm:"column:range_value" json:"range_value" form:"range_value"`
+	RangeOptions string `gorm:"column:range_options" json:"range_options" form:"range_options"`
+	Unit         string `gorm:"column:unit" json:"unit" form:"unit"`
+}
+
 type InspectionReference struct {
 	ID               int64  `gorm:"column:id" json:"id" form:"id"`
 	OrgId            int64  `gorm:"column:org_id" json:"org_id" form:"org_id"`
 type InspectionDate struct {
 	InspectDate int64
 }
+
+type XtPatientFeedback struct {
+	ID          int64  `gorm:"column:id" json:"id" form:"id"`
+	ProblemType int64  `gorm:"column:problem_type" json:"problem_type" form:"problem_type"`
+	Title       string `gorm:"column:title" json:"title" form:"title"`
+	Content     string `gorm:"column:content" json:"content" form:"content"`
+	Image       string `gorm:"column:image" json:"image" form:"image"`
+	Phone       string `gorm:"column:phone" json:"phone" form:"phone"`
+	TimeQuantum int64  `gorm:"column:time_quantum" json:"time_quantum" form:"time_quantum"`
+	Ctime       int64  `gorm:"column:ctime" json:"ctime" form:"ctime"`
+	Mtime       int64  `gorm:"column:mtime" json:"mtime" form:"mtime"`
+	Status      int64  `gorm:"column:status" json:"status" form:"status"`
+	UserOrgId   int64  `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	AdminUserId int64  `gorm:"column:admin_user_id" json:"admin_user_id" form:"admin_user_id"`
+	AppId       int64  `gorm:"column:app_id" json:"app_id" form:"app_id"`
+}
+
+func (XtPatientFeedback) TableName() string {
+	return "xt_patient_feedback"
+}

models/patient_models.go

 
 	return "xt_inspection"
 }
+
+type XtPatients struct {
+	ID                           int64   `gorm:"column:id" json:"id" form:"id"`
+	UserOrgId                    int64   `gorm:"column:user_org_id" json:"user_org_id" form:"user_org_id"`
+	UserId                       int64   `gorm:"column:user_id" json:"user_id" form:"user_id"`
+	Avatar                       string  `gorm:"column:avatar" json:"avatar" form:"avatar"`
+	PatientType                  int64   `gorm:"column:patient_type" json:"patient_type" form:"patient_type"`
+	DialysisNo                   string  `gorm:"column:dialysis_no" json:"dialysis_no" form:"dialysis_no"`
+	AdmissionNumber              string  `gorm:"column:admission_number" json:"admission_number" form:"admission_number"`
+	Source                       int64   `gorm:"column:source" json:"source" form:"source"`
+	Lapseto                      int64   `gorm:"column:lapseto" json:"lapseto" form:"lapseto"`
+	PartitionId                  int64   `gorm:"column:partition_id" json:"partition_id" form:"partition_id"`
+	BedId                        int64   `gorm:"column:bed_id" json:"bed_id" form:"bed_id"`
+	Name                         string  `gorm:"column:name" json:"name" form:"name"`
+	Alias                        string  `gorm:"column:alias" json:"alias" form:"alias"`
+	Gender                       int64   `gorm:"column:gender" json:"gender" form:"gender"`
+	MaritalStatus                int64   `gorm:"column:marital_status" json:"marital_status" form:"marital_status"`
+	IdCardNo                     string  `gorm:"column:id_card_no" json:"id_card_no" form:"id_card_no"`
+	Birthday                     int64   `gorm:"column:birthday" json:"birthday" form:"birthday"`
+	ReimbursementWayId           int64   `gorm:"column:reimbursement_way_id" json:"reimbursement_way_id" form:"reimbursement_way_id"`
+	HealthCareType               int64   `gorm:"column:health_care_type" json:"health_care_type" form:"health_care_type"`
+	HealthCareNo                 string  `gorm:"column:health_care_no" json:"health_care_no" form:"health_care_no"`
+	HealthCareDueDate            int64   `gorm:"column:health_care_due_date" json:"health_care_due_date" form:"health_care_due_date"`
+	Height                       int64   `gorm:"column:height" json:"height" form:"height"`
+	BloodType                    int64   `gorm:"column:blood_type" json:"blood_type" form:"blood_type"`
+	Rh                           int64   `gorm:"column:rh" json:"rh" form:"rh"`
+	HealthCareDueAlertDate       int64   `gorm:"column:health_care_due_alert_date" json:"health_care_due_alert_date" form:"health_care_due_alert_date"`
+	EducationLevel               int64   `gorm:"column:education_level" json:"education_level" form:"education_level"`
+	Profession                   int64   `gorm:"column:profession" json:"profession" form:"profession"`
+	Phone                        string  `gorm:"column:phone" json:"phone" form:"phone"`
+	HomeTelephone                string  `gorm:"column:home_telephone" json:"home_telephone" form:"home_telephone"`
+	RelativePhone                string  `gorm:"column:relative_phone" json:"relative_phone" form:"relative_phone"`
+	RelativeRelations            string  `gorm:"column:relative_relations" json:"relative_relations" form:"relative_relations"`
+	HomeAddress                  string  `gorm:"column:home_address" json:"home_address" form:"home_address"`
+	WorkUnit                     string  `gorm:"column:work_unit" json:"work_unit" form:"work_unit"`
+	UnitAddress                  string  `gorm:"column:unit_address" json:"unit_address" form:"unit_address"`
+	Children                     int64   `gorm:"column:children" json:"children" form:"children"`
+	ReceivingDate                int64   `gorm:"column:receiving_date" json:"receiving_date" form:"receiving_date"`
+	IsHospitalFirstDialysis      int64   `gorm:"column:is_hospital_first_dialysis" json:"is_hospital_first_dialysis" form:"is_hospital_first_dialysis"`
+	FirstDialysisDate            int64   `gorm:"column:first_dialysis_date" json:"first_dialysis_date" form:"first_dialysis_date"`
+	FirstDialysisHospital        string  `gorm:"column:first_dialysis_hospital" json:"first_dialysis_hospital" form:"first_dialysis_hospital"`
+	PredialysisCondition         string  `gorm:"column:predialysis_condition" json:"predialysis_condition" form:"predialysis_condition"`
+	PreHospitalDialysisFrequency string  `gorm:"column:pre_hospital_dialysis_frequency" json:"pre_hospital_dialysis_frequency" form:"pre_hospital_dialysis_frequency"`
+	PreHospitalDialysisTimes     int64   `gorm:"column:pre_hospital_dialysis_times" json:"pre_hospital_dialysis_times" form:"pre_hospital_dialysis_times"`
+	HospitalFirstDialysisDate    int64   `gorm:"column:hospital_first_dialysis_date" json:"hospital_first_dialysis_date" form:"hospital_first_dialysis_date"`
+	InductionPeriod              int64   `gorm:"column:induction_period" json:"induction_period" form:"induction_period"`
+	InitialDialysis              int64   `gorm:"column:initial_dialysis" json:"initial_dialysis" form:"initial_dialysis"`
+	TotalDialysis                int64   `gorm:"column:total_dialysis" json:"total_dialysis" form:"total_dialysis"`
+	AttendingDoctorId            int64   `gorm:"column:attending_doctor_id" json:"attending_doctor_id" form:"attending_doctor_id"`
+	HeadNurseId                  int64   `gorm:"column:head_nurse_id" json:"head_nurse_id" form:"head_nurse_id"`
+	Evaluate                     string  `gorm:"column:evaluate" json:"evaluate" form:"evaluate"`
+	Diagnose                     string  `gorm:"column:diagnose" json:"diagnose" form:"diagnose"`
+	Remark                       string  `gorm:"column:remark" json:"remark" form:"remark"`
+	RegistrarsId                 int64   `gorm:"column:registrars_id" json:"registrars_id" form:"registrars_id"`
+	Registrars                   string  `gorm:"column:registrars" json:"registrars" form:"registrars"`
+	QrCode                       string  `gorm:"column:qr_code" json:"qr_code" form:"qr_code"`
+	BindingState                 int64   `gorm:"column:binding_state" json:"binding_state" form:"binding_state"`
+	PatientComplains             string  `gorm:"column:patient_complains" json:"patient_complains" form:"patient_complains"`
+	PresentHistory               string  `gorm:"column:present_history" json:"present_history" form:"present_history"`
+	PastHistory                  string  `gorm:"column:past_history" json:"past_history" form:"past_history"`
+	Temperature                  float64 `gorm:"column:temperature" json:"temperature" form:"temperature"`
+	Pulse                        int64   `gorm:"column:pulse" json:"pulse" form:"pulse"`
+	Respiratory                  int64   `gorm:"column:respiratory" json:"respiratory" form:"respiratory"`
+	Sbp                          int64   `gorm:"column:sbp" json:"sbp" form:"sbp"`
+	Dbp                          int64   `gorm:"column:dbp" json:"dbp" form:"dbp"`
+	Status                       int64   `gorm:"column:status" json:"status" form:"status"`
+	CreatedTime                  int64   `gorm:"column:created_time" json:"created_time" form:"created_time"`
+	UpdatedTime                  int64   `gorm:"column:updated_time" json:"updated_time" form:"updated_time"`
+	Nation                       string  `gorm:"column:nation" json:"nation" form:"nation"`
+	NativePlace                  string  `gorm:"column:native_place" json:"native_place" form:"native_place"`
+	Age                          int64   `gorm:"column:age" json:"age" form:"age"`
+	InfectiousNextRecordTime     int64   `gorm:"column:infectious_next_record_time" json:"infectious_next_record_time" form:"infectious_next_record_time"`
+	IsInfectious                 int64   `gorm:"column:is_infectious" json:"is_infectious" form:"is_infectious"`
+	RemindCycle                  int64   `gorm:"column:remind_cycle" json:"remind_cycle" form:"remind_cycle"`
+	ResponseResult               string  `gorm:"column:response_result" json:"response_result" form:"response_result"`
+	IsOpenRemind                 int64   `gorm:"column:is_open_remind" json:"is_open_remind" form:"is_open_remind"`
+	FirstTreatmentDate           int64   `gorm:"column:first_treatment_date" json:"first_treatment_date" form:"first_treatment_date"`
+	DialysisAge                  int64   `gorm:"column:dialysis_age" json:"dialysis_age" form:"dialysis_age"`
+	ExpenseKind                  int64   `gorm:"column:expense_kind" json:"expense_kind" form:"expense_kind"`
+	TellPhone                    string  `gorm:"column:tell_phone" json:"tell_phone" form:"tell_phone"`
+	ContactName                  string  `gorm:"column:contact_name" json:"contact_name" form:"contact_name"`
+}
+
+func (XtPatients) TableName() string {
+
+	return "xt_patients"
+}

service/device_service.go

 	db := readUserDb.Table("xt_device_addmacher as a").Where("a.status = 1")
 	table := XTReadDB().Table("xt_device_zone as x")
 	d := readUserDb.Table("xt_device_mode as m")
+	d2 := XTReadDB().Table("xt_device_number as n")
 	fmt.Print("d", d)
 	fmt.Println("table", table)
+	fmt.Print("d2", d2)
 	if orgid > 0 {
 		db = db.Where("a.user_org_id = ?", orgid)
 	}
 
 	offset := (page - 1) * limit
 
-	err = db.Order("a.ctime asc").Select("a.id,a.serial_number,a.device_type,a.bed_number,a.device_name,a.manufacture_factory,a.service_manufacturer,a.unit_type,a.use_section,a.section_number,a.buy_date,a.install_date,a.start_date,a.maintenace_engineer,a.telephone,a.guarantee_date,a.machine_status,a.user_total,a.disinfection_mode,a.remarks,a.rubbish_date,a.rubbish_reason,a.user_year,a.work_time,a.revers_mode,a.user_org_id,a.status,a.ctime,a.mtime,a.bed_id,x.name,m.device_mode").Count(&total).
-		Joins("Left JOIN sgj_xt.xt_device_zone as x On x.id = a.zone_id").Joins("Left JOIN xt_device_mode as m on m.id = a.unit_type ").Offset(offset).Limit(limit).Scan(&addmahcer).Error
+	err = db.Order("a.ctime asc").Select("a.id,a.serial_number,a.device_type,a.bed_number,a.device_name,a.manufacture_factory,a.service_manufacturer,a.unit_type,a.use_section,a.section_number,a.buy_date,a.install_date,a.start_date,a.maintenace_engineer,a.telephone,a.guarantee_date,a.machine_status,a.user_total,a.disinfection_mode,a.remarks,a.rubbish_date,a.rubbish_reason,a.user_year,a.work_time,a.revers_mode,a.user_org_id,a.status,a.ctime,a.mtime,a.bed_id,x.name,m.device_mode,n.number").Count(&total).
+		Joins("Left JOIN xt_device_mode as m on m.id = a.unit_type ").Joins("left join sgj_xt.xt_device_number as n on n.id = a.bed_id").Joins("Left JOIN sgj_xt.xt_device_zone as x On x.id = n.zone_id").Offset(offset).Limit(limit).Scan(&addmahcer).Error
 
 	if err != nil {
 
 	fmt.Println("tab", tab)
 	d := readUserDb.Table("xt_device_mode as m")
 	fmt.Print("d", d)
+	table := XTReadDB().Table("xt_device_number as n")
+	fmt.Print("table", table)
 	if orgid > 0 {
 		db = db.Where("a.user_org_id = ?", orgid)
 	}
 		db = db.Where("a.device_type = ?", deviceid)
 	}
 	if classid > 0 {
-		error := db.Joins("LEFT JOIN sgj_xt.xt_schedule as x On x.bed_id = a.bed_id").Joins("LEFT JOIN xt_device_mode as d on d.id = a.unit_type").Where("x.user_org_id = ? AND x.schedule_date = ? AND x.schedule_type = ? AND x.status = ?", orgid, timenow, classid, 1).Order("a.ctime desc").Select("a.id,a.serial_number,a.device_type,a.bed_number,a.device_name,a.manufacture_factory,a.service_manufacturer,a.unit_type,a.use_section,a.section_number,a.buy_date,a.install_date,a.start_date,a.maintenace_engineer,a.telephone,a.guarantee_date,a.machine_status,a.user_total,a.disinfection_mode,a.remarks,a.rubbish_date,a.rubbish_reason,a.user_year,a.work_time,a.revers_mode,a.user_org_id,a.status,a.ctime,a.mtime,d.device_mode").Find(&addmahcer).Error
+		error := db.Joins("LEFT JOIN sgj_xt.xt_schedule as x On x.bed_id = a.bed_id").Joins("LEFT JOIN xt_device_mode as d on d.id = a.unit_type").Joins("lefj join sgj_xt.xt_device_number as n on n.id = a.bed_id").Where("x.user_org_id = ? AND x.schedule_date = ? AND x.schedule_type = ? AND x.status = ?", orgid, timenow, classid, 1).Order("a.ctime desc").Select("a.id,a.serial_number,a.device_type,a.bed_number,a.device_name,a.manufacture_factory,a.service_manufacturer,a.unit_type,a.use_section,a.section_number,a.buy_date,a.install_date,a.start_date,a.maintenace_engineer,a.telephone,a.guarantee_date,a.machine_status,a.user_total,a.disinfection_mode,a.remarks,a.rubbish_date,a.rubbish_reason,a.user_year,a.work_time,a.revers_mode,a.user_org_id,a.status,a.ctime,a.mtime,d.device_mode,n.number").Find(&addmahcer).Error
 		fmt.Println("err", error)
 	} else {
-		err = db.Order("a.ctime asc").Select("a.id,a.serial_number,a.device_type,a.bed_number,a.device_name,a.manufacture_factory,a.service_manufacturer,a.unit_type,a.use_section,a.section_number,a.buy_date,a.install_date,a.start_date,a.maintenace_engineer,a.telephone,a.guarantee_date,a.machine_status,a.user_total,a.disinfection_mode,a.remarks,a.rubbish_date,a.rubbish_reason,a.user_year,a.work_time,a.revers_mode,a.user_org_id,a.status,a.ctime,a.mtime,a.bed_id,d.device_mode").Joins("LEFT JOIN xt_device_mode as d on d.id = a.unit_type").Find(&addmahcer).Error
+		err = db.Order("a.ctime asc").Select("a.id,a.serial_number,a.device_type,a.bed_number,a.device_name,a.manufacture_factory,a.service_manufacturer,a.unit_type,a.use_section,a.section_number,a.buy_date,a.install_date,a.start_date,a.maintenace_engineer,a.telephone,a.guarantee_date,a.machine_status,a.user_total,a.disinfection_mode,a.remarks,a.rubbish_date,a.rubbish_reason,a.user_year,a.work_time,a.revers_mode,a.user_org_id,a.status,a.ctime,a.mtime,a.bed_id,d.device_mode,n.number").Joins("LEFT JOIN xt_device_mode as d on d.id = a.unit_type").Joins("left join sgj_xt.xt_device_number as n on n.id = a.bed_id").Find(&addmahcer).Error
 		fmt.Println("错误是什么", err)
 		if err != nil {
 

service/manage_service.go

 	return err
 }
 
+func GetEquitmentByBedID(bedid int64, orgid int64) (models.DeviceAddmacher, error) {
+	addmacher := models.DeviceAddmacher{}
+	err := UserReadDB().Model(&addmacher).Where("bed_id = ? and user_org_id = ? and status = 1", bedid, orgid).First(&addmacher).Error
+	return addmacher, err
+}
+
 func CreateMacher(machers *models.DeviceAddmacher) error {
 
 	//err := writeDb.Create(&machers).Error
 	if orgId > 0 {
 		db = db.Where("x.user_org_id = ?", orgId)
 	}
-	err = db.Group("x.id").Select("x.id,x.date,x.class,x.zone,x.bed_number,x.patient_id,x.contagion,x.dialysis_mode,x.start_time,x.end_time,x.dialysis_hour,x.hyperfiltratio,x.weight_loss,x.warning_value,x.user_total,x.move,x.failure_stage,x.fault_description,x.code_information,x.disinfect_type,x.disinfectant_type,x.disinfection,x.machine_run,x.fluid_path,x.disinfectant,x.disinfection_status,x.disinfection_residue,x.long_time,x.disinfec_startime,x.disinfec_endtime,x.dialysis_checked,x.dialysis_name,x.norms,x.dialysis_concentration,x.germ_checked,x.germ_name,x.germ_number,x.clean,x.sign_name,x.equiment_id,x.bed,p.name,r.user_name").Count(&total).Joins("Left Join sgj_xt.xt_patients as p on p.id = x.patient_id").Joins("Left Join sgj_user_admin_role as r on r.admin_user_id = x.sign_name").Order("x.ctime desc").Offset(offset).Limit(limit).Scan(&infor).Error
+	err = db.Group("x.id").Select("x.id,x.date,x.class,x.zone,x.bed_number,x.patient_id,x.contagion,x.dialysis_mode,x.start_time,x.end_time,x.dialysis_hour,x.hyperfiltratio,x.weight_loss,x.warning_value,x.user_total,x.move,x.failure_stage,x.fault_description,x.code_information,x.disinfect_type,x.disinfectant_type,x.disinfection,x.machine_run,x.fluid_path,x.disinfectant,x.disinfection_status,x.disinfection_residue,x.long_time,x.disinfec_startime,x.disinfec_endtime,x.dialysis_checked,x.dialysis_name,x.norms,x.dialysis_concentration,x.germ_checked,x.germ_name,x.germ_number,x.clean,x.sign_name,x.equiment_id,x.bed,p.name,r.user_name").Count(&total).Joins("Left Join sgj_xt.xt_patients as p on p.id = x.patient_id").Joins("Left Join sgj_user_admin_role as r on r.admin_user_id = x.sign_name").Offset(offset).Limit(limit).Scan(&infor).Error
 	if err != nil {
 
 		return

service/patient_service.go

 	return
 }
 
+func GetLastPatientData(orgid int64) (models.Patients, error) {
+	patients := models.Patients{}
+	err := XTReadDB().Model(&patients).Where("user_org_id = ? and status = 1", orgid).Last(&patients).Error
+	return patients, err
+}
+
+func CreatePatientsNew(patientsNew *models.XtPatientsNew) error {
+
+	err := XTWriteDB().Model(&patientsNew).Create(&patientsNew).Error
+	return err
+}
+
 func EditPatientLapseto(patient *models.Patients, lapseto *models.PatientLapseto) (err error) {
 	utx := writeDb.Begin()
 	err = utx.Model(&models.Patients{}).Where("id=?", patient.ID).Update(map[string]interface{}{"Lapseto": patient.Lapseto}).Error
 		return
 	}
 	err = utx.Model(&models.InfectiousDiseases{}).Where("patient_id=?", patient.ID).Update(map[string]interface{}{"Status": 2, "UpdatedTime": patient.UpdatedTime}).Error
-	fmt.Println("错误是什么。。。。。。。。。。。。。。。。。。。。。。。。。。。", err)
+	fmt.Println("err", err)
 	if err != nil {
 		utx.Rollback()
 		return

service/patientmanage_service.go

 	return
 }
 
+func FindPatientByIdCardNoOne(orgID int64, idCardNo string) (patient models.Patients, err error) {
+	err = readDb.Model(&models.Patients{}).Where("status=1 and user_org_id=? and id_card_no=?", orgID, idCardNo).First(&patient).Error
+	return
+}
+
+func FindPatientByDialysisNoOne(orgID int64, dialysisNo string) (patient models.Patients, err error) {
+	err = readDb.Model(&models.Patients{}).Where("status=1 and user_org_id=? and dialysis_no=?", orgID, dialysisNo).First(&patient).Error
+	return
+}
+
+func FindPatientByMobileOne(mobile string, orgID int64) (patient models.Patients, err error) {
+	err = readDb.Model(&models.Patients{}).Where("phone=? and user_org_id=? and status=1", mobile, orgID).First(&patient).Error
+	return
+}
+
 func GetPatientData(phone string, orgid int64) (*models.XtPatientsNew, error) {
 	var patientnew models.XtPatientsNew
 	var err error
 	} else if advice_type == 0 {
 		db = db.Where("x.advice_type in (?)", []int{1, 3})
 	}
-	if start != 0 {
+	if start > 0 {
 		db = db.Where("x.start_time>=?", start)
 	}
-	if end != 0 {
+	if end > 0 {
 		db = db.Where("start_time<=?", end)
 	}
 	offset := (page - 1) * limit
 		db = db.Where("x.assessment_date <= ?", endtime)
 	}
 	offset := (page - 1) * limit
-	err = db.Count(&total).Order("x.assessment_date").Offset(offset).Limit(limit).Group("x.id").
+	err = db.Count(&total).Order("x.assessment_date desc").Offset(offset).Limit(limit).Group("x.id").
 		Select("x.id,x.user_org_id,x.patient_id,x.assessment_date,x.dialysis_order_id,x.mission,x.dialysis_summary,x.change,x.sj_nurse,x.zl_nurse,x.hd_nurse,x.xj_nurse,x.zl_doctor,x.channel_image,x.puncture,x.puncture_needle,x.puncture_direction,x.status,x.created_time,x.updated_time,x.creater,x.modifier").Scan(&treatment).Error
 	return
 }
 		Joins("JOIN xt_device_zone as dz ON dz.org_id = ? and dz.id=s.partition_id", orgID).
 		Where("do.patient_id=? and do.user_org_id=? and do.stage = 2 and do.status=1", patientID, orgID).Group("s.schedule_date")
 
-	if start != 0 {
+	if start > 0 {
 		db = db.Where("do.dialysis_date>=?", start)
 	}
-	if end != 0 {
+	if end > 0 {
 		db = db.Where("do.dialysis_date<=?", end)
 	}
 	if mode_id > 0 {
 	return err
 }
 
+func UpdateContagions(patientid int64) (models.XtPatientsInfectiousDiseases, error) {
+	diseases := models.XtPatientsInfectiousDiseases{}
+	err := XTWriteDB().Model(&diseases).Where("patient_id = ?", patientid).Update(map[string]interface{}{"status": 2, "updated_time": time.Now().Unix()}).Error
+	return diseases, err
+}
+
 func UpdateCustomer(cdmpatient models.CdmPatients, id int64) error {
 
 	err := PatientWriteDB().Model(&cdmpatient).Where("id=?", id).Update(map[string]interface{}{"name": cdmpatient.Name, "phone": cdmpatient.Phone, "gender": cdmpatient.Gender, "birthday": cdmpatient.Birthday, "diagnose": cdmpatient.Diagnose, "source": cdmpatient.Source, "avatar": cdmpatient.Avatar, "id_card_no": cdmpatient.IdCardNo, "updated_time": cdmpatient.UpdatedTime}).Error
 	return err
 }
 
+func GetInspectionByOrgId(orgid int64) (*models.XtInspectionReference, error) {
+	diseases := models.XtInspectionReference{}
+	err := XTReadDB().Model(&diseases).Where("org_id = ? and status = 1", orgid).Find(&diseases).Error
+	if err == gorm.ErrRecordNotFound {
+		return nil, err
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &diseases, nil
+
+}
+
+//func GetInspectionById(patientid int64,startime int64,endtime int64,orgId int64)(inspection []*models.XtInspectionReference,err error)  {
+//
+//  db := XTReadDB().Table("xt_inspection as x").Where("x.status = 1")
+//  if patientid > 0 {
+//    db = db.Where("x.patient_id = ?", patientid)
+//  }
+//  if startime > 0 {
+//    db = db.Where("x.inspect_date >= ?", startime)
+//  }
+//  if endtime > 0 {
+//    db = db.Where("x.inspect_date<=?", endtime)
+//  }
+//  if orgId > 0 {
+//    db = db.Where("x.org_id = ?", orgId)
+//  }
+//  err = db.Select("x.id,x.patient_id,x.org_id,x.project_id,x.item_id,x.item_name,x.project_name,x.inspect_type,x.inspect_value,x.inspect_date,x.created_time").Find(inspection).Error
+//
+//  return inspection,err
+//}
+
 func GetAllInspection(orgid int64) (inspection []*models.XtInspectionReference, err error) {
 
 	err = XTReadDB().Model(&inspection).Where("org_id = ? and status = 1", orgid).Group("project_name").Find(&inspection).Error
 }
 
 func GetInspection(patientid int64, startime int64, endtime int64, limit int64, page int64, orgid int64) (inspection []*models.Inspection, total int64, err error) {
-	fmt.Print(limit, page)
+
 	db := XTReadDB().Table("xt_inspection as x").Where("x.status = 1")
 	if patientid > 0 {
 		db = db.Where("x.patient_id = ?", patientid)
 	if orgid > 0 {
 		db = db.Where("x.org_id = ?", orgid)
 	}
-	err = db.Count(&total).Order("x.inspect_date").Group("x.id").
+	err = db.Count(&total).Order("x.inspect_date desc").Group("x.id").
 		Select("x.id,x.patient_id,x.org_id,x.project_id,x.item_id,x.item_name,x.project_name,x.inspect_type,x.inspect_value,x.inspect_date,x.created_time").Find(&inspection).Error
 	return inspection, total, err
 }
+
+func GetInspectionDetail(patientid int64, date int64, orgid int64, projectid int64) (inspection []*models.Inspections, err error) {
+
+	db := XTReadDB().Table("xt_inspection as x").Where("x.status =1")
+	table := XTReadDB().Table("xt_inspection_reference as r")
+	fmt.Print("table", table)
+	if patientid > 0 {
+		db = db.Where("x.patient_id = ?", patientid)
+	}
+
+	if date > 0 {
+		db = db.Where("x.inspect_date = ?", date)
+	}
+	if orgid > 0 {
+
+		db = db.Where("x.org_id = ?", orgid)
+	}
+	if projectid > 0 {
+		db = db.Where("x.project_id = ?", projectid)
+	}
+	err = db.Select("x.id,x.patient_id,x.org_id,x.project_id,x.item_id,x.item_name,x.project_name,x.inspect_type,x.inspect_value,x.inspect_date,x.status,x.created_time,x.updated_time,r.range_type,r.range_min,r.range_max,r.range_value,r.range_options,r.unit").Joins("left join xt_inspection_reference as r on r.id = x.item_id ").Scan(&inspection).Error
+	return inspection, err
+}
+
+func CreateFeedBack(feedback *models.XtPatientFeedback) error {
+
+	err := XTWriteDB().Model(&feedback).Create(&feedback).Error
+	return err
+}